decidim-core 0.15.2 → 0.16.0

data/lib/decidim/events/simple_event.rb

@@ -49,9 +49,19 @@ module Decidim
       # Public: The String to use as scope to search for the keys
       # when using I18n.t
       #
-      # By default is the same value as the event name.
+      # By default is the same value as the event name. If the event has roles,
+      # then the role is appended to the i18n scope.
       def i18n_scope
-        event_name
+        return event_name if user_role.blank? || !event_has_roles?
+        "#{event_name}.#{user_role}"
+      end
+
+      # Public: Whether the event differentiates between different user roles.
+      # This will change the default i18n scope.
+      #
+      # Returns a boolean.
+      def event_has_roles?
+        false
       end
 
       # Public: The Hash of options to pass to the I18.t method.
@@ -78,6 +88,15 @@ module Decidim
         @participatory_space_url ||= ResourceLocatorPresenter.new(participatory_space).url
       end
 
+      # Caches the text to render as a quote in the email. It will appear, if
+      # present, after the `intro` section. This method is intended to be
+      # overwritten by each event class.
+      #
+      # Returns a string.
+      def resource_text
+        nil
+      end
+
       private
 
       def event_interpolations

data/lib/decidim/form_builder.rb

@@ -372,6 +372,14 @@ module Decidim
       end
     end
 
+    def form_field_for(attribute)
+      if attribute == :body
+        text_area attribute, rows: 10
+      else
+        text_field attribute
+      end
+    end
+
     private
 
     # Private: Override from FoundationRailsHelper in order to render

data/lib/decidim/gamification/badge_scorer.rb

@@ -108,7 +108,7 @@ module Decidim
           event: name,
           event_class: klass,
           resource: @model,
-          recipient_ids: recipients,
+          affected_users: recipients,
           extra: {
             badge_name: @badge.name.to_s,
             previous_level: previous_level,
@@ -123,9 +123,9 @@ module Decidim
 
       def recipients
         if @model.is_a?(User)
-          [@model.id]
+          [@model]
         elsif @model.is_a?(UserGroup)
-          @model.users.pluck(:id)
+          @model.users
         end
       end
     end

data/lib/decidim/has_component.rb

@@ -9,7 +9,7 @@ module Decidim
     extend ActiveSupport::Concern
 
     included do
-      belongs_to :component, foreign_key: "decidim_component_id", class_name: "Decidim::Component"
+      belongs_to :component, foreign_key: "decidim_component_id", class_name: "Decidim::Component", touch: true
       delegate :organization, to: :component, allow_nil: true
       delegate :participatory_space, to: :component, allow_nil: true
     end

data/lib/decidim/hashtag.rb

@@ -9,7 +9,5 @@ module Decidim
 
     validates :name, presence: true
     validates :name, uniqueness: { scope: [:decidim_organization_id] }
-
-    HASHTAG_REGEX = /(^|\s)#([a-zA-Z0-9]\w*)/i
   end
 end

data/lib/decidim/hashtaggable.rb

@@ -8,12 +8,12 @@ module Decidim
     included do
       def search_title
         renderer = Decidim::ContentRenderers::HashtagRenderer.new(title)
-        renderer.render_without_link.html_safe
+        renderer.render(links: false).html_safe
       end
 
       def search_body
         renderer = Decidim::ContentRenderers::HashtagRenderer.new(body)
-        renderer.render_without_link.html_safe
+        renderer.render(links: false).html_safe
       end
     end
   end

data/lib/decidim/metric_manifest.rb

@@ -12,9 +12,24 @@ module Decidim
 
     attribute :metric_name, String
     attribute :manager_class, String
-    attribute :highlighted, String
-    attribute :position, Integer
 
     validates :metric_name, :manager_class, presence: true
+
+    def has_settings?
+      settings.attributes.any?
+    end
+
+    def settings(&block)
+      @settings ||= SettingsManifest.new
+      yield(@settings) if block
+      @settings
+    end
+
+    # stat_block is a non-required parameter
+    # This method make it easier to retrieve it,
+    #  and gives an empty string if it's not configured
+    def stat_block
+      settings.attributes[:stat_block].try(:[], :default) || ""
+    end
   end
 end

data/lib/decidim/metric_operation.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Decidim
+  class MetricOperation
+    # Public: Registers a operation for metrics
+    #
+    # metric_operation - a symbol representing the name of the operation involved
+    # metric_name - a symbol representing the name of the metric involved
+    #
+    # Returns nothing. Raises an error if there's already a metric
+    # registered with that metric name.
+    def register(metric_operation, metric_name)
+      metric_operation = metric_operation.to_s
+      metric_name = metric_name.to_s
+      metric_exists = self.for(metric_operation, metric_name).present?
+
+      if metric_exists
+        raise(
+          MetricOperationAlreadyRegistered,
+          "There's a metric already registered with the name `:#{metric_name}`, must be unique"
+        )
+      end
+
+      metric_manifest = MetricOperationManifest.new(metric_operation: metric_operation, metric_name: metric_name)
+
+      yield(metric_manifest)
+
+      metric_manifest.validate!
+
+      metrics_manifests << metric_manifest
+    end
+
+    # Searches for MetricOperationManifest(s) depending on parameters
+    # With 'metric_operation' only:
+    #   - Returns all manifest related to that operation
+    # With 'metric_operation' and 'metric_name':
+    #   - Returns a single manifest related to that two params
+    def for(metric_operation, metric_name = nil)
+      list = if metric_name
+               all.find { |manifest| manifest.metric_operation == metric_operation.to_s && manifest.metric_name == metric_name.to_s }
+             else
+               all.find_all { |manifest| manifest.metric_operation == metric_operation.to_s }
+             end
+      list
+    end
+
+    def all
+      metrics_manifests
+    end
+
+    class MetricOperationAlreadyRegistered < StandardError; end
+
+    private
+
+    def metrics_manifests
+      @metrics_manifests ||= []
+    end
+  end
+end

data/lib/decidim/metric_operation_manifest.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This class acts as a manifest for metrics operations.
+  #
+  # This manifest is an expansion from Decidim::MetricManifest that holds and stores
+  # operations, metrics and measure class, for operations purpose
+  #
+  class MetricOperationManifest < Decidim::MetricManifest
+    attribute :metric_operation, String
+
+    validates :metric_operation, presence: true
+
+    def calculate(day, resource)
+      operation = manager_class.constantize.new(day, resource)
+      return unless operation.valid?
+      operation.calculate
+    end
+  end
+end

data/lib/decidim/metric_registry.rb

@@ -4,31 +4,34 @@ module Decidim
   # This class acts as a registry for metrics. Each metric needs a name
   # and a manager class, that will be used for calculations
   #
+  #   Also, each metrics must have a collection of attributes:
+  #     - highlighted: Determines if it showed in a highlighted chart
+  #     - scopes: List of scopes where it will be used
+  #     - weight: Priority of itself
+  #
   # In order to register a metric, you can follow this example:
   #
-  #     Decidim.metrics_registry.register(
-  #       :users_metric,
-  #       "Decidim::Metrics::UsersMetricManage"
-  #     )
+  #     Decidim.metrics_registry.register(:users) do
+  #       metric_registry.manager_class = "Decidim::Metrics::UsersMetricManage"
+  #
+  #       metric_registry.settings do |settings|
+  #         settings.attribute :highlighted, type: :boolean, default: true
+  #         settings.attribute :scopes, type: :array, default: %w(home)
+  #         settings.attribute :weight, type: :integer, default: 1
+  #       end
+  #     end
   #
   # Metrics need to be registered in the `engine.rb` file of each module
   class MetricRegistry
-    HIGHLIGHTED = "highlighted"
-    NOT_HIGHLIGHTED = "not-highlighted"
     # Public: Registers a metric for calculations
     #
     # metric_name - a symbol representing the name of the metric
     #
-    # manager_class - Manager class for specific metric calculation
-    #
-    # highlighted - value referencing if it's a highluithgted metric, or not
-    #
     # Returns nothing. Raises an error if there's already a metric
     # registered with that metric name.
-    def register(metric_name, manager_class, highlighted = NOT_HIGHLIGHTED, position = nil)
+    def register(metric_name)
       metric_name = metric_name.to_s
       metric_exists = self.for(metric_name).present?
-      position ||= all.size + 1
 
       if metric_exists
         raise(
@@ -37,27 +40,62 @@ module Decidim
         )
       end
 
-      metric_manifest = MetricManifest.new(metric_name: metric_name, manager_class: manager_class, highlighted: highlighted, position: position)
+      metric_manifest = MetricManifest.new(metric_name: metric_name)
+
+      yield(metric_manifest)
 
       metric_manifest.validate!
 
       metrics_manifests << metric_manifest
     end
 
-    def for(metric_name)
-      all.find { |manifest| manifest.metric_name == metric_name }
+    def for(metric_name, list = nil)
+      list ||= all
+      list.find { |manifest| manifest.metric_name == metric_name.to_s }
     end
 
     def all
       metrics_manifests
     end
 
-    def highlighted
-      all.find_all { |manifest| manifest.highlighted == HIGHLIGHTED }.sort_by(&:position)
+    def filtered(highlight: nil, scope: nil, sort: nil, block: nil)
+      result = all
+      unless highlight.nil?
+        result = if highlight
+                   highlighted(result)
+                 else
+                   not_highlighted(result)
+                 end
+      end
+      result = scoped(scope, result) if scope.present?
+      result = sorted(result) if sort.present?
+      result = stat_block(block, result) if block.present?
+      result
+    end
+
+    def highlighted(list = nil)
+      list ||= all
+      list.find_all { |manifest| manifest.settings.attributes[:highlighted][:default] }
+    end
+
+    def not_highlighted(list = nil)
+      list ||= all
+      list.find_all { |manifest| !manifest.settings.attributes[:highlighted][:default] }
+    end
+
+    def scoped(scope, list = nil)
+      list ||= all
+      list.find_all { |manifest| manifest.settings.attributes[:scopes][:default].include?(scope.to_s) }
+    end
+
+    def stat_block(block, list = nil)
+      list ||= all
+      list.find_all { |manifest| manifest.stat_block == block.to_s }
     end
 
-    def not_highlighted
-      all.find_all { |manifest| manifest.highlighted == NOT_HIGHLIGHTED }.sort_by(&:position)
+    def sorted(list = nil)
+      list ||= all
+      list.sort_by { |manifest| manifest.settings.attributes[:weight].default }
     end
 
     class MetricAlreadyRegistered < StandardError; end

data/lib/decidim/paddable.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # A concern with the components needed when you want a model to be able to create
+  # links from it to another resource.
+  module Paddable
+    extend ActiveSupport::Concern
+    include HasComponent
+    include HasReference
+
+    included do
+      # Public: The String with the URL to access the pad with read/write permissions.
+      def pad_public_url
+        return unless pad
+
+        build_pad_url pad.id
+      end
+
+      # Public: The String with the URL to access the pad with read permissions only.
+      def pad_read_only_url
+        return unless pad
+
+        build_pad_url pad.read_only_id
+      end
+
+      # Public: Returns a EtherpadLite::Pad instance if Etherpad is configured.
+      def pad
+        return if Decidim.etherpad.blank?
+        return unless component.settings.enable_pads_creation
+
+        @pad ||= etherpad.pad(pad_id)
+      end
+
+      # Public: Whether to show the pad or not.
+      #
+      # True by default if a Pad exists.
+      #
+      # This should be overwritten at the included model to customise the rules.
+      # Returns a Boolean.
+      def pad_is_visible?
+        pad
+      end
+
+      # Public: Whether the pad is writable or not.
+      #
+      # True by default if a Pad exists.
+      #
+      # This should be overwritten at the included model to customise the rules.
+      # Returns a Boolean.
+      def pad_is_writable?
+        pad
+      end
+
+      private
+
+      def etherpad
+        @etherpad ||= EtherpadLite.connect(
+          Decidim.etherpad.fetch(:server),
+          Decidim.etherpad.fetch(:api_key),
+          Decidim.etherpad.fetch(:api_version, "1.2.1")
+        )
+      end
+
+      def pad_id
+        @pad_id ||= [
+          reference,
+          Digest::MD5.hexdigest("#{id}-#{Rails.application.secrets.secret_key_base}")
+        ].join("-").slice(0, 50)
+      end
+
+      def build_pad_url(id)
+        [
+          Decidim.etherpad.fetch(:server),
+          "p",
+          id
+        ].join("/")
+      end
+    end
+  end
+end

data/lib/decidim/participable.rb

@@ -93,6 +93,30 @@ module Decidim
       def public_spaces
         published
       end
+
+      # Public: Adds a sane default way to retrieve active spaces. Please, overwrite
+      # this from your model class in case this is not correct for your model.
+      #
+      # Returns an `ActiveRecord::Association`.
+      def active_spaces
+        public_spaces
+      end
+
+      # Public: Adds a sane default way to retrieve future spaces. Please, overwrite
+      # this from your model class in case this is not correct for your model.
+      #
+      # Returns an `ActiveRecord::Association`.
+      def future_spaces
+        none
+      end
+
+      # Public: Adds a sane default way to retrieve past spaces. Please, overwrite
+      # this from your model class in case this is not correct for your model.
+      #
+      # Returns an `ActiveRecord::Association`.
+      def past_spaces
+        none
+      end
     end
   end
 end