decidim-direct_verifications 0.17.8 → 1.0

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

data/lib/decidim/direct_verifications/tests/factories.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "decidim/core/test/factories"
+
+FactoryBot.modify do
+  factory :authorization do
+    trait :direct_verification do
+      name { "direct_verifications" }
+    end
+  end
+end

data/lib/decidim/direct_verifications/tests/verification_controller_examples.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+shared_examples_for "checking users" do |params|
+  context "when check without mails" do
+    before { params[:userslist] = "" }
+
+    it "renders the index with info message" do
+      perform_enqueued_jobs do
+        post :create, params: params
+        expect(flash[:info]).not_to be_empty
+        expect(flash[:info]).to include("0 users detected")
+        expect(subject).to render_template("decidim/direct_verifications/verification/admin/direct_verifications/index")
+      end
+    end
+  end
+
+  context "when check with mails" do
+    before { params[:userslist] = "mail@example.com" }
+
+    it "renders the index with info message" do
+      perform_enqueued_jobs do
+        post :create, params: params
+        expect(flash[:info]).not_to be_empty
+        expect(flash[:info]).to include("1 users detected")
+        expect(subject).to render_template("decidim/direct_verifications/verification/admin/direct_verifications/index")
+      end
+    end
+  end
+end
+
+shared_examples_for "registering users" do |params|
+  context "when there are valid emails" do
+    it "creates warning message" do
+      perform_enqueued_jobs do
+        post :create, params: params
+        expect(flash[:warning]).not_to be_empty
+        expect(flash[:warning]).to include("1 detected")
+        expect(flash[:warning]).to include("0 errors")
+        expect(flash[:warning]).to include("1 users")
+        expect(flash[:warning]).to include("registered")
+      end
+    end
+  end
+end
+
+shared_examples_for "authorizing users" do |params|
+  context "when there are valid emails" do
+    it "creates notice message" do
+      perform_enqueued_jobs do
+        post :create, params: params
+        expect(flash[:notice]).not_to be_empty
+        expect(flash[:notice]).to include("1 detected")
+        expect(flash[:notice]).to include("0 errors")
+        expect(flash[:notice]).to include("1 users")
+        expect(flash[:notice]).to include("verified")
+      end
+    end
+  end
+end
+
+shared_examples_for "revoking users" do |params|
+  context "when there are valid emails" do
+    before do
+      create(
+        :authorization,
+        :granted,
+        name: verification_type,
+        user: authorized_user
+      )
+    end
+
+    it "creates notice message" do
+      perform_enqueued_jobs do
+        post :create, params: params
+        expect(flash[:notice]).not_to be_empty
+        expect(flash[:notice]).to include("1 detected")
+        expect(flash[:notice]).to include("0 errors")
+        expect(flash[:notice]).to include("1 users")
+        expect(flash[:notice]).to include("revoked")
+      end
+    end
+  end
+end

data/lib/decidim/direct_verifications/user_processor.rb

@@ -1,127 +1,47 @@
 # frozen_string_literal: true
 
+require "decidim/direct_verifications/register_user"
+require "decidim/direct_verifications/authorize_user"
+require "decidim/direct_verifications/revoke_user"
+require "decidim/direct_verifications/instrumenter"
+
 module Decidim
   module DirectVerifications
     class UserProcessor
-      def initialize(organization, current_user)
+      def initialize(organization, current_user, session, instrumenter)
         @organization = organization
         @current_user = current_user
         @authorization_handler = :direct_verifications
-        @errors = { registered: [], authorized: [], revoked: [] }
-        @processed = { registered: [], authorized: [], revoked: [] }
+
         @emails = {}
+        @session = session
+        @instrumenter = instrumenter
       end
 
-      attr_reader :organization, :current_user, :errors, :processed, :emails
-      attr_accessor :authorization_handler
-
-      def emails=(email_list)
-        @emails = email_list.map { |k, v| [k.to_s.downcase, v.presence || k.split("@").first] }.to_h
-      end
+      attr_reader :organization, :current_user, :session, :errors, :processed
+      attr_accessor :authorization_handler, :emails
 
       def register_users
-        @emails.each do |email, name|
-          next if find_user(email)
-          form = register_form(email, name)
-          begin
-            InviteUser.call(form) do
-              on(:ok) do
-                add_processed :registered, email
-                log_action find_user(email)
-              end
-              on(:invalid) do
-                add_error :registered, email
-              end
-            end
-          rescue StandardError
-            add_error :registered, email
-          end
+        emails.each do |email, data|
+          RegisterUser.new(email, data, organization, current_user, instrumenter).call
         end
       end
 
       def authorize_users
-        @emails.each do |email, _name|
-          if (u = find_user(email))
-            auth = authorization(u)
-            next unless !auth.granted? || auth.expired?
-            Verification::ConfirmUserAuthorization.call(auth, authorize_form(u)) do
-              on(:ok) do
-                add_processed :authorized, email
-              end
-              on(:invalid) do
-                add_error :authorized, email
-              end
-            end
-          else
-            add_error :authorized, email
-          end
+        emails.each do |email, data|
+          AuthorizeUser.new(email, data, session, organization, instrumenter, authorization_handler).call
         end
       end
 
       def revoke_users
-        @emails.each do |email, _name|
-          if (u = find_user(email))
-            auth = authorization(u)
-            next unless auth.granted?
-            Verification::DestroyUserAuthorization.call(auth) do
-              on(:ok) do
-                add_processed :revoked, email
-              end
-              on(:invalid) do
-                add_error :revoked, email
-              end
-            end
-          else
-            add_error :revoked, email
-          end
+        emails.each do |email, _name|
+          RevokeUser.new(email, organization, instrumenter, authorization_handler).call
         end
       end
 
       private
 
-      def find_user(email)
-        User.find_by(email: email, decidim_organization_id: @organization.id)
-      end
-
-      def register_form(email, name)
-        OpenStruct.new(name: name.presence || email.split("@").first,
-                       email: email.downcase,
-                       organization: organization,
-                       admin: false,
-                       invited_by: current_user,
-                       invitation_instructions: "direct_invite")
-      end
-
-      def authorization(user)
-        Authorization.find_or_initialize_by(
-          user: user,
-          name: authorization_handler
-        )
-      end
-
-      def authorize_form(user)
-        Verification::DirectVerificationsForm.new(email: user.email, name: user.name)
-      end
-
-      def add_processed(type, email)
-        @processed[type] << email unless @processed[type].include? email
-      end
-
-      def add_error(type, email)
-        @errors[type] << email unless @errors[type].include? email
-      end
-
-      def log_action(user)
-        Decidim.traceability.perform_action!(
-          "invite",
-          user,
-          current_user,
-          extra: {
-            invited_user_role: "participant",
-            invited_user_id: user.id
-          }
-        )
-      end
+      attr_reader :instrumenter
     end
   end
 end