decidim-direct_verifications 0.22.1 → 1.0

data/config/locales/fr.yml

@@ -0,0 +1,69 @@
+fr:
+  decidim:
+    admin:
+      models:
+        user:
+          fields:
+            roles:
+              participant: Participant
+    authorization_handlers:
+      admin:
+        direct_verifications:
+          help:
+            - 'Permet l''introduction massive des utilisateurs afin de :'
+            - Inscription directe au sein de l'organisation et envoie des invitations
+            - Vérifiez-les avec n'importe quelle méthode de vérification active
+            - Révoquer leur vérification dans toute méthode de vérification active
+      direct_verifications:
+        explanation: Vérification manuelle par les administrateurs de l'organisation
+        name: Vérification directe
+    direct_verifications:
+      verification:
+        admin:
+          authorizations:
+            index:
+              created_at: Créé à
+              metadata: Métadonnées
+              name: Nom
+              title: Autorisations
+              user_name: Nom de l'utilisateur
+              new_import: Nouvel import
+          direct_verifications:
+            create:
+              authorized: "%{authorized} utilisateurs ont été vérifiés avec succès en utilisant [%{handler}] (%{count} détectés, %{errors} erreurs)"
+              info: "%{count} utilisateurs détectés, dont %{registered} sont enregistrés, %{authorized} autorisés à utiliser [%{handler}] (%{unconfirmed} non confirmés)"
+              registered: "%{registered} utilisateurs ont été enregistrés avec succès (%{count} détectés, %{errors} erreurs) "
+              revoked: La vérification de %{revoked} utilisateurs ont été révoqués en utilisant [%{handler}] (%{count} détectés, %{errors} erreurs)
+            gdpr_disclaimer: Faites-le sous votre responsabilité. N'oubliez pas que vous devez avoir le consentement explicite de vos utilisateurs afin de les enregistrer. Dans le cas contraire, vous enfreindrez le règlement du RGPD dans les pays de l'UE.
+          index:
+            authorizations: Utilisateurs autorisés
+            stats: Statistiques des utilisateurs
+            title: Inscription et autorisation des utilisateurs
+          new:
+            authorization_handler: Méthode de vérification
+            authorize: Utilisateurs autorisés
+            check: Vérifier le statut des utilisateurs
+            info: Entrez les e-mails ici, un par ligne. Si les e-mails sont précédés d'un texte, il sera interprété comme le nom de l'utilisateur
+            register: Inscrire des utilisateurs sur la plateforme (si ils existent, ils seront ignorés)
+            revoke: Révoquer l'autorisation des utilisateurs
+            submit: Envoyer et traiter la liste
+            textarea: Liste d'emails
+          stats:
+            index:
+              authorized: Autorisé
+              authorized_unconfirmed: Autorisé mais non confirmé
+              global: "- N'importe quelle méthode de vérification -"
+              registered: Inscrits
+              unconfirmed: Non confirmé
+        authorizations:
+          new:
+            no_action: Cette méthode nécessite un administrateur qui vous vérifie
+    verifications:
+      authorizations:
+        first_login:
+          actions:
+            direct_verifications: Vérification directe
+  devise:
+    mailer:
+      direct_invite:
+        subject: Instructions d'invitation

data/lib/decidim/direct_verifications.rb

@@ -1,12 +1,35 @@
 # frozen_string_literal: true
 
 require_relative "direct_verifications/version"
-require_relative "direct_verifications/config"
 require_relative "direct_verifications/user_processor"
 require_relative "direct_verifications/user_stats"
 require_relative "direct_verifications/verification"
+require_relative "direct_verifications/parsers"
 
 module Decidim
   module DirectVerifications
+    include ActiveSupport::Configurable
+
+    class InputParserError < StandardError; end
+
+    # Specify in this variable which authorization methods can be managed by the plugin
+    # Be careful to specify only what you really need
+    config_accessor :manage_workflows do
+      ["direct_verifications"]
+    end
+
+    # The processor for the user uploaded data where to extract emails and other info
+    # be default it uses Decidim::DirectVerifications::Parsers::NameParser
+    # Currently available are:
+    # - :name_parser
+    # - :metadata_parser
+    # A custom parser can be specified as long it respects the module hierachy
+    config_accessor :input_parser do
+      :name_parser
+    end
+
+    def self.find_parser_class(manifest)
+      "Decidim::DirectVerifications::Parsers::#{manifest.to_s.camelize}".safe_constantize || Decidim::DirectVerifications::Parsers::NameParser
+    end
   end
 end

data/lib/decidim/direct_verifications/authorize_user.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DirectVerifications
+    class AuthorizeUser
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(email, data, session, organization, instrumenter, authorization_handler)
+        @email = email
+        @data = data
+        @session = session
+        @organization = organization
+        @instrumenter = instrumenter
+        @authorization_handler = authorization_handler
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def call
+        unless user
+          instrumenter.add_error :authorized, email
+          return
+        end
+
+        return unless valid_authorization?
+
+        Verification::ConfirmUserAuthorization.call(authorization, form, session) do
+          on(:ok) do
+            instrumenter.add_processed :authorized, email
+          end
+          on(:invalid) do
+            instrumenter.add_error :authorized, email
+          end
+        end
+      end
+
+      private
+
+      attr_reader :email, :data, :session, :organization, :instrumenter, :authorization_handler
+
+      def valid_authorization?
+        !authorization.granted? || authorization.expired?
+      end
+
+      def user
+        @user ||= User.find_by(email: email, decidim_organization_id: organization.id)
+      end
+
+      def authorization
+        @authorization ||=
+          begin
+            auth = Authorization.find_or_initialize_by(
+              user: user,
+              name: authorization_handler
+            )
+            auth.metadata = data
+            auth
+          end
+      end
+
+      def form
+        Verification::DirectVerificationsForm.new(email: user.email, name: user.name)
+      end
+    end
+  end
+end

data/lib/decidim/direct_verifications/instrumenter.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DirectVerifications
+    class Instrumenter
+      def initialize(current_user)
+        @current_user = current_user
+        @errors = { registered: Set.new, authorized: Set.new, revoked: Set.new }
+        @processed = { registered: Set.new, authorized: Set.new, revoked: Set.new }
+      end
+
+      def add_processed(type, email)
+        @processed[type] << email
+      end
+
+      def add_error(type, email)
+        @errors[type] << email
+      end
+
+      def processed_count(key)
+        processed[key].size
+      end
+
+      def errors_count(key)
+        errors[key].size
+      end
+
+      def emails_count(key)
+        @processed[key].size + @errors[key].size
+      end
+
+      def track(event, email, user = nil)
+        if user
+          add_processed event, email
+          log_action user
+        else
+          add_error event, email
+        end
+      end
+
+      private
+
+      attr_reader :current_user, :processed, :errors
+
+      def log_action(user)
+        Decidim.traceability.perform_action!(
+          "invite",
+          user,
+          current_user,
+          extra: {
+            invited_user_role: "participant",
+            invited_user_id: user.id
+          }
+        )
+      end
+    end
+  end
+end

data/lib/decidim/direct_verifications/parsers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DirectVerifications
+    module Parsers
+      autoload :BaseParser, "decidim/direct_verifications/parsers/base_parser"
+      autoload :NameParser, "decidim/direct_verifications/parsers/name_parser"
+      autoload :MetadataParser, "decidim/direct_verifications/parsers/metadata_parser"
+    end
+  end
+end

data/lib/decidim/direct_verifications/parsers/base_parser.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DirectVerifications
+    module Parsers
+      # Abstract class all concrete parsers should inherit from. They are expected to implement
+      # #header, #lines, and #parse_data methods.
+      class BaseParser
+        EMAIL_REGEXP = /([A-Z0-9+._-]+@[A-Z0-9._-]+\.[A-Z0-9_-]+)\b/i.freeze
+
+        def initialize(txt)
+          @txt = txt
+          @emails = {}
+        end
+
+        def to_h
+          lines.each do |line|
+            EMAIL_REGEXP.match(line) do |match|
+              email = normalize(match[0])
+              emails[email] = parse_data(email, line, header)
+            end
+          end
+
+          emails
+        end
+
+        private
+
+        attr_reader :txt, :emails
+
+        def normalize(value)
+          value.to_s.downcase
+        end
+      end
+    end
+  end
+end

data/lib/decidim/direct_verifications/parsers/metadata_parser.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module Decidim
+  module DirectVerifications
+    module Parsers
+      class MetadataParser < BaseParser
+        I18N_SCOPE = "decidim.direct_verifications.verification.admin.direct_verifications"
+
+        def header
+          @header ||= begin
+            header_row = lines[0].chomp
+            header_row = tokenize(header_row)
+            normalize_header(header_row)
+          end
+        end
+
+        def lines
+          @lines ||= StringIO.new(txt).readlines
+        end
+
+        def parse_data(email, line, header)
+          tokens = tokenize(line)
+
+          hash = {}
+          header.each_with_index do |column, index|
+            value = tokens[index]
+            next if value&.include?(email)
+
+            hash[column] = value
+          end
+          hash
+        end
+
+        private
+
+        def tokenize(line)
+          CSV.parse_line(line).map do |token|
+            token&.strip
+          end
+        end
+
+        def normalize_header(line)
+          line.map do |field|
+            raise InputParserError, I18n.t("#{I18N_SCOPE}.create.missing_header") if field.nil?
+
+            field.to_sym.downcase
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decidim/direct_verifications/parsers/name_parser.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DirectVerifications
+    module Parsers
+      class NameParser < BaseParser
+        LINE_DELIMITER = /[\r\n;,]/.freeze
+        NON_ALPHA_CHARS = /[^[:print:]]|["$<>|\\]/.freeze
+
+        def header
+          nil
+        end
+
+        def lines
+          txt.split(LINE_DELIMITER)
+        end
+
+        def parse_data(email, line, _header)
+          name = parse_name(email, line)
+          name = strip_non_alpha_chars(name)
+          name.presence || fallback_name(email)
+        end
+
+        private
+
+        def strip_non_alpha_chars(str)
+          (str.presence || "").gsub(NON_ALPHA_CHARS, "").strip
+        end
+
+        def parse_name(email, line)
+          line.split(email).first
+        end
+
+        def fallback_name(email)
+          email.split("@").first
+        end
+      end
+    end
+  end
+end

data/lib/decidim/direct_verifications/register_user.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DirectVerifications
+    class RegisterUser
+      def initialize(email, data, organization, current_user, instrumenter)
+        @email = email
+        @name = data.is_a?(Hash) ? data[:name] : data
+        @organization = organization
+        @current_user = current_user
+        @instrumenter = instrumenter
+      end
+
+      def call
+        return if user
+
+        InviteUser.call(form) do
+          on(:ok) do
+            instrumenter.track(:registered, email, user)
+          end
+          on(:invalid) do
+            instrumenter.track(:registered, email)
+          end
+        end
+      rescue StandardError => e
+        instrumenter.track(:registered, email)
+        raise e if Rails.env.test? || Rails.env.development?
+      end
+
+      private
+
+      attr_reader :email, :name, :organization, :current_user, :instrumenter
+
+      def user
+        @user ||= User.find_by(email: email, decidim_organization_id: organization.id)
+      end
+
+      def form
+        RegistrationForm.new(
+          name: name.presence || fallback_name,
+          email: email.downcase,
+          organization: organization,
+          admin: false,
+          invited_by: current_user,
+          invitation_instructions: "direct_invite"
+        )
+      end
+
+      def fallback_name
+        email.split("@").first
+      end
+    end
+  end
+end

data/lib/decidim/direct_verifications/revoke_user.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DirectVerifications
+    class RevokeUser
+      def initialize(email, organization, instrumenter, authorization_handler)
+        @email = email
+        @organization = organization
+        @instrumenter = instrumenter
+        @authorization_handler = authorization_handler
+      end
+
+      def call
+        unless user
+          instrumenter.add_error :revoked, email
+          return
+        end
+
+        return unless valid_authorization?
+
+        Verification::DestroyUserAuthorization.call(authorization) do
+          on(:ok) do
+            instrumenter.add_processed :revoked, email
+          end
+        end
+      end
+
+      private
+
+      attr_reader :email, :organization, :instrumenter, :authorization_handler
+
+      def user
+        @user ||= User.find_by(email: email, decidim_organization_id: organization.id)
+      end
+
+      def authorization
+        @authorization ||= Authorization.find_by(user: user, name: authorization_handler)
+      end
+
+      def valid_authorization?
+        authorization&.granted?
+      end
+    end
+  end
+end