decidim-core 0.22.0 → 0.23.3

data/lib/decidim/paddable.rb

@@ -64,10 +64,17 @@ module Decidim
       end
 
       def pad_id
-        @pad_id ||= [
-          reference,
-          Digest::MD5.hexdigest("#{id}-#{Rails.application.secrets.secret_key_base}")
-        ].join("-").slice(0, 50)
+        @pad_id ||= [reference, token].join("-").slice(0, 50)
+      end
+
+      # compatibilize with old versions if no salt available (less secure)
+      def token
+        if defined?(salt) && salt.present?
+          tokenizer = Decidim::Tokenizer.new(salt: salt)
+          return tokenizer.hex_digest(id)
+        end
+
+        Digest::MD5.hexdigest("#{id}-#{Rails.application.secrets.secret_key_base}")
       end
 
       def build_pad_url(id)

data/lib/decidim/resource_manifest.rb

@@ -66,7 +66,7 @@ module Decidim
       component_ids = Decidim::Component.where(participatory_space: component.participatory_space, manifest_name: component_manifest.name).pluck(:id)
       return model_class.none if component_ids.empty?
 
-      model_class.where(component: component_ids)
+      model_class.joins(:component).where(decidim_components: { id: component_ids })
     end
 
     # Finds the current class with the given `model_class_name`

data/lib/decidim/scopable.rb

@@ -23,16 +23,18 @@ module Decidim
     extend ActiveSupport::Concern
 
     included do
-      belongs_to :scope,
-                 foreign_key: "decidim_scope_id",
-                 class_name: "Decidim::Scope",
-                 optional: true
-
       delegate :scopes, to: :organization
 
       validate :scope_belongs_to_organization
     end
 
+    # Whether the resource has scopes enabled or not.
+    #
+    # Returns a boolean.
+    def scopes_enabled?
+      scopes_enabled
+    end
+
     # Gets the children scopes of the object's scope.
     #
     # If it's global, returns the organization's top scopes.
@@ -46,7 +48,7 @@ module Decidim
     #
     # Returns a boolean.
     def has_subscopes?
-      scopes_enabled && subscopes.any?
+      scopes_enabled? && subscopes.any?
     end
 
     # Whether the passed subscope is out of the resource's scope.
@@ -68,6 +70,7 @@ module Decidim
 
     private
 
+    # Validation to ensure that the resource is scoped within the organization's scope.
     def scope_belongs_to_organization
       return if !scope || !organization
 

data/lib/decidim/scopable_component.rb

@@ -10,7 +10,35 @@ module Decidim
     included do
       include Scopable
 
-      delegate :scopes_enabled, to: :participatory_space
+      validate :scope_belongs_to_participatory_space
+
+      # Whether the component or participatory_space has subscopes or not.
+      #
+      # Returns a boolean.
+      def has_subscopes?
+        (scopes_enabled? || participatory_space.scopes_enabled?) && subscopes.any?
+      end
+
+      # Public: Returns the component Scope
+      def scope
+        return participatory_space.scope unless scopes_enabled?
+
+        participatory_space.scopes.find_by(id: settings.scope_id)
+      end
+
+      # Returns a boolean.
+      def scopes_enabled
+        settings.try(:scopes_enabled)
+      end
+
+      private
+
+      # Validation to ensure that the component is scoped within its participatory space Scope.
+      def scope_belongs_to_participatory_space
+        return if !scopes_enabled? || !participatory_space
+
+        errors.add(:scope, :invalid) if participatory_space.out_of_scope?(scope)
+      end
     end
   end
 end

data/lib/decidim/scopable_participatory_space.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # Specific methods for scoped participatory spaces.
+  module ScopableParticipatorySpace
+    extend ActiveSupport::Concern
+
+    included do
+      include Scopable
+
+      belongs_to :scope,
+                 foreign_key: "decidim_scope_id",
+                 class_name: "Decidim::Scope",
+                 optional: true
+    end
+  end
+end

data/lib/decidim/scopable_resource.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # This concern contains the logic related to scopes included by resources.
+  module ScopableResource
+    extend ActiveSupport::Concern
+
+    included do
+      include Scopable
+
+      belongs_to :scope,
+                 foreign_key: "decidim_scope_id",
+                 class_name: "Decidim::Scope",
+                 optional: true
+
+      delegate :scopes_enabled, to: :component
+    end
+  end
+end

data/lib/decidim/search_resource_fields_mapper.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module Decidim
-  # A class with the responsibility to mapp fields between a Searchable and a SearchableResource.
+  # A class with the responsibility to map fields between a Searchable and a SearchableResource.
   class SearchResourceFieldsMapper
+    include ActionView::Helpers::SanitizeHelper
+
     #
     # Declared fields may be of types:
     # - Hash for deep associations.
@@ -61,9 +63,9 @@ module Decidim
     def retrieve_organization(resource)
       if @declared_fields[:organization_id].present?
         organization_id = read_field(resource, @declared_fields, :organization_id)
-        Decidim::Organization.find(organization_id)
+        Decidim::Organization.find_by(id: organization_id)
       else
-        participatory_space(resource).organization
+        participatory_space(resource)&.organization
       end
     end
 
@@ -125,8 +127,19 @@ module Decidim
       return if content.nil?
 
       content = Array.wrap(content).collect do |item|
-        item.is_a?(Hash) ? item[locale] : item
+        text = if item.is_a?(Hash)
+                 item.dig(locale).presence || item.dig("machine_translations", locale) || ""
+               else
+                 item
+               end
+
+        if text.is_a?(String)
+          strip_tags(Decidim::ContentProcessor.render_without_format(text, links: false))
+        else
+          text
+        end
       end
+
       content.respond_to?(:join) ? content.join(" ") : content
     end
   end

data/lib/decidim/searchable.rb

@@ -38,6 +38,10 @@ module Decidim
       searchable_resources.select { |r| r.constantize.ancestors.include?(Decidim::HasComponent) }
     end
 
+    def self.searchable_resources_of_type_comment
+      searchable_resources.select { |r| r == "Decidim::Comments::Comment" }
+    end
+
     included do
       # Always access to this association scoping by_organization
       clazz = self
@@ -80,6 +84,8 @@ module Decidim
         return unless self.class.searchable_resource?(self)
 
         org = self.class.search_resource_fields_mapper.retrieve_organization(self)
+        return unless org
+
         searchables_in_org = searchable_resources.by_organization(org.id)
         if self.class.search_resource_fields_mapper.index_on_update?(self)
           if searchables_in_org.empty?

data/lib/decidim/settings_manifest.rb

@@ -94,7 +94,8 @@ module Decidim
         string: { klass: String, default: nil },
         text: { klass: String, default: nil },
         array: { klass: Array, default: [] },
-        enum: { klass: String, default: nil }
+        enum: { klass: String, default: nil },
+        scope: { klass: Integer, default: nil }
       }.freeze
 
       attribute :type, Symbol, default: :boolean

data/lib/decidim/shareable_with_token.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 be publicly shareable skipping authentication,
+  # using a token with an expiration time.
+  #
+  module ShareableWithToken
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :share_tokens,
+               class_name: "Decidim::ShareToken",
+               foreign_key: "token_for_id",
+               foreign_type: "token_for_type",
+               inverse_of: :token_for,
+               as: :token_for,
+               dependent: :destroy
+
+      # Override this method in the included class with the public url for the shareable resource
+      def shareable_url(_share_token)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/decidim/snippets.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A utility for managing snippets that need to be registered during the view
+  # display and displayed in another part of the application. For example, maps
+  # can register their snippets when the map is displayed but they need to be
+  # added to the <head> section of the document.
+  class Snippets
+    def initialize
+      @snippets = {}
+    end
+
+    def add(category, *snippet)
+      @snippets[category] ||= []
+      @snippets[category].push(*snippet.flatten)
+    end
+
+    def for(category)
+      @snippets[category]
+    end
+
+    def any?(category)
+      self.for(category).present?
+    end
+
+    def display(category)
+      self.for(category)&.join("\n")&.html_safe
+    end
+  end
+end

data/lib/decidim/translatable_attributes.rb

@@ -15,6 +15,11 @@ module Decidim
       #
       # name - The attribute's name
       # type - The attribute's type
+      # options - Options to send to the form class when defining the attribute.
+      # block - An optional block to be called for each attribute name and
+      # locale. The block will receive two arguments, one with the attriubte
+      # name and another with the locale.
+      #
       #
       # Example:
       #
@@ -23,6 +28,11 @@ module Decidim
       #   # and will keep them synchronized with a hash in `name`:
       #   # name = { "ca" => "Hola", "en" => "Hello" }
       #
+      #   translatable_attribute(:name, String) do |name, locale|
+      #     # Do something, like adding validations.
+      #     # name would be `name_ca`, `name_en` and locale `ca` and `en`.
+      #   end
+      #
       # Returns nothing.
       def translatable_attribute(name, type, *options)
         attribute name, Hash, default: {}
@@ -40,6 +50,8 @@ module Decidim
             field = public_send(name) || {}
             public_send("#{name}=", field.merge(locale => super(value)))
           end
+
+          yield(attribute_name, locale) if block_given?
         end
       end
 
@@ -55,22 +67,48 @@ module Decidim
       # attribute - A Hash where keys (strings) are locales, and their values are
       #             the translation for each locale.
       #
-      # organization - An optional Organization to get the default locale from.
+      # given_organization - An optional Organization to get the default locale from.
       #
       # Returns a String with the translation.
-      def translated_attribute(attribute, organization = nil)
+      def translated_attribute(attribute, given_organization = nil)
         return "" if attribute.nil?
         return attribute unless attribute.is_a?(Hash)
 
         attribute = attribute.dup.stringify_keys
-        organization ||= try(:current_organization)
-        organization_locale = organization.try(:default_locale)
+        given_organization ||= try(:current_organization)
+        given_organization ||= try(:organization)
+        organization_locale = given_organization.try(:default_locale)
 
         attribute[I18n.locale.to_s].presence ||
+          machine_translation_value(attribute, given_organization) ||
           attribute[organization_locale].presence ||
           attribute[attribute.keys.first].presence ||
           ""
       end
+
+      # Detects whether we need to show the machine translated version of the
+      # field, or not.
+      #
+      # It uses `RequestStore` so that the method works from inside presenter
+      # classes, which don't have access to controller instance variables.
+      def machine_translation_value(attribute, organization)
+        return unless organization
+        return unless organization.enable_machine_translations?
+
+        attribute.dig("machine_translations", I18n.locale.to_s).presence if must_render_translation?(organization)
+      end
+
+      def must_render_translation?(organization)
+        translations_prioritized = organization.machine_translation_prioritizes_translation?
+        translations_toggled = RequestStore.store[:toggle_machine_translations]
+
+        translations_prioritized != translations_toggled
+      end
+    end
+
+    def default_locale?(locale)
+      locale.to_s == try(:default_locale).to_s ||
+        locale.to_s == try(:current_organization).try(:default_locale).to_s
     end
   end
 end

data/lib/decidim/translatable_resource.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module TranslatableResource
+    extend ActiveSupport::Concern
+
+    included do
+      after_create :machine_translation
+      after_update :machine_translation
+
+      validate :translatable_fields_are_hashes
+
+      def self.translatable_fields(*list)
+        @translatable_fields = list
+
+        @translatable_fields.each do |field|
+          method_name = "#{field}="
+
+          # We're overriding the attribute setter method so that we can reuse the
+          # machine translations. This is to fix a bug encoutered when updating
+          # the resource from a FormObject. The FormObject on the `#create`
+          # action in the controller doesn't have the machine translations loaded,
+          # so they're effectively lost whenever a resource is updated.
+          #
+          # This overriding allows us to keep the old machine translations, so
+          # that we skip some translations requests.
+          define_method(method_name) do |new_value|
+            return super(new_value) if attributes[field.to_s].nil?
+            return super(new_value) unless [new_value, attributes[field.to_s]].all?(Hash)
+            return super(new_value) if new_value.has_key?("machine_translations")
+
+            original_value = attributes[field.to_s]
+
+            new_value = new_value.merge("machine_translations" => original_value["machine_translations"]) if original_value.has_key?("machine_translations")
+
+            super(new_value)
+          end
+        end
+      end
+
+      def self.translatable_fields_list
+        @translatable_fields
+      end
+
+      # Fires a job to start the machine translation process, only if the
+      # service is properly configured and the organization has machine
+      # translations enabled.
+      def machine_translation
+        return unless Decidim.machine_translation_service_klass
+
+        organization = try(:organization)
+        return if organization && !organization.enable_machine_translations
+        return if try(:enable_machine_translations) == false
+
+        Decidim::MachineTranslationResourceJob.perform_later(
+          self,
+          translatable_previous_changes,
+          I18n.locale.to_s
+        )
+      end
+
+      def translatable_previous_changes
+        previous_changes.slice(*self.class.translatable_fields_list)
+      end
+
+      def translatable_fields_are_hashes
+        self.class.translatable_fields_list.each do |field|
+          value = send(field).presence
+          next if value.nil? || value.is_a?(Hash)
+
+          errors.add(field, :invalid)
+        end
+      end
+    end
+  end
+end