decidim 0.4.4 → 0.5.0

data/decidim-core/app/commands/decidim/remove_admin.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A command to remove the admin privilege to an user.
+  class RemoveAdmin < Rectify::Command
+    # Public: Initializes the command.
+    #
+    # form - A form object with the params.
+    def initialize(user)
+      @user = user
+    end
+
+    def call
+      return broadcast(:invalid) unless user
+
+      user.update_attributes!(admin: false)
+
+      broadcast(:ok)
+    end
+
+    private
+
+    attr_reader :user
+  end
+end

data/decidim-core/app/commands/decidim/update_account.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This command updates the user's account.
+  class UpdateAccount < Rectify::Command
+    # Updates a user's account.
+    #
+    # user - The user to be updated.
+    # form - The form with the data.
+    def initialize(user, form)
+      @user = user
+      @form = form
+    end
+
+    def call
+      return broadcast(:invalid) unless @form.valid?
+
+      update_personal_data
+      update_avatar
+      update_password
+
+      if @user.valid?
+        @user.save!
+        broadcast(:ok, @user.unconfirmed_email.present?)
+      else
+        if @user.errors.has_key? :avatar
+          @form.errors.add :avatar, @user.errors[:avatar]
+        end
+        broadcast(:invalid)
+      end
+    end
+
+    private
+
+    def update_personal_data
+      @user.name = @form.name
+      @user.email = @form.email
+    end
+
+    def update_avatar
+      @user.avatar = @form.avatar
+      @user.remove_avatar = @form.remove_avatar
+    end
+
+    def update_password
+      return unless @form.password.present?
+
+      @user.password = @form.password
+      @user.password_confirmation = @form.password_confirmation
+    end
+  end
+end

data/decidim-core/app/commands/decidim/update_notifications_settings.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This command updates the user's notifictions settings.
+  class UpdateNotificationsSettings < Rectify::Command
+    # Updates a user's notifications settings.
+    #
+    # user - The user to be updated.
+    # form - The form with the data.
+    def initialize(user, form)
+      @user = user
+      @form = form
+    end
+
+    def call
+      return broadcast(:invalid) unless @form.valid?
+
+      update_notifications_settings
+      @user.save!
+
+      broadcast(:ok, @user)
+    end
+
+    private
+
+    def update_notifications_settings
+      @user.comments_notifications = @form.comments_notifications
+      @user.replies_notifications = @form.replies_notifications
+      @user.newsletter_notifications = @form.newsletter_notifications
+    end
+  end
+end

data/decidim-core/app/constraints/decidim/current_feature.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This class infers the current feature we're scoped to by looking at the
+  # request parameters and injects it into the environment.
+  class CurrentFeature
+    # Public: Initializes the class.
+    #
+    # manifest - The manifest of the feature to check against.
+    def initialize(manifest)
+      @manifest = manifest
+    end
+
+    # Public: Matches the request against a feature and injects it into the
+    #         environment.
+    #
+    # request - The request that holds the current feature relevant information.
+    #
+    # Returns a true if the request matched, false otherwise
+    def matches?(request)
+      env = request.env
+
+      return false unless CurrentParticipatoryProcess.new.matches?(request)
+
+      @participatory_process = env["decidim.current_participatory_process"]
+
+      current_feature(env, request.params) ? true : false
+    end
+
+    private
+
+    def current_feature(env, params)
+      env["decidim.current_feature"] ||= detect_current_feature(params)
+    end
+
+    def detect_current_feature(params)
+      @participatory_process.features.find do |feature|
+        params["feature_id"] == feature.id.to_s && feature.manifest_name == @manifest.name.to_s
+      end
+    end
+  end
+end

data/decidim-core/app/constraints/decidim/current_participatory_process.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This class infers the current participatory process we're scoped to by
+  # looking at the request parameters and the organization in the request
+  # environment, and injects it into the environment.
+  class CurrentParticipatoryProcess
+    # Public: Matches the request against a participatory process and injects it
+    #         into the environment.
+    #
+    # request - The request that holds the participatory process relevant
+    #           information.
+    #
+    # Returns a true if the request matched, false otherwise
+    def matches?(request)
+      env = request.env
+
+      @organization = env["decidim.current_organization"]
+      return false unless @organization
+
+      current_participatory_process(env, request.params) ? true : false
+    end
+
+    private
+
+    def current_participatory_process(env, params)
+      env["decidim.current_participatory_process"] ||=
+        detect_current_participatory_process(params)
+    end
+
+    def detect_current_participatory_process(params)
+      OrganizationParticipatoryProcesses.new(@organization).query.find_by_id(params["participatory_process_id"])
+    end
+  end
+end

data/decidim-core/app/controllers/concerns/decidim/action_authorization.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module ActionAuthorization
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :authorize_action_path, :action_authorization
+    end
+
+    # Public: Authorizes an action of a feature given an action name.
+    #
+    # action_name  - The action name to authorize. Actions are set up on the
+    #                feature's permissions panel.
+    # redirect_url - Url to be redirected to when the authorization is finished.
+    def authorize_action!(action_name, redirect_url: nil)
+      @action_authorizations ||= {}
+      @action_authorizations[action_name] = _action_authorizer(action_name).authorize
+      status = @action_authorizations[action_name]
+
+      return if status.ok?
+      raise Unauthorized if status.code == :invalid
+
+      redirect_to authorize_action_path_from_status(status, redirect_url)
+    end
+
+    # Public: Returns the authorization object for an authorization.
+    #
+    # action_name - The action to authorize against.
+    #
+    # Returns an ActionAuthorizer::AuthorizationStatus
+    def action_authorization(action_name)
+      _action_authorizer(action_name).authorize
+    end
+
+    # Public: Returns the authorization path for a failed authorization with
+    # the populated redirect url.
+    #
+    # action_name - The action name to authorize against.
+    # redirect_url - The url to redirect to when finished.
+    #
+    # Returns a String.
+    def authorize_action_path(action_name, redirect_url: nil)
+      redirect_url ||= request.path
+
+      authorize_action_path_from_status(
+        action_authorization(action_name),
+        redirect_url: redirect_url
+      )
+    end
+
+    # Public: Returns the authorization path for a failed authorization with
+    # the populated redirect url.
+    #
+    # status       - The status after an authorization check.
+    # redirect_url - The url to redirect to when finished.
+    #
+    # Returns a String.
+    def authorize_action_path_from_status(status, redirect_url: nil)
+      decidim.new_authorization_path(
+        handler: status.data[:handler],
+        redirect_url: redirect_url
+      )
+    end
+
+    def _action_authorizer(action_name)
+      ::Decidim::ActionAuthorizer.new(current_user, current_feature, action_name)
+    end
+
+    class Unauthorized < StandardError; end
+  end
+end

data/decidim-core/app/controllers/concerns/decidim/devise_controllers.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # This concern groups methods and helpers needed by Devise controllers.
+  module DeviseControllers
+    extend ActiveSupport::Concern
+
+    included do
+      include Decidim::NeedsOrganization
+      include Decidim::LocaleSwitcher
+
+      include NeedsAuthorization
+      skip_authorization_check
+
+      helper Decidim::TranslationsHelper
+      helper Decidim::MetaTagsHelper
+      helper Decidim::DecidimFormHelper
+      helper Decidim::LanguageChooserHelper
+      helper Decidim::CookiesHelper
+      helper Decidim::ReplaceButtonsHelper
+      helper Decidim::LayoutHelper
+      helper Decidim::MenuHelper
+      helper Decidim::OmniauthHelper
+
+      layout "layouts/decidim/application"
+    end
+
+    # Overwrites `cancancan`'s method to point to the correct ability class,
+    # since the gem expects the ability class to be in the root namespace.
+    def current_ability_klass
+      Decidim::Abilities::BaseAbility
+    end
+  end
+end

data/decidim-core/app/controllers/concerns/decidim/filter_resource.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # Common logic to filter resources
+  module FilterResource
+    extend ActiveSupport::Concern
+
+    # Internal: Defines a class that will wrap in an object the URL params used by the filter.
+    # this way we can use Rails' form helpers and have automatically checked checkboxes and
+    # radio buttons in the view, for example.
+    class Filter
+      def initialize(filter)
+        @filter = filter
+      end
+
+      def method_missing(method_name, *_arguments)
+        @filter.present? && @filter.has_key?(method_name) ? @filter[method_name] : super
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @filter.present? && @filter.has_key?(method_name) || super
+      end
+    end
+
+    included do
+      helper_method :search, :filter
+
+      private
+
+      def search
+        @search ||= search_klass.new(search_params)
+      end
+
+      def search_klass
+        raise NotImplementedError, "A search class is neeeded to filter resources"
+      end
+
+      def filter
+        @filter ||= Filter.new(filter_params)
+      end
+
+      def search_params
+        default_search_params
+          .merge(filter_params)
+          .merge(context_params)
+      end
+
+      def filter_params
+        default_filter_params
+          .merge(params.to_unsafe_h[:filter].try(:symbolize_keys) || {})
+      end
+
+      def default_search_params
+        {}
+      end
+
+      def default_filter_params
+        {}
+      end
+
+      def context_params
+        {
+          feature: current_feature,
+          current_user: current_user
+        }
+      end
+    end
+  end
+end

data/decidim-core/app/controllers/concerns/decidim/form_factory.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # A factory to build forms. This is done to add a context when possible, so
+  # that forms can act based on data that varies between requests. This is
+  # mostly done so that i18n form fields can be properly validated with the
+  # `current_organization` available locales, instead of doing so against all
+  # the available locales in the platform. The `current_organization` varies
+  # between requests, so the form need some way to access this data.
+  #
+  # Examples:
+  #
+  #   # in a controller, mostly in a `create` action:
+  #   form(MyFormClass).form_params(params)
+  #
+  #   # in a controller, mostly in a `new` action:
+  #   form(MyFormClass).instance
+  #
+  #   # in a controller, mostly in an `edit` action:
+  #   form(MyFormClass).form_model(@my_resource)
+  #
+  module FormFactory
+    extend ActiveSupport::Concern
+
+    included do
+      # Initializes a factory for the given Form Object class.
+      #
+      # klass - a Form object class name. Must be a constant, not a String.
+      def form(klass)
+        Class.new do
+          # Initializes the form factory object.
+          #
+          # klass - the class name of the Form object that will be initialized
+          # controller - the Controller where the form is built.
+          def initialize(klass, controller)
+            @klass = klass
+            @controller = controller
+          end
+
+          # Returns a simple instance of the form klass.
+          #
+          # extra_context - A Hash with optional extra context data.
+          def instance(extra_context = {})
+            @klass.new.with_context(context.merge(extra_context))
+          end
+
+          # Initializes a form object from a model. Delegates the functionality
+          # to the form object class method.
+          #
+          # model         - the model instance from which the form object will be
+          #                 initialized.
+          # extra_context - a Hash with optional context data.
+          def from_model(model, extra_context = {})
+            @klass.from_model(model).with_context(context.merge(extra_context))
+          end
+
+          # Initializes a form object instance from params, and it
+          # automatically adds some context. Context can be extended.
+          #
+          # params        - a Hash with params. Mostly a set of params from a form.
+          # extra_context - a Hash with optional context data.
+          def from_params(params, extra_context = {})
+            @klass.from_params(params).with_context(context.merge(extra_context))
+          end
+
+          # Sets a base context from the current controller. Since this can be
+          # used from some controllers that do not respond to the helper
+          # methods used here, this Hash can have different keys depending on
+          # the controller that uses it.
+          def context
+            {
+              current_organization: @controller.try(:current_organization),
+              current_feature: @controller.try(:current_feature),
+              current_user: @controller.try(:current_user)
+            }
+          end
+        end.new(klass, self)
+      end
+    end
+  end
+end