decidim-core 0.9.3 → 0.10.0

data/app/presenters/decidim/log/value_types/percentage_presenter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Log
+    module ValueTypes
+      # This class presents the given value as a percentage. Check
+      # the `DefaultPresenter` for more info on how value
+      # presenters work.
+      class PercentagePresenter < DefaultPresenter
+        # Public: Presents the value as a percentage. For clarity,
+        # it strips the insignificant zeros.
+        #
+        # Returns an HTML-safe String.
+        def present
+          return unless value
+          h.number_to_percentage(value, strip_insignificant_zeros: true)
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/log/value_types/scope_presenter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Log
+    module ValueTypes
+      # This class presents the given value as a Decidim::Scope. Check
+      # the `DefaultPresenter` for more info on how value
+      # presenters work.
+      class ScopePresenter < DefaultPresenter
+        # Public: Presents the value as a Decidim::Scope. If the scope can
+        # be found, it shows its title. Otherwise it shows its ID.
+        #
+        # Returns an HTML-safe String.
+        def present
+          return unless value
+          return h.translated_attribute(scope.name) if scope
+          I18n.t("not_found", id: value, scope: "decidim.log.value_types.scope_presenter")
+        end
+
+        private
+
+        def scope
+          @scope ||= Decidim::Scope.where(id: value).first
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/log/value_types/scope_type_presenter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Log
+    module ValueTypes
+      # This class presents the given value as a Decidim::ScopeType. Check
+      # the `DefaultPresenter` for more info on how value
+      # presenters work.
+      class ScopeTypePresenter < DefaultPresenter
+        # Public: Presents the value as a Percentage. If the scope can
+        # be found, it shows its title. Otherwise it shows its ID.
+        #
+        # Returns an HTML-safe String.
+        def present
+          return unless value
+          return h.translated_attribute(scope_type.name) if scope_type
+          I18n.t("not_found", id: value, scope: "decidim.log.value_types.scope_type_presenter")
+        end
+
+        private
+
+        def scope_type
+          @scope_type ||= Decidim::ScopeType.where(id: value).first
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/user_presenter.rb

@@ -12,7 +12,7 @@ module Decidim
     # nickname presented in a twitter-like style
     #
     def nickname
-      "@#{super}"
+      "@#{__getobj__.nickname}"
     end
 
     def badge

data/app/services/decidim/action_authorizer.rb

@@ -43,7 +43,7 @@ module Decidim
     def authorization
       return nil unless user && authorization_handler_name
 
-      @authorization ||= Verifications::Authorizations.new(user: user, name: authorization_handler_name).first
+      @authorization ||= Verifications::Authorizations.new(organization: user.organization, user: user, name: authorization_handler_name).first
     end
 
     def authorization_handler

data/app/services/decidim/action_logger.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Use this class to log actions by any user. You probably shouldn't
+  # use this class dfirectly, but rather use `Decidim.traceability` instead.
+  # Check the docs on `Decidim::Traceability` for more info.
+  #
+  # Usage:
+  #
+  #    ActionLogger.log(:create, user, new_proposal, extra_data)
+  class ActionLogger
+    # Public: Logs the given `action` by the given `user` on the given `resource`.
+    # Delegates the work to the instance method.
+    #
+    # action - a String representing the name of the action
+    # user - the Decidim::User that performed the action
+    # resource - the resource onn which the action was performed
+    # version_id - the ID of the `PaperTrail::Version` that was created on that action
+    # resource_extra - a Hash with resource_extra info to be recorded
+    #
+    # Returns the newly created `Decidim::ActionLog` resource.
+    def self.log(action, user, resource, version_id, resource_extra = {})
+      new(action, user, resource, version_id, resource_extra).log!
+    end
+
+    # Public: Initializes the instance.
+    #
+    # action - a String representing the name of the action
+    # user - the Decidim::User that performed the action
+    # resource - the resource onn which the action was performed
+    # version_id - the ID of the `PaperTrail::Version` that was created on that action
+    # resource_extra - a Hash with resource_extra info to be recorded
+    def initialize(action, user, resource, version_id = nil, resource_extra = {})
+      @action = action
+      @user = user
+      @resource = resource
+      @version_id = version_id
+      @resource_extra = resource_extra
+    end
+
+    # Public: Logs the given `action` by the given `user` on the given
+    # `resource`.
+    #
+    # Returns the newly created `Decidim::ActionLog` resource.
+    def log!
+      Decidim::ActionLog.create!(
+        user: user,
+        organization: organization,
+        action: action,
+        resource: resource,
+        participatory_space: participatory_space,
+        feature: feature,
+        version_id: version_id,
+        extra: extra_data
+      )
+    end
+
+    private
+
+    attr_reader :action, :user, :resource, :resource_extra, :version_id
+
+    def organization
+      user.organization
+    end
+
+    def feature
+      resource.feature if resource.respond_to?(:feature)
+    end
+
+    def participatory_space
+      return feature.participatory_space if feature.respond_to?(:participatory_space)
+      resource.participatory_space if resource.respond_to?(:participatory_space)
+    end
+
+    def title_for(resource)
+      resource.try(:title) || resource.try(:name) || resource.try(:subject)
+    end
+
+    def participatory_space_manifest_name
+      participatory_space.try(:class).try(:participatory_space_manifest).try(:name)
+    end
+
+    # Private: Defines some extra data that will be saved in the action log `extra`
+    # field.
+    #
+    # Returns a Hash.
+    def extra_data
+      {
+        feature: {
+          manifest_name: feature.try(:manifest_name),
+          title: title_for(feature)
+        }.compact,
+        participatory_space: {
+          manifest_name: participatory_space_manifest_name,
+          title: title_for(participatory_space)
+        }.compact,
+        resource: {
+          title: title_for(resource)
+        }.compact,
+        user: {
+          ip: user.current_sign_in_ip,
+          name: user.name,
+          nickname: user.nickname
+        }.compact
+      }.deep_merge(resource_extra)
+    end
+  end
+end

data/app/services/decidim/events_manager.rb

@@ -23,7 +23,7 @@ module Decidim
         event,
         event_class: event_class.name,
         resource: resource,
-        recipient_ids: recipient_ids,
+        recipient_ids: recipient_ids.compact.uniq,
         extra: extra
       )
     end

data/app/services/decidim/log/diff_changeset_calculator.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Log
+    # This class takes a changeset from a `PaperTrail::Version` and
+    # a field mapping and cleans the changeset so it can be easily
+    # rendered in the log section. It is intended to be used by the
+    # `Decidim::Log::BasePresenter` class, which handles most of the
+    # work to render a log.
+    #
+    # Example:
+    #
+    #    version = resource.versions.last
+    #    fields_mapping = { updated_at: :date, title: :string }
+    #    i18n_labels_scope = "activemodel.attributes.my_resource"
+    #
+    #    DiffChangesetCalculator
+    #      .new(version.changeset, fields_mapping, i18n_labels_scope)
+    #      .changeset
+    class DiffChangesetCalculator
+      # original_changeset - a `changeset` from a PaperTrail::Version instance
+      # fields_mapping - a Hash mapping attribute names and a type to render them
+      # i18n_labels_scope - a String representing the I18n scope where the attribtue
+      #   labels can be found
+      def initialize(original_changeset, fields_mapping, i18n_labels_scope)
+        @original_changeset = original_changeset
+        @fields_mapping = fields_mapping
+        @i18n_labels_scope = i18n_labels_scope
+      end
+
+      # Calculates the changeset that should be rendered, from the
+      # `original_changeset` and the `fields_mapping` values.
+      #
+      # Returns an Array of Hashes.
+      def changeset
+        original_changeset.inject([]) do |diff, (attribute, values)|
+          attribute = attribute.to_sym
+
+          type = :default
+          type = fields_mapping[attribute] unless fields_mapping.nil?
+
+          if type.blank? || values[0] == values[1]
+            diff
+          else
+            diff.concat(calculate_changeset(attribute, values, type))
+          end
+        end.compact
+      end
+
+      private
+
+      attr_reader :fields_mapping, :original_changeset, :i18n_labels_scope
+
+      # Private: Generates the data structure for the changeset attribute,
+      # needed so that the attribute can be rendered in the diff.
+      #
+      # attribute - the name of the attribute
+      # values - an Array of the attribute values: [old_value, new_value]
+      # type - a symbol or a String representing the value type presenter
+      #
+      # Returns an array of hashes.
+      def calculate_changeset(attribute, values, type)
+        return generate_i18n_changeset(attribute, values, type) if type == :i18n
+
+        generate_changeset(attribute, values, type)
+      end
+
+      # Private: Generates the data structure for an i18n attribute,
+      # needed so that the attribute can be rendered in the diff.
+      # Sets the label for the given attribute as: `AttributeName (locale)`.
+      #
+      # attribute - the name of the attribute
+      # values - an Array of the attribute values: [old_value, new_value]
+      # type - a symbol or a String representing the value type presenter
+      #
+      # Returns an array of hashes.
+      def generate_i18n_changeset(attribute, values, type)
+        values.map! { |value| value.is_a?(String) ? JSON.parse(value) : value }
+
+        locales = values[0].to_h.keys | values[1].to_h.keys
+        locales.flat_map do |locale|
+          previous_value = values.first.try(:[], locale)
+          new_value = values.last.try(:[], locale)
+          if previous_value == new_value
+            nil
+          else
+            label = generate_label(attribute, locale)
+            generate_changeset(attribute, [previous_value, new_value], type, label)
+          end
+        end
+      end
+
+      # Private: Generates the structure needed for the given attribute,
+      # values, type and label.
+      #
+      # attribute - the name of the attribute
+      # values - an Array of the attribute values: [old_value, new_value]
+      # type - a symbol or a String representing the value type presenter
+      # label - the label for the current attribute
+      #
+      # Returns an array of Hashes.
+      def generate_changeset(attribute, values, type, label = nil)
+        [
+          {
+            attribute_name: attribute,
+            label: label || generate_label(attribute),
+            new_value: values[1],
+            previous_value: values[0],
+            type: type
+          }
+        ]
+      end
+
+      # Generates the label for the given attribute. If the `locale` is set,
+      # it appends the locale at the end: `AttributeName (LocaleName)`.
+      #
+      # attribute - A Symbol representing the attribute name. It will retrive
+      #   this key from the I18n scope set at `i18n_labels_scope`.
+      # locale - a String representing the name of the locale.
+      #
+      # Returns a String.
+      def generate_label(attribute, locale = nil)
+        label = if i18n_labels_scope
+                  I18n.t(attribute, scope: i18n_labels_scope, default: attribute.to_s.humanize)
+                else
+                  attribute.to_s.humanize
+                end
+        return label unless locale
+
+        locale_name = I18n.t("locale.name", locale: locale)
+        "#{label} (#{locale_name})"
+      end
+    end
+  end
+end

data/app/services/decidim/resource_search.rb

@@ -47,15 +47,9 @@ module Decidim
 
       conditions = []
       conditions << "decidim_scope_id IS NULL" if clean_scope_ids.delete("global")
+      conditions.concat(["? = ANY(decidim_scopes.part_of)"] * clean_scope_ids.count) if clean_scope_ids.any?
 
-      clean_scope_ids.map!(&:to_i)
-
-      if clean_scope_ids.any?
-        conditions.concat(["? = ANY(decidim_scopes.part_of)"] * clean_scope_ids.count)
-        conditions << "decidim_scopes.id IN (?)"
-      end
-
-      query.includes(:scope).references(:decidim_scopes).where(conditions.join(" OR "), *clean_scope_ids, clean_scope_ids)
+      query.includes(:scope).references(:decidim_scopes).where(conditions.join(" OR "), *clean_scope_ids.map(&:to_i))
     end
 
     private

data/app/services/decidim/settings_change.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This is a helper class in order to publish feature and settings changes
+  # so that components can react to these changes and send notifications to users.
+  class SettingsChange
+    # Publishes a change to ActiveSupport::Notifications.
+    #
+    # feature - The Decidim::Feature where the changes have been applied.
+    # previous_settings - A Hash or a Decidim::SettingsManifest schema with the settings before changing them.
+    # current_settings - A Hash or a Decidim::SettingsManifest schema with the current settings.
+    def self.publish(feature, previous_settings, current_settings)
+      ActiveSupport::Notifications.publish(
+        "decidim.settings_change.#{feature.manifest_name}",
+        feature_id: feature.id,
+        previous_settings: previous_settings.to_h.deep_symbolize_keys,
+        current_settings: current_settings.to_h.deep_symbolize_keys
+      )
+    end
+
+    # Creates a subscription to setting changes.
+    #
+    # scope - The String manifest name of the component so it only receives relevant changes.
+    # block - The block to be executed when an event is received.
+    def self.subscribe(scope, &block)
+      ActiveSupport::Notifications.subscribe(/^decidim\.settings_change\.#{scope}/) do |_event_name, data|
+        block.call(data)
+      end
+    end
+  end
+end

data/app/services/decidim/traceability.rb

@@ -24,11 +24,12 @@ module Decidim
     #
     # klass - An ActiveRecord class that implements `Decidim::Traceable`
     # author - An object that implements `to_gid` or a String
-    # params - a Hash
+    # params - a Hash with the attributes of the new resource
+    # extra_log_info - a Hash with extra info that will be saved to the log
     #
     # Returns an instance of `klass`.
-    def create(klass, author, params)
-      PaperTrail.whodunnit(gid(author)) do
+    def create(klass, author, params, extra_log_info = {})
+      perform_action!(:create, klass, author, extra_log_info) do
         klass.create(params)
       end
     end
@@ -37,25 +38,51 @@ module Decidim
     #
     # klass - An ActiveRecord class that implements `Decidim::Traceable`
     # author - An object that implements `to_gid` or a String
-    # params - a Hash
+    # params - a Hash with the attributes of the new resource
+    # extra_log_info - a Hash with extra info that will be saved to the log
     #
     # Returns an instance of `klass`.
-    def create!(klass, author, params)
-      PaperTrail.whodunnit(gid(author)) do
+    def create!(klass, author, params, extra_log_info = {})
+      perform_action!(:create, klass, author, extra_log_info) do
         klass.create!(params)
       end
     end
 
-    # Updates the `resource` with `update_attributes!` and sets the author of the version.
+    # Performs the given block and sets the author of the action.
+    # It also logs the action with the given `action` parameter.
+    # The action and the logging are run inside a transaction.
     #
+    # action - a String or Symbol representing the action performed
     # resource - An ActiveRecord instance that implements `Decidim::Traceable`
     # author - An object that implements `to_gid` or a String
-    # params - a Hash
+    # extra_log_info - a Hash with extra info that will be saved to the log
     #
-    # Returns the updated `resource`.
-    def update!(resource, author, params)
+    # Returns whatever the given block returns.
+    def perform_action!(action, resource, author, extra_log_info = {})
       PaperTrail.whodunnit(gid(author)) do
-        resource.update_attributes!(params)
+        klass = resource.is_a?(Class) ? resource : resource.class
+        klass.transaction do
+          Decidim::ApplicationRecord.transaction do
+            result = block_given? ? yield : nil
+            loggable_resource = resource.is_a?(Class) ? result : resource
+            log(action, author, loggable_resource, extra_log_info)
+            result
+          end
+        end
+      end
+    end
+
+    # Updates the `resource` with `update!` and sets the author of the version.
+    #
+    # resource - An ActiveRecord instance that implements `Decidim::Traceable`
+    # author - An object that implements `to_gid` or a String
+    # params - a Hash with the attributes to update to the resource
+    # extra_log_info - a Hash with extra info that will be saved to the log
+    #
+    # Returns the updated `resource`.
+    def update!(resource, author, params, extra_log_info = {})
+      perform_action!(:update, resource, author, extra_log_info) do
+        resource.update!(params)
         resource
       end
     end
@@ -87,5 +114,24 @@ module Decidim
       return author.to_gid if author.respond_to?(:to_gid)
       author
     end
+
+    def log(action, user, resource, extra_log_info = {})
+      return unless user.is_a?(Decidim::User)
+
+      Decidim::ActionLogger.log(
+        action,
+        user,
+        resource,
+        version_id(resource),
+        extra_log_info
+      )
+    end
+
+    def version_id(resource)
+      return nil unless resource.is_a?(Decidim::Traceable)
+      return nil if resource.versions.blank?
+
+      resource.versions.last.id
+    end
   end
 end