decidim-core 0.22.0 → 0.23.0

data/lib/decidim/geocodable.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "geocoder/stores/active_record"
+
+module Decidim
+  # This concern overrides some of the Active Record functionality injected by
+  # the Geocoder gem in order to pass the geocoding searches through Decidim's
+  # own API which configures the geocoder correctly for each search. This is
+  # used when the `model.geocode` and `model.reverse_geocode` methods are called
+  # for the Active Record models.
+  #
+  # NOTE: This module is automatically loaded for all active record models in
+  #       the "decidim.geocoding_extensions" initializer. It does not need to be
+  #       included separately into any models.
+  module Geocodable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Avoid double loading Geocoder::Store::ActiveRecord since it's already
+      # loaded by this concern (below in the included block).
+      def geocoder_init(options)
+        @geocoder_options = {} unless defined?(@geocoder_options)
+        @geocoder_options.merge! options
+      end
+    end
+
+    included do
+      include Geocoder::Store::ActiveRecord
+
+      private
+
+      def do_lookup(_reverse = false)
+        RecordGeocoder.with_record(self) do
+          super
+        end
+      end
+    end
+
+    module RecordGeocoder
+      def self.with_record(record)
+        @record = record
+        yield
+      ensure
+        @record = nil
+      end
+
+      def self.utility
+        return if @record.blank?
+        return unless Decidim::Map.available?(:geocoding)
+        return unless @record.respond_to?(:organization)
+
+        Decidim::Map.geocoding(organization: @record.organization)
+      end
+
+      def self.search(query, options = {})
+        if (util = utility)
+          util.search(query, options.compact)
+        else
+          Geocoder.search(query, options)
+        end
+      end
+
+      # Make the calculation functions work within the geocoded record, e.g.
+      # `distance_to`.
+      module Calculations
+        extend Geocoder::Calculations
+      end
+    end
+
+    # Change the `Geocoder` module reference under the Geocoder::Store::Base
+    # module which initiates the geocoding searches. This allows passing the
+    # geocoding queries through Decidim's own API that configures the geocoder
+    # correctly for each query.
+    #
+    # Overrides this call with the method defined above:
+    # https://git.io/JJEpq
+    ::Geocoder::Store::Base.const_set(:Geocoder, RecordGeocoder)
+  end
+end

data/lib/decidim/has_attachments.rb

@@ -43,5 +43,15 @@ module Decidim
         documents.reject(&:attachment_collection_id?)
       end
     end
+
+    # Attachment context for the file uploaders checks (e.g. which kind of files
+    # the user is allowed to upload in this context).
+    #
+    # Override this in the model class if it is for a different context.
+    #
+    # Returns a Symbol.
+    def attachment_context
+      :participant
+    end
   end
 end

data/lib/decidim/has_upload_validations.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module HasUploadValidations
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def validates_upload(attribute, options = {})
+        max_size = options[:max_size] || ->(record) { record.maximum_upload_size }
+
+        validates(
+          attribute,
+          file_size: { less_than_or_equal_to: max_size },
+          uploader_content_type: true
+        )
+      end
+
+      def validates_avatar(attribute = :avatar)
+        validates_upload(
+          attribute,
+          max_size: ->(record) { record.maximum_avatar_size }
+        )
+      end
+    end
+
+    def maximum_upload_size
+      Decidim.organization_settings(organization).upload_maximum_file_size
+    end
+
+    def maximum_avatar_size
+      Decidim.organization_settings(organization).upload_maximum_file_size_avatar
+    end
+  end
+end

data/lib/decidim/map.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+# Decidim configuration.
+module Decidim
+  # A module containing the map functionality for Decidim.
+  module Map
+    autoload :Autocomplete, "decidim/map/autocomplete"
+    autoload :DynamicMap, "decidim/map/dynamic_map"
+    autoload :Geocoding, "decidim/map/geocoding"
+    autoload :Provider, "decidim/map/provider"
+    autoload :StaticMap, "decidim/map/static_map"
+    autoload :Utility, "decidim/map/utility"
+    autoload :Frontend, "decidim/map/frontend"
+
+    # Public: Returns a boolean indicating whether the mapping functionality has
+    # been configured.
+    #
+    # @return [Boolean] A boolean indicating whether the mapping functionality
+    #   has been configured.
+    def self.configured?
+      configuration.present?
+    end
+
+    # Public: Returns a boolean indicating if the category of mapping services
+    # is available for this instance that the provided key represents.
+    #
+    # @param *categories [Symbol] The utility category key to check the
+    #   availability for.
+    # @return [Boolean] A boolean indicating if the category of mapping services
+    #   is available.
+    def self.available?(*categories)
+      categories.all? { |category| utility_class(category).present? }
+    end
+
+    # Public: Returns the full maps configuration hash.
+    #
+    # @return [Hash] The full map functionality configuration hash.
+    def self.configuration
+      Decidim.maps
+    end
+
+    # Public: Creates a new instance of the correct mapping utility class for
+    # the category specified by the key argument.
+    #
+    # @param category [Symbol] The utility category key for the utility to be
+    #   created.
+    # @param options [Hash] The options for the utility constructor method.
+    # @return [Decidim::Map::Utility] A new instance of the mapping utility.
+    def self.utility(category, options)
+      return unless (klass = utility_class(category))
+
+      config = utility_configuration(category)
+      options[:config] = config.except(:provider)
+      klass.new(options)
+    end
+
+    # Public: Returns the utility class module namespace for each category of
+    # map utilities. The configured utility class (through Decidim.maps) is
+    # should be under these namespaces.
+    #
+    # @return [Hash<Symbol, Module>] The modules within which the utility
+    #   classes should be defined in.
+    def self.utility_modules
+      @utility_modules ||= {}
+    end
+
+    # Public: Registers a new category of map modules.
+    #
+    # @param category [Symbol] The key for the category.
+    # @param mod [Module] The module to be assigned for the category.
+    # @return [Module] The module which was assigned for the category.
+    def self.register_category(category, mod)
+      @utility_modules ||= {}
+      @utility_modules[category] = mod
+
+      # Dynamically define the category method.
+      module_eval %{
+        def self.#{category}(options)
+          utility(:#{category}, options)
+        end
+      }, __FILE__, __LINE__ - 4
+
+      mod
+    end
+
+    # Public: Unregisters the given category of map modules. Mostly used for
+    # testing but there can be also actual use cases for this.
+    #
+    # @param category [Symbol] The key for the category.
+    # @return [Module, nil] The module which was previously assigned for the
+    #   category or nil if no module was previously assigned for it.
+    def self.unregister_category(category)
+      return unless @utility_modules
+
+      mod = @utility_modules.delete(category)
+      @utility_configuration.delete(category) if @utility_configuration
+      singleton_class.instance_eval do
+        undef_method(category) if method_defined?(category)
+      end
+      mod
+    end
+
+    # Public: Sets and returns the utility specific configuration hash which
+    # contains the prepared configuration objects for each category of
+    # utilities.
+    #
+    # For example, given the following configuration:
+    #   Decidim.configure do |config|
+    #     config.maps = {
+    #       provider: :osm,
+    #       api_key: "apikey",
+    #       global_conf: "value",
+    #       dynamic: {
+    #         tile_layer: {
+    #           url: "https://tiles.example.org/{z}/{x}/{y}.png?{foo}",
+    #           foo: "bar"
+    #         }
+    #       },
+    #       static: {
+    #         url: "https://staticmap.example.org/"
+    #       },
+    #       geocoding: {
+    #         provider: :alternative,
+    #         api_key: "gc_apikey",
+    #         host: "https://nominatim.example.org/"
+    #       }
+    #     }
+    #   end
+    #
+    # This would result in the following kind of configuration hash returned
+    # by this method:
+    #   {
+    #     dynamic: {
+    #       provider: :osm,
+    #       api_key: "apikey",
+    #       global_conf: "value",
+    #       tile_layer: {
+    #         url: "https://tiles.example.org/{z}/{x}/{y}.png?{foo}",
+    #         foo: "bar"
+    #       }
+    #     }
+    #     static: {
+    #       provider: :osm,
+    #       api_key: "apikey",
+    #       global_conf: "value",
+    #       url: "https://staticmap.example.org/"
+    #     }
+    #     geocoding: {
+    #       provider: :alternative,
+    #       api_key: "gc_apikey",
+    #       global_conf: "value",
+    #       host: "https://nominatim.example.org/"
+    #     }
+    #   }
+    #
+    # @param category [Symbol, nil] The key of the utility category for which to
+    #   fetch the configuration for. When nil, returns the whole configuration
+    #   hash.
+    # @return [Hash] The configuration hash.
+    def self.utility_configuration(category = nil)
+      @utility_configuration ||= {}.tap do |config|
+        break {} unless configuration
+
+        global_config = configuration.except(*utility_modules.keys)
+        utility_modules.keys.each do |key|
+          utility_config = configuration.fetch(key, {})
+          next if utility_config == false
+
+          unless utility_config.is_a?(Hash)
+            config[key] = global_config
+            next
+          end
+
+          config[key] = global_config.merge(utility_config)
+        end
+      end
+      return @utility_configuration[category] if category
+
+      @utility_configuration
+    end
+
+    # Public: Resets the utility configuration to its initial state so that it
+    # is reloaded when utility_configuration is called the next time. It should
+    # not be necessary to call this ever but it is useful for the tests as the
+    # configurations can change.
+    #
+    # @return [nil]
+    def self.reset_utility_configuration!
+      @utility_configuration = nil
+    end
+
+    # Public: Returns the full utility class name in the correct module
+    # namespace for the given utility category. For example, if the provider
+    # :osm is configured for the :dynamic utilities, the utility class returned
+    # by this method is `Decidim::Map::Provider::DynamicMap::Osm`.
+    #
+    # @param category [Symbol] The category of utilities. E.g. `:dynamic`.
+    # @return [Class] The configured mapping service provider key.
+    def self.utility_class(category)
+      return unless (ns = utility_modules[category])
+
+      config = utility_configuration(category)
+      return if config.blank?
+      return unless (key = config[:provider])
+
+      # Define the last part of the class name from the category provider's key,
+      # e.g. by turning `:osm` to "Osm" or `:some_service` to "SomeService".
+      subclass_name = key.to_s.camelize
+      return unless ns.const_defined?(subclass_name)
+
+      ns.const_get(subclass_name)
+    end
+  end
+end

data/lib/decidim/map/autocomplete.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Map
+    # A base class for autocomplete geocoding functionality, common to all
+    # autocomplete map services.
+    class Autocomplete < Map::Frontend
+      # A builder for the geocoding autocompletion to be attached to the views.
+      # Provides all the necessary functionality to initialize the front-end
+      # geocoding autocompletion functionality.
+      class Builder < Decidim::Map::Frontend::Builder
+        # Displays the geocoding field element's markup for the view.
+        #
+        # @param object_name [String, Symbol] The name for the object for which
+        #   the field is generated for.
+        # @param method [String, Symbol] The method/property in the object that
+        #   the field is for.
+        # @param options [Hash] Extra options for the field.
+        # @return [String] The field element's markup.
+        def geocoding_field(object_name, method, options = {})
+          options[:autocomplete] ||= "off"
+
+          template.text_field(
+            object_name,
+            method,
+            options.merge("data-decidim-geocoding" => view_options.to_json)
+          )
+        end
+      end
+
+      # This module will be included in the main application's form builder in
+      # order to provide the geocoding_field method for the normal form
+      # builders. This allows you to include geocoding autocompletion in the
+      # forms using the following code:
+      #
+      #   <%= form_for record do |form| %>
+      #     <%= form.geocoding_field(:address) %>
+      #   <% end %>
+      module FormBuilder
+        def geocoding_field(attribute, options = {}, geocoding_options = {})
+          @autocomplete_utility ||= Decidim::Map.autocomplete(
+            organization: @template.current_organization
+          )
+          return text_field(attribute, options) unless @autocomplete_utility
+
+          # Decidim::Map::Autocomplete::Builder
+          builder = @autocomplete_utility.create_builder(
+            @template,
+            geocoding_options
+          )
+
+          unless @template.snippets.any?(:geocoding)
+            @template.snippets.add(:geocoding, builder.stylesheet_snippets)
+            @template.snippets.add(:geocoding, builder.javascript_snippets)
+
+            # This will display the snippets in the <head> part of the page.
+            @template.snippets.add(:head, @template.snippets.for(:geocoding))
+          end
+
+          field(attribute, options) do |opts|
+            builder.geocoding_field(@object_name, attribute, opts)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decidim/map/dynamic_map.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Map
+    # A base class for dynamic mapping functionality, common to all dynamic map
+    # services.
+    class DynamicMap < Map::Frontend
+      # Creates a builder class for the front-end that is used to build the map
+      # HTML markup.
+      #
+      # @param (see Decidim::Map::DynamicMap::Builder#initialize)
+      #
+      # @return [Decidim::Map::DynamicMap::Builder] The builder object that can
+      #   be used to build the map's markup.
+      def create_builder(template, options = {})
+        builder_class.new(template, builder_options.merge(options))
+      end
+
+      # Returns the builder class for the map. Allows fetching the class name
+      # dynamically also in the utility classes that extend this class.
+      #
+      # @return [Class] The class for the builder object.
+      def builder_class
+        self.class.const_get(:Builder)
+      end
+
+      # Returns the options for the default builder object.
+      #
+      # @return [Hash] The default options for the map builder.
+      def builder_options
+        {
+          marker_color: organization.colors.fetch("primary", "#ef604d"),
+          tile_layer: tile_layer_configuration
+        }
+      end
+
+      protected
+
+      # Prepares the tile layer configuration hash to be passed for the
+      # builder.
+      #
+      # @return The tile layer configuration hash.
+      def tile_layer_configuration
+        tile_layer = configuration.fetch(:tile_layer, {})
+        tile_layer_options = tile_layer.except(:url).tap do |config|
+          config.fetch(:api_key, nil) == true &&
+            config[:api_key] = configuration.fetch(:api_key, nil)
+        end
+
+        {
+          url: tile_layer.fetch(:url, nil),
+          options: tile_layer_options
+        }
+      end
+
+      # A builder for the dynamic maps to be used in the views. Provides all the
+      # necessary functionality to display and initialize the maps.
+      class Builder < Decidim::Map::Frontend::Builder
+        # Displays the map element's markup for the view.
+        #
+        # @param html_options [Hash] Extra options to pass to the map element.
+        # @return [String] The map element's markup.
+        def map_element(html_options = {})
+          map_html_options = {
+            "data-decidim-map" => view_options.to_json,
+            # The data-markers-data is kept for backwards compatibility
+            "data-markers-data" => options.fetch(:markers, []).to_json
+          }.merge(html_options)
+
+          content = template.capture { yield }.html_safe if block_given?
+
+          template.content_tag(:div, map_html_options) do
+            (content || "")
+          end
+        end
+
+        # @see Decidim::Map::View::Builder#stylesheet_snippets
+        def stylesheet_snippets
+          template.stylesheet_link_tag("decidim/map")
+        end
+
+        # @see Decidim::Map::View::Builder#javascript_snippets
+        def javascript_snippets
+          template.javascript_include_tag("decidim/map/provider/default")
+        end
+      end
+    end
+  end
+end