decidim-direct_verifications 0.22 → 1.0.1

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/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/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

@@ -2,24 +2,26 @@
 
 shared_examples_for "checking users" do |params|
   context "when check without mails" do
+    before { params[:userslist] = "" }
+
     it "renders the index with info message" do
-      params[:userlist] = ""
       perform_enqueued_jobs do
         post :create, params: params
         expect(flash[:info]).not_to be_empty
-        expect(flash[:info]).to include("0 users detected")
+        expect(flash[:info]).to include("0 participants 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
-      params[:userlist] = "mail@example.com"
       perform_enqueued_jobs do
         post :create, params: params
         expect(flash[:info]).not_to be_empty
-        expect(flash[:info]).to include("1 users detected")
+        expect(flash[:info]).to include("1 participants detected")
         expect(subject).to render_template("decidim/direct_verifications/verification/admin/direct_verifications/index")
       end
     end
@@ -34,7 +36,7 @@ shared_examples_for "registering users" do |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("1 participants")
         expect(flash[:warning]).to include("registered")
       end
     end
@@ -49,7 +51,7 @@ shared_examples_for "authorizing users" do |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("1 participants")
         expect(flash[:notice]).to include("verified")
       end
     end
@@ -58,19 +60,22 @@ end
 
 shared_examples_for "revoking users" do |params|
   context "when there are valid emails" do
-    it "creates notice message" 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("1 participants")
         expect(flash[:notice]).to include("revoked")
       end
     end

data/lib/decidim/direct_verifications/user_processor.rb

@@ -1,131 +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, session)
+      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, :session, :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), session) 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

data/lib/decidim/direct_verifications/user_stats.rb

@@ -22,7 +22,7 @@ module Decidim
       end
 
       def unconfirmed
-        registered_users.where("decidim_users.confirmed_at IS NULL").count
+        registered_users.where(decidim_users: { confirmed_at: nil }).count
       end
 
       def authorized
@@ -30,7 +30,7 @@ module Decidim
       end
 
       def authorized_unconfirmed
-        authorized_users.where("decidim_users.confirmed_at IS NULL").count
+        authorized_users.where(decidim_users: { confirmed_at: nil }).count
       end
 
       private
@@ -41,10 +41,10 @@ module Decidim
           filter[:email] = emails unless emails.empty?
           return User.where(filter).where.not(email: "")
         end
-        authorized_users(false)
+        authorized_users(strict: false)
       end
 
-      def authorized_users(strict = true)
+      def authorized_users(strict: true)
         q = Decidim::Authorization.joins(:user)
         unless authorization_handler.empty?
           q = q.where(name: authorization_handler)
@@ -56,7 +56,7 @@ module Decidim
         q = q.where("decidim_users.decidim_organization_id=:org and decidim_users.email!=''", org: organization.id)
         return q if emails.empty?
 
-        q.where("decidim_users.email IN (:emails)", emails: emails)
+        q.where(decidim_users: { email: emails })
       end
 
       def expires_in

data/lib/decidim/direct_verifications/verification/admin_engine.rb

@@ -10,12 +10,17 @@ module Decidim
         routes do
           resources :direct_verifications, only: [:index, :create, :stats]
           resources :stats, only: [:index]
+          resources :authorizations, only: [:index, :destroy]
+          resources :imports, only: [:new, :create]
 
           root to: "direct_verifications#index"
         end
 
         initializer "decidim_direct_verifications.admin_assets" do |app|
-          app.config.assets.precompile += %w(direct_verifications_admin_manifest.js)
+          app.config.assets.precompile += %w(
+            direct_verifications_admin_manifest.js
+            direct_verifications_admin_manifest.css
+          )
         end
       end
     end

data/lib/decidim/direct_verifications/version.rb

@@ -3,8 +3,8 @@
 module Decidim
   # This holds the decidim-direct_verifications version.
   module DirectVerifications
-    VERSION = "0.22"
-    DECIDIM_VERSION = "0.22"
-    MIN_DECIDIM_VERSION = ">= 0.22.0"
+    VERSION = "1.0.1"
+    DECIDIM_VERSION = "0.24.3"
+    MIN_DECIDIM_VERSION = ">= 0.23.0"
   end
 end

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