decidim-core 0.22.0 → 0.23.3

data/lib/decidim/map/provider/dynamic_map/osm.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Map
+    module Provider
+      module DynamicMap
+        # The dynamic map utility class for the OpenStreetMap based map services
+        class Osm < ::Decidim::Map::DynamicMap
+        end
+      end
+    end
+  end
+end

data/lib/decidim/map/provider/geocoding/here.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Map
+    module Provider
+      module Geocoding
+        # The geocoding utility class for the HERE geocoding service
+        class Here < ::Decidim::Map::Geocoding
+          # @see Decidim::Map::Geocoding#address
+          def address(coordinates, options = {})
+            # Pass in a radius of 50 meters as an extra attribute for the HERE
+            # API. Also sort the results by distance and pass a maxresults
+            # attribute of 5.
+            results = search(coordinates + [50], {
+              params: {
+                sortby: :distance,
+                maxresults: 5
+              }
+            }.merge(options))
+            return if results.empty?
+
+            # Always prioritize house number results, even if they are not as
+            # close as street level matches.
+            hn_result = results.find do |r|
+              r.data["MatchLevel"] == "houseNumber"
+            end
+            return hn_result.address if hn_result
+
+            # Some of the matches that have "MatchLevel" == "street" do not even
+            # contain the street name unless they also have the "Street" key in
+            # the "MatchQuality" attribute defined.
+            street_result = results.find do |r|
+              r.data["MatchQuality"].has_key?("Street")
+            end
+            return street_result.address if street_result
+
+            # Otherwise, sort the results based on their exact distances from
+            # the given coordinates (default functionality).
+            results.sort! do |result1, result2|
+              dist1 = Geocoder::Calculations.distance_between(
+                result1.coordinates,
+                coordinates
+              )
+              dist2 = Geocoder::Calculations.distance_between(
+                result2.coordinates,
+                coordinates
+              )
+
+              dist1 <=> dist2
+            end
+
+            results.first.address
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decidim/map/provider/geocoding/osm.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Map
+    module Provider
+      module Geocoding
+        # The geocoding utility class for OpenStreetMap's (OSM) Nominatim based
+        # geocoding services
+        class Osm < ::Decidim::Map::Geocoding
+          # @see Decidim::Map::Geocoding#handle
+          def handle
+            @handle ||= :nominatim
+          end
+
+          protected
+
+          # @see Decidim::Map::Utility#configure!
+          def configure!(config)
+            @configuration = config.merge(
+              http_headers: {
+                "User-Agent" => "Decidim/#{Decidim.version} (#{Decidim.application_name})",
+                "Referer" => organization.host
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decidim/map/provider/here.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Map
+    # A module to contain map functionality specific to the HERE map provider.
+    module Provider
+      module Autocomplete
+        autoload :Here, "decidim/map/provider/autocomplete/here"
+      end
+      module Geocoding
+        autoload :Here, "decidim/map/provider/geocoding/here"
+      end
+      module DynamicMap
+        autoload :Here, "decidim/map/provider/dynamic_map/here"
+      end
+      module StaticMap
+        autoload :Here, "decidim/map/provider/static_map/here"
+      end
+    end
+  end
+end

data/lib/decidim/map/provider/osm.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Map
+    # A module to contain map functionality specific to the OpenStreetMap (OSM)
+    # based map providers.
+    module Provider
+      module Autocomplete
+        autoload :Osm, "decidim/map/provider/autocomplete/osm"
+      end
+      module Geocoding
+        autoload :Osm, "decidim/map/provider/geocoding/osm"
+      end
+      module DynamicMap
+        autoload :Osm, "decidim/map/provider/dynamic_map/osm"
+      end
+      module StaticMap
+        autoload :Osm, "decidim/map/provider/static_map/osm"
+      end
+    end
+  end
+end

data/lib/decidim/map/provider/static_map/here.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Map
+    module Provider
+      module StaticMap
+        # The static map utility class for the HERE maps service
+        class Here < ::Decidim::Map::StaticMap
+          # @See Decidim::Map::StaticMap#url_params
+          def url_params(latitude:, longitude:, options: {})
+            params = {
+              c: "#{latitude}, #{longitude}",
+              z: options[:zoom] || 15,
+              w: options[:width] || 120,
+              h: options[:height] || 120,
+              f: 1
+            }
+
+            api_key = configuration[:api_key]
+            if api_key.is_a?(Array)
+              # Legacy way of configuring the API credentials
+              params[:app_id] = api_key[0]
+              params[:app_code] = api_key[1]
+            else
+              # The new way of configuring the API key
+              params[:apiKey] = api_key
+            end
+
+            params
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decidim/map/provider/static_map/osm.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Map
+    module Provider
+      module StaticMap
+        # The static map utility class for the OpenStreetMap based map services
+        class Osm < ::Decidim::Map::StaticMap
+          # @See Decidim::Map::StaticMap#url_params
+          def url_params(latitude:, longitude:, options: {})
+            # This is the format used by osm-static-maps which is not an
+            # official OSM product but it should be rather easy to setup. For
+            # further information, see:
+            # https://github.com/jperelli/osm-static-maps
+            {
+              geojson: {
+                type: "Point",
+                coordinates: [longitude, latitude]
+              }.to_json,
+              zoom: options[:zoom] || 15,
+              width: options[:width] || 120,
+              height: options[:height] || 120
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decidim/map/static_map.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Map
+    # A base class for static mapping functionality, common to all static map
+    # services.
+    class StaticMap < Map::Utility
+      # Creates a link for the static maps. This will point to an external map
+      # service where the user can further explore the given location.
+      #
+      # @param params [Hash] The parameters for the static map URL
+      # @option params [Float, String] :latitude The latitude of the map
+      #   position to be linked to
+      # @option params [Float, String] :longitude The longitude of the map
+      #   position to be linked to
+      # @option params [Hash] :options Extra options that can be provided to the
+      #   map URL containing the following keys:
+      #   * zoom: A number to represent the zoom value of the map (default 17)
+      #
+      # @return [String] The link where the static map images link to.
+      def link(latitude:, longitude:, options: {})
+        zoom = options.fetch(:zoom, 17)
+        base_url = configuration.fetch(
+          :link,
+          "https://www.openstreetmap.org/"
+        )
+
+        params = { mlat: latitude, mlon: longitude }
+        fragment = "map=#{zoom}/#{latitude}/#{longitude}"
+
+        URI.parse(base_url).tap do |uri|
+          uri.query = URI.encode_www_form(params)
+          uri.fragment = fragment
+        end.to_s
+      end
+
+      # Creates a URL that generates a static map image for the given map
+      # location with the given options.
+      #
+      # @param params [Hash] The parameters for the static map URL
+      # @option params [Float, String] :latitude The latitude of the map
+      #   position
+      # @option params [Float, String] :longitude The longitude of the map
+      #   position
+      # @option params [Hash] :options Extra options that can be provided to
+      #   the underlying map service to generate the image with containing the
+      #   following keys:
+      #   * zoom: A number to represent the zoom value of the map image (default
+      #     15)
+      #   * width: A number to represent the pixel width of the map image
+      #     (default 120)
+      #   * height: A number to represent the pixel height of the map image
+      #     (default 120)
+      #
+      # @return [String] The URL to request for the static map image.
+      def url(latitude:, longitude:, options: {})
+        map_url = configuration.fetch(:url, nil)
+        return unless map_url
+
+        # If a lambda or proc is passed as the :static_map_url configuration.
+        if map_url.respond_to?(:call)
+          return map_url.call(
+            latitude: latitude,
+            longitude: longitude,
+            options: options
+          ).to_s
+        end
+
+        # Fetch the "extra" parameters from the configured map URL
+        configured_uri = URI.parse(map_url)
+        configured_params = Rack::Utils.parse_nested_query(
+          configured_uri.query
+        ).symbolize_keys
+
+        # Generate a base URL without the URL parameters
+        configured_uri.query = nil
+        configured_uri.fragment = nil
+        base_url = configured_uri.to_s
+
+        # Generate the actual parameters by combining the configured parameters
+        # with the provider specific parameters, giving priority to the
+        # dynamically set parameters.
+        params = configured_params.merge(
+          url_params(
+            latitude: latitude,
+            longitude: longitude,
+            options: options
+          )
+        )
+
+        # Generate the actual URL to call with all the prepared parameters.
+        URI.parse(base_url).tap do |uri|
+          uri.query = URI.encode_www_form(params)
+        end.to_s
+      end
+
+      # Prepares the URL params for the static map URL.
+      #
+      # @param (see #url)
+      #
+      # @return [Hash] The parameters to pass to the static map image URL.
+      def url_params(latitude:, longitude:, options: {})
+        {
+          latitude: latitude,
+          longitude: longitude,
+          zoom: options.fetch(:zoom, 15),
+          width: options.fetch(:width, 120),
+          height: options.fetch(:height, 120)
+        }
+      end
+
+      # Creates a static map image data for the given map location with the
+      # given options.
+      #
+      # @param (see #url)
+      #
+      # @return [String] The raw data for the image.
+      def image_data(latitude:, longitude:, options: {})
+        request_url = url(
+          latitude: latitude,
+          longitude: longitude,
+          options: options
+        )
+        return "" unless request_url
+
+        response = Faraday.get(request_url) do |req|
+          req.headers["Referer"] = organization.host
+        end
+        response.body
+      end
+    end
+  end
+end

data/lib/decidim/map/utility.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Map
+    # Generic map utility that will be used for providing different map
+    # functionality to the application.
+    #
+    # @abstract
+    class Utility
+      attr_reader :organization, :configuration, :locale
+
+      # Initializes the map utility.
+      #
+      # @param options [Hash] The options for the map utility
+      # @option options [Decidim::Organization] :organization The organization
+      #   where the map functionality is used
+      # @option options [String] :config The configuration hash specific to the
+      #   utility
+      # @option options [String] :locale The locale to use for the queries
+      def initialize(organization:, config:, locale: I18n.locale.to_s)
+        @organization = organization
+        @locale = locale
+        configure!(config)
+      end
+
+      protected
+
+      # Sets the local configurations for the utility.
+      #
+      # @param config [Hash] The whole configuration hash.
+      #
+      # @return [Hash] The configuration hash.
+      def configure!(config)
+        @configuration = config
+      end
+    end
+  end
+end

data/lib/decidim/newsletter_participant.rb

@@ -9,10 +9,8 @@ module Decidim
 
     included do
       # Returns a User collection Participants
-      # This is the default, if you want, you can overwrite in each Class to be export.
-      def self.newsletter_participant_ids(_component)
-        nil
-      end
+      # Behaves as an abstract method, you must overwrite it in each includer class.
+      def self.newsletter_participant_ids(_component); end
     end
   end
 end

data/lib/decidim/organization_settings.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+module Decidim
+  #
+  # Takes care of holding and accessing organization settings for each
+  # organization or the default organization.
+  #
+  class OrganizationSettings < OpenStruct
+    class << self
+      # Fetches or creates a settings object for the given organization.
+      #
+      # @param organization [Decidim::Organization] The organization in
+      #   question.
+      # @return [Decidim::OrganizationSettings] The settings object.
+      def for(organization)
+        # Before the organization has an ID attached to it, it cannot be stored
+        # to the registry.
+        return new(organization) if organization.new_record?
+
+        @registry ||= {}
+        @registry[organization.id] ||= new(organization)
+      end
+
+      # Reloads the settings object for a given organization. Should be called
+      # when the configurations have changed and need to be reloaded.
+      #
+      # @param organization [Decidim::Organization] The organization in question.
+      # @return [Decidim::OrganizationSettings] The settings object.
+      def reload(organization)
+        @registry.delete(organization.id) if @registry
+        self.for(organization)
+      end
+
+      # The settings should be reset during the tests in order for the new tests
+      # to always load the latest settings. The results of the previous tests
+      # should not affect the settings of the following test.
+      def reset!
+        @registry = {}
+      end
+
+      # Returns the default configuration value for the given setting key chain.
+      #
+      # For example:
+      #
+      #   Decidim::OrganizationSettings.default(:upload, :maximum_file_size, :default)
+      #   #=> 10
+      #
+      # Note: this cannot fetch the default settings from the class instance
+      # variable "defaults" because that would cause an infinite loop.
+      #
+      # @param *chain [Symbol, String] The configuration key(s) to dig into
+      #   inside the default configurations hash.
+      # @return The value found from the default configurations hash.
+      def default(*chain)
+        return if chain.blank?
+
+        configs = defaults_hash
+        while (lookup = chain.shift)
+          configs = configs[lookup.to_s]
+          return configs if chain.empty?
+          return unless configs.is_a?(Hash)
+        end
+
+        nil
+      end
+
+      # This is a class level helper to get a "dummy" default settings object
+      # that responds to the same methods as the normal organization specific
+      # settings objects. This allows for the following kind of syntactic sugar:
+      #
+      #   settings = Decidim::OrganizationSettings.for(actual_org)
+      #   settings.target_config_accessor #=> returns the organization setting
+      #
+      #   settings = Decidim::OrganizationSettings.defaults
+      #   settings.target_config_accessor #=> returns the default setting
+      #
+      # This can be used through the Decidim module as follows:
+      #
+      #   Decidim.organization_settings(org).target_config_accessor
+      #   #=> returns the organization specific setting
+      #
+      #   Decidim.organization_settings(model_beloging_to_org).target_config_accessor
+      #   #=> returns the organization specific setting for model's organization
+      #
+      #   Decidim.organization_settings(nil).target_config_accessor
+      #   #=> returns the default setting
+      #
+      # @return [Decidim::OrganizationSettings] The default settings object.
+      def defaults
+        @defaults ||= new(OpenStruct.new)
+      end
+
+      private
+
+      # Stores the default settings hash which is used to create the settings
+      # objects. This will provide all the missing configuration values for the
+      # final object if it does not define some of the values.
+      #
+      # Note: This cannot be stored in a class variable because it would change
+      # the arrays into comma separated strings.
+      #
+      # @return [Hash] The default settings hash.
+      def defaults_hash
+        {
+          "upload" => {
+            "allowed_file_extensions" => {
+              "default" => %w(jpg jpeg gif png bmp pdf rtf txt),
+              "admin" => %w(jpg jpeg gif png bmp pdf doc docx xls xlsx ppt ppx rtf txt odt ott odf otg ods ots),
+              "image" => %w(jpg jpeg gif png bmp ico)
+            },
+            "allowed_content_types" => {
+              "default" => %w(
+                image/*
+                application/pdf
+                application/rtf
+                text/plain
+              ),
+              "admin" => %w(
+                image/*
+                application/vnd.oasis.opendocument
+                application/vnd.ms-*
+                application/msword
+                application/vnd.ms-word
+                application/vnd.openxmlformats-officedocument
+                application/vnd.oasis.opendocument
+                application/pdf
+                application/rtf
+                text/plain
+              )
+            },
+            "maximum_file_size" => {
+              "default" => 10,
+              "avatar" => 5
+            }
+          }
+        }
+      end
+    end
+
+    def initialize(organization)
+      # This maps the local configuration top level keys to the methods/column
+      # names in the organization model that provide the values for these
+      # settings.
+      keys_map = { upload: :file_upload_settings }
+
+      # Pass a configuration hash to the parent constructor that combines the
+      # default settings with the organization level settings. This ensures that
+      # all configurations have values even when the organization settings do
+      # not define them.
+      super(
+        keys_map.map do |config, method|
+          [
+            config.to_s,
+            generate_config(
+              organization.public_send(method) || {},
+              self.class.default(config)
+            )
+          ]
+        end.to_h
+      )
+
+      keys_map.keys.each do |config|
+        define_config_accessors(public_send(config), [config])
+      end
+    end
+
+    def wrap_upload_maximum_file_size(value)
+      value.megabytes
+    end
+
+    def wrap_upload_maximum_file_size_avatar(value)
+      value.megabytes
+    end
+
+    def wrap_upload_allowed_content_types(value)
+      content_type_array(value)
+    end
+
+    def wrap_upload_allowed_content_types_admin(value)
+      content_type_array(value)
+    end
+
+    private
+
+    # Generates a final settigns configuration struct from the given settings
+    # hash. Combines the given defaults with the settings hash.
+    #
+    # @param hash [Hash] The configurations hash.
+    # @param default [Hash] The default configurations.
+    # @return [OpenStruct] The configuration struct.
+    def generate_config(hash, default = {})
+      OpenStruct.new(
+        default.deep_merge(hash).map do |key, value|
+          value = generate_config(value) if value.is_a?(Hash)
+          [key, value]
+        end.to_h
+      )
+    end
+
+    # Turns the stars into wildcard regular expression matches in the matching
+    # strings.
+    #
+    # @param [Array<String>] An array of glob strings to match against.
+    # @return [Array<Regexp>] An array of regular expressions to match against.
+    def content_type_array(types)
+      types.map do |match_string|
+        Regexp.new(Regexp.escape(match_string).gsub("\\*", ".*?"))
+      end
+    end
+
+    # This defines all the config accessors for the configuration parameters
+    # that can be directly called for the settings instance without having to
+    # "drill down" to the child structs. For example, if the whole settings
+    # object was initialized with the following hash:
+    #
+    #   {
+    #     "upload" => {
+    #       "allowed_file_extensions" => {
+    #         "default" => %w(jpg jpeg),
+    #         "admin" => %w(jpg jpeg gif png)
+    #       }
+    #     },
+    #     "another_thing" => {
+    #       "bleep" => "bloop",
+    #       "foo" => {
+    #         "bar" => 1
+    #         "baz" => 2
+    #       }
+    #     }
+    #   }
+    #
+    # This would automatically generate the following methods in the settings
+    # instance:
+    #
+    #   - upload_allowed_file_extensions #=> ["jpg", "jpeg"]
+    #   - upload_allowed_file_extensions_admin #=> ["jpg", "jpeg", "gif", "png"]
+    #   - another_thing_bleep #=> "bloop"
+    #   - another_thing_foo_bar #=> 1
+    #   - another_thing_foo_baz #=> 2
+    #
+    # Note that when the deepest configuration hash has the key "default", it
+    # will not be appended to the method name.
+    #
+    # @param obj [Decidim::OrganizationSettings, OpenStruct] The settings object
+    #   for which to define the accessors.
+    # @param chain [Array<Symbol>] The current lookup chain for the settings
+    #   object. Needed when called recursively.
+    def define_config_accessors(obj, chain)
+      obj.each_pair do |key, val|
+        if val.is_a?(OpenStruct)
+          define_config_accessors(val, [*chain, key])
+        else
+          prefix = chain.join("_")
+          method = prefix
+          method = "#{method}_#{key}" unless key.to_sym == :default
+
+          define_singleton_method(method) do
+            value = dig(*chain, key)
+            return value unless respond_to?("wrap_#{method}")
+
+            public_send("wrap_#{method}", value)
+          end
+        end
+      end
+    end
+  end
+end