decidim-core 0.0.1 → 0.0.2

data/app/assets/stylesheets/decidim/utils/_variables.scss

@@ -0,0 +1,22 @@
+// Decidim Variables
+
+$primary: map-get($foundation-palette, primary) !default;
+$secondary: map-get($foundation-palette, secondary) !default;
+$success: map-get($foundation-palette, success) !default;
+$warning: map-get($foundation-palette, warning) !default;
+$alert: map-get($foundation-palette, alert) !default;
+
+$light-gray-dark: darken($light-gray, 2.5) !default;
+
+$proposals: #238FF7 !default;
+$actions: #57D685 !default;
+$debates: #FA6C96 !default;
+$meetings: #FABC6C !default;
+
+$twitter: #55acee !default;
+$facebook: #3b5998 !default;
+$google: #dd4b39 !default;
+
+$muted: lighten($body-font-color, 30) !default;
+
+$border: 1px solid $medium-gray !default;

data/app/commands/decidim/authorize_user.rb

@@ -16,7 +16,7 @@ module Decidim
     #
     # Returns nothing.
     def call
-      return broadcast(:invalid) unless handler.authorized?
+      return broadcast(:invalid) unless handler.valid? && unique?
 
       create_authorization
       broadcast(:ok)
@@ -29,9 +29,25 @@ module Decidim
     def create_authorization
       Authorization.create!(
         user: handler.user,
+        unique_id: handler.unique_id,
         name: handler.handler_name,
         metadata: handler.metadata
       )
     end
+
+    def unique?
+      return true if handler.unique_id.nil?
+
+      duplicates = Authorization.where(
+        user: User.where(organization: handler.user.organization.id),
+        name: handler.handler_name,
+        unique_id: handler.unique_id
+      )
+
+      return true unless duplicates.any?
+
+      handler.errors.add(:base, I18n.t("decidim.authorization_handlers.errors.duplicate_authorization"))
+      false
+    end
   end
 end

data/app/commands/decidim/create_omniauth_registration.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+module Decidim
+  # A command with all the business logic to create a user from omniauth
+  class CreateOmniauthRegistration < Rectify::Command
+    # Public: Initializes the command.
+    #
+    # form - A form object with the params.
+    def initialize(form, verified_email = nil)
+      @form = form
+      @verified_email = verified_email
+    end
+
+    # Executes the command. Broadcasts these events:
+    #
+    # - :ok when everything is valid.
+    # - :invalid if the form wasn't valid and we couldn't proceed.
+    #
+    # Returns nothing.
+    def call
+      verify_oauth_signature!
+
+      begin
+        return broadcast(:ok, existing_identity.user) if existing_identity
+        return broadcast(:invalid) if form.invalid?
+
+        transaction do
+          create_or_find_user
+          create_identity
+        end
+
+        broadcast(:ok, @user)
+      rescue ActiveRecord::RecordInvalid
+        broadcast(:invalid)
+      end
+    end
+
+    private
+
+    attr_reader :form, :verified_email
+
+    def create_or_find_user
+      generated_password = SecureRandom.hex
+
+      @user = User.find_or_initialize_by(
+        email: verified_email,
+        organization: organization
+      )
+
+      unless @user.persisted?
+        @user.email = (verified_email || form.email)
+        @user.name = form.name
+        @user.password = generated_password
+        @user.password_confirmation = generated_password
+        @user.skip_confirmation! if verified_email
+      end
+
+      @user.tos_agreement = "1"
+      @user.save!
+    end
+
+    def create_identity
+      @user.identities.create!(
+        provider: form.provider,
+        uid: form.uid
+      )
+    end
+
+    def organization
+      @form.current_organization
+    end
+
+    def existing_identity
+      @existing_identity ||= Identity.where(
+        user: organization.users,
+        provider: form.provider,
+        uid: form.uid
+      ).first
+    end
+
+    def verify_oauth_signature!
+      raise InvalidOauthSignature, "Invalid oauth signature: #{form.oauth_signature}" unless signature_valid?
+    end
+
+    def signature_valid?
+      signature = OmniauthRegistrationForm.create_signature(form.provider, form.uid)
+      form.oauth_signature == signature
+    end
+  end
+
+  class InvalidOauthSignature < StandardError
+  end
+end

data/app/commands/decidim/create_registration.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module Decidim
+  # A command with all the business logic to create a user through the sign up form.
+  # It enables the option to sign up as a user group.
+  class CreateRegistration < Rectify::Command
+    # Public: Initializes the command.
+    #
+    # form - A form object with the params.
+    def initialize(form)
+      @form = form
+    end
+
+    # Executes the command. Broadcasts these events:
+    #
+    # - :ok when everything is valid.
+    # - :invalid if the form wasn't valid and we couldn't proceed.
+    #
+    # Returns nothing.
+    def call
+      return broadcast(:invalid) if form.invalid?
+
+      transaction do
+        create_user
+        create_user_group if form.is_user_group?
+      end
+
+      broadcast(:ok, @user)
+    end
+
+    private
+
+    attr_reader :form
+
+    def create_user
+      @user = User.create!(email: form.email,
+                           name: form.name,
+                           password: form.password,
+                           password_confirmation: form.password_confirmation,
+                           organization: form.current_organization,
+                           tos_agreement: form.tos_agreement)
+    end
+
+    def create_user_group
+      UserGroupMembership.create!(user: @user,
+                                  user_group: UserGroup.new(name: form.user_group_name,
+                                                            document_number: form.user_group_document_number,
+                                                            phone: form.user_group_phone))
+    end
+  end
+end

data/app/commands/decidim/invite_user.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module Decidim
+  # A command with the business logic to invite a user to an organization.
+  class InviteUser < Rectify::Command
+    # Public: Initializes the command.
+    #
+    # form - A form object with the params.
+    def initialize(form)
+      @form = form
+    end
+
+    def call
+      return broadcast(:invalid) if form.invalid?
+
+      if user.present?
+        set_user_roles
+      else
+        invite_user
+      end
+
+      broadcast(:ok)
+    end
+
+    private
+
+    attr_reader :form
+
+    def user
+      @user ||= Decidim::User.where(organization: form.organization).where(email: form.email.downcase).first
+    end
+
+    def set_user_roles
+      user.roles += form.roles
+      user.save!
+    end
+
+    def invite_user
+      Decidim::User.invite!(
+        {
+          name: form.name,
+          email: form.email.downcase,
+          organization: form.organization,
+          roles: form.roles
+        },
+        form.invited_by,
+        invitation_instructions: form.invitation_instructions
+      )
+    end
+  end
+end

data/app/commands/decidim/invite_user_again.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Decidim
+  # A command with the business logic to invite an user to an organization.
+  class InviteUserAgain < Rectify::Command
+    # Public: Initializes the command.
+    #
+    # form - A form object with the params.
+    def initialize(user, instructions)
+      @user = user
+      @instructions = instructions
+    end
+
+    def call
+      return broadcast(:invalid) unless user&.invited_to_sign_up?
+
+      user.deliver_invitation(invitation_instructions: instructions)
+
+      broadcast(:ok)
+    end
+
+    private
+
+    attr_reader :user, :instructions
+  end
+end

data/app/commands/decidim/remove_user_role.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module Decidim
+  # A command to remove a role from a given User.
+  class RemoveUserRole < Rectify::Command
+    # Public: Initializes the command.
+    #
+    # form - A form object with the params.
+    def initialize(user, role)
+      @user = user
+      @role = role
+    end
+
+    def call
+      return broadcast(:invalid) unless user
+
+      user.roles.delete(role.to_s)
+      user.save!
+
+      broadcast(:ok)
+    end
+
+    private
+
+    attr_reader :user, :role
+  end
+end

data/app/controllers/concerns/decidim/feature_settings.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require "active_support/concern"
+
+module Decidim
+  # This concern groups methods and helpers related to accessing the settings
+  # of a feature from a controller.
+  module FeatureSettings
+    extend ActiveSupport::Concern
+
+    included do
+      include NeedsParticipatoryProcess
+
+      helper_method :feature_settings, :current_settings
+
+      def feature_settings
+        current_feature.settings
+      end
+
+      def current_settings
+        active_step = current_participatory_process.active_step
+        return nil unless active_step
+
+        current_feature.step_settings.fetch(active_step.id.to_s)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+# rubocop:disable Metrics/BlockLength
+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.key?(method_name) ? @filter[method_name] : super
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @filter.present? && @filter.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/app/controllers/concerns/decidim/form_factory.rb

@@ -33,45 +33,48 @@ module Decidim
           # Initializes the form factory object.
           #
           # klass - the class name of the Form object that will be initialized
-          # context - the Controller where the form is built.
-          def initialize(klass, context)
+          # controller - the Controller where the form is built.
+          def initialize(klass, controller)
             @klass = klass
-            @context = context
+            @controller = controller
           end
 
           # Returns a simple instance of the form klass.
-          def instance(context = {})
-            @klass.new(context)
+          #
+          # extra_context - A Hash with optional extra context data.
+          def instance(extra_context = {})
+            @klass.new(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.
-          # context - a Hash with optional context data.
-          def from_model(model, context = {})
-            from_params(model.attributes, context)
+          # 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.
-          # context - a Hash with optional context data.
-          def from_params(params, context = {})
-            @klass.from_params(params, context_hash.merge(context))
+          # 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_hash
+          def context
             {
-              current_organization: @context.try(:current_organization),
-              current_user: @context.try(:current_user)
-            }.compact
+              current_organization: @controller.try(:current_organization),
+              current_feature: @controller.try(:current_feature),
+              current_user: @controller.try(:current_user)
+            }
           end
         end.new(klass, self)
       end