decidim-direct_verifications 0.17.8 → 1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4928cec1e6b6d4f5e09fd2235e38b4e7a0fe411dc4be792a25d5bff2a8ef5b6
-  data.tar.gz: 978ba2b8a55151a524643df8268e2f0435f329edc46acad48c3fe463f5382150
+  metadata.gz: 46d0f12ed4661879a4cdec82f1482875823fe9c5f4fba39c129e2a020d3c7f19
+  data.tar.gz: 5cf039fb0a1b3474082dbf7acc28013d8d0034c6d959c7c7ad589aca85c1fdf8
 SHA512:
-  metadata.gz: f9435b6e219c4c49c2d19899fe7482524ca101545f9099dd2b09a7a7c33a0d662ce0b60dace84582912b1e91c8969843b2263404e4730c31043908da455f345a
-  data.tar.gz: 42dc907a3fd1bfc59194a31007c6ed083a5b5610790bde8f32a50ef83ee5fed8ed8e4a215adb8586bb7e1e096a9244e5aa48c0a0973b0d1afce1f409ddc9cd3d
+  metadata.gz: 4f960edacf1528f9801d6cfd82aa6898a5bffbf9233a2386a57cdb0c55c0a3d5ef45ddf501d1775db1ab325dbcd61925b012dcc3ab8bf83bedbd4630abbf3b03
+  data.tar.gz: 909e8c8be3368861bc6fe75c1290f820a4d697e20bf4ded85d9e91ec9a5b7a27d3aa65953d749460d3fe0efbfe132fd8aa586ac27e032782127463be98476a61

data/README.md

@@ -1,6 +1,10 @@
 # Decidim::DirectVerifications
 
-[![Build Status](https://travis-ci.org/Platoniq/decidim-verifications-direct_verifications.svg?branch=master)](https://travis-ci.org/Platoniq/decidim-verifications-direct_verifications)
+[![Test](https://github.com/Platoniq/decidim-verifications-direct_verifications/actions/workflows/test.yml/badge.svg)](https://github.com/Platoniq/decidim-verifications-direct_verifications/actions/workflows/test.yml)
+[![Maintainability](https://api.codeclimate.com/v1/badges/2195deb4de6c6354a6bc/maintainability)](https://codeclimate.com/github/Platoniq/decidim-verifications-direct_verifications/maintainability)
+[![codecov](https://codecov.io/gh/Platoniq/decidim-verifications-direct_verifications/branch/main/graph/badge.svg?token=FR1zkV71S2)](https://codecov.io/gh/Platoniq/decidim-verifications-direct_verifications)
+
+
 
 A [Decidim](https://github.com/decidim/decidim) that provides a verification method called `Direct verification`. Works only on the admin side, final users do not intervene in the verification process.
 
@@ -34,6 +38,23 @@ With the detected list of emails admin have different options available:
 3. Revoke the authorization for the list of users using any verification method available.
 4. Check the status of the users in order to know if they are verified or registered.
 
+### Metadata mode
+
+This mode provides extra capabilities over the default processing:
+
+* Reads CSV format with header (copy and paste it from your spreadsheet)
+* Stores all columns except the email as authorization metadata
+
+This enables querying the authorization metadata however fits you best.
+
+To enable it create a new initializer, for instance `config/initializers/decidim_direct_verifications.rb` with the following contents
+
+```ruby
+Decidim::DirectVerifications.configure do |config|
+  config.input_parser = :metadata_parser
+end
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -48,6 +69,13 @@ And then execute:
 bundle
 ```
 
+Depending on your Decidim version, you might want to specify the version to ensure compatibility:
+
+| Direct Verifications version | Compatible Decidim versions |
+|---|---|
+| 1.0 | >= 0.23.x |
+| 0.22.x | 0.22.x |
+
 ## Using additional verification methods
 
 You can manage other verification methods (or workflow) a part from `Direct verification`. You need to configure it in a new file in the `config/initializers` folder.
@@ -68,7 +96,10 @@ end
 
 # We need to tell the plugin to handle this method in addition to the default "Direct verification". Any registered workflow is valid.
 Decidim::DirectVerifications.configure do |config|
-  config.manage_workflows = %w(direct_verifications_managers)
+  config.manage_workflows = %w(direct_verifications direct_verifications_managers)
+
+  # change the to the metadata_parser if you want it
+  # config.input_parser = :metadata_parser
 end
 
 ```
@@ -84,6 +115,11 @@ en:
       direct_verifications_managers:
         name: Organization managers
         explanation: Direct Verifications Subgroup explanation
+    verifications:
+      authorizations:
+        first_login:
+          actions:
+            direct_verifications_managers: Organization managers
 ```
 
 Similarly, you can also overwrite the default title "Direct verification" by creating the key again in your locales:
@@ -95,6 +131,11 @@ en:
       direct_verifications:
         name: Generic organization members
         explanation: Direct Verifications Subgroup explanation
+    verifications:
+      authorizations:
+        first_login:
+          actions:
+            direct_verifications: Generic organization members
 ```
 
 

data/app/assets/config/direct_verifications_admin_manifest.css

@@ -0,0 +1,3 @@
+/*
+ *= link decidim/direct_verifications/authorizations.css
+ */

data/app/assets/stylesheets/decidim/direct_verifications/authorizations.scss

@@ -0,0 +1,17 @@
+@import "decidim/admin/utils/settings";
+
+$code-color: $black;
+$code-font-family: $font-family-monospace;
+$code-font-weight: $global-weight-normal;
+$code-background: $light-gray;
+$code-border: 1px solid $medium-gray;
+$code-padding: rem-calc(2 5 1);
+
+.code {
+  background: $code-background;
+  color: $code-color;
+  font-family: $code-font-family;
+  font-weight: $code-font-weight;
+  border: $code-border;
+  padding: $code-padding;
+}

data/app/commands/decidim/direct_verifications/verification/create_import.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DirectVerifications
+    module Verification
+      class CreateImport < Rectify::Command
+        def initialize(form)
+          @form = form
+          @file = form.file
+          @organization = form.organization
+          @user = form.user
+          @action = form.action
+        end
+
+        def call
+          return broadcast(:invalid) unless form.valid?
+
+          case action
+          when :register
+            register_users_async
+          when :register_and_authorize
+            register_users_async
+            file.rewind
+            authorize_users_async
+          when :revoke
+            revoke_users_async
+          end
+
+          broadcast(:ok)
+        end
+
+        private
+
+        attr_reader :form, :file, :organization, :user, :action
+
+        def register_users_async
+          RegisterUsersJob.perform_later(file.read, organization, user, form.authorization_handler)
+        end
+
+        def revoke_users_async
+          RevokeUsersJob.perform_later(file.read, organization, user, form.authorization_handler)
+        end
+
+        def authorize_users_async
+          AuthorizeUsersJob.perform_later(file.read, organization, user, form.authorization_handler)
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/direct_verifications/verification/admin/authorizations_controller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DirectVerifications
+    module Verification
+      module Admin
+        class AuthorizationsController < Decidim::Admin::ApplicationController
+          layout "decidim/admin/users"
+
+          def index
+            enforce_permission_to :index, :authorization
+            @authorizations = collection.includes(:user)
+          end
+
+          def destroy
+            if authorization.destroy
+              flash[:notice] = "successfully"
+              redirect_to authorizations_path
+            end
+          end
+
+          private
+
+          def collection
+            # Decidim::Verifications::Authorizations Query
+            Decidim::Verifications::Authorizations.new(
+              organization: current_organization,
+              name: "direct_verifications",
+              granted: true
+            ).query
+          end
+
+          def authorization
+            @authorization ||= collection.find_by(id: params[:id])
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/direct_verifications/verification/admin/direct_verifications_controller.rb

@@ -6,75 +6,100 @@ module Decidim
       module Admin
         class DirectVerificationsController < Decidim::Admin::ApplicationController
           include NeedsPermission
+          helper_method :workflows, :current_authorization_handler
 
           layout "decidim/admin/users"
 
           def index
             enforce_permission_to :index, :authorization
-            @authorization_handler = :direct_verifications
-            @workflows = workflows
           end
 
           def create
             enforce_permission_to :create, :authorization
 
-            @userlist = params[:userlist]
-            @workflows = workflows
-            processor = UserProcessor.new(current_organization, current_user)
-            processor.emails = extract_emails_to_hash @userlist
-            processor.authorization_handler = authorization_handler(params[:authorization_handler])
-            stats = UserStats.new(current_organization)
-            stats.authorization_handler = processor.authorization_handler
-            if params[:register]
-              processor.register_users
-              flash[:warning] = t(".registered", count: processor.emails.count,
-                                                 registered: processor.processed[:registered].count,
-                                                 errors: processor.errors[:registered].count)
-            end
-            if params[:authorize] == "in"
-              processor.authorize_users
-              flash[:notice] = t(".authorized", handler: t("#{processor.authorization_handler}.name", scope: "decidim.authorization_handlers"),
-                                                count: processor.emails.count,
-                                                authorized: processor.processed[:authorized].count,
-                                                errors: processor.errors[:authorized].count)
-            elsif params[:authorize] == "out"
-              processor.revoke_users
-              flash[:notice] = t(".revoked", handler: t("#{processor.authorization_handler}.name", scope: "decidim.authorization_handlers"),
-                                             count: processor.emails.count,
-                                             revoked: processor.processed[:revoked].count,
-                                             errors: processor.errors[:revoked].count)
-            else
-              stats.emails = processor.emails.keys
-              flash[:info] = t(".info", handler: t("#{processor.authorization_handler}.name", scope: "decidim.authorization_handlers"),
-                                        count: processor.emails.count,
-                                        authorized: stats.authorized,
-                                        unconfirmed: stats.unconfirmed,
-                                        registered: stats.registered)
-              render(action: :index) && return
-            end
+            @userslist = params[:userslist]
+
+            @processor = UserProcessor.new(current_organization, current_user, session, instrumenter)
+            @processor.emails = parser_class.new(@userslist).to_h
+            @processor.authorization_handler = current_authorization_handler
+
+            @stats = UserStats.new(current_organization)
+            @stats.authorization_handler = @processor.authorization_handler
+
+            register_users
+            authorize_users
+            revoke_users
+
+            render(action: :index) && return if show_users_info
+
+            redirect_to direct_verifications_path
+          rescue InputParserError => e
+            flash[:error] = e.message
             redirect_to direct_verifications_path
           end
 
           private
 
-          def extract_emails_to_hash(txt)
-            reg = /([A-Z0-9+._-]+@[A-Z0-9._-]+\.[A-Z0-9_-]+)\b/i
-            emails = {}
-            txt.split(/[\r\n;,]/).each do |line|
-              reg.match line do |m|
-                n = line.split(m[0]).first
-                emails[m[0]] = (n.presence || "").gsub(/[^[:print:]]|[\"\$\<\>\|\\]/, "").strip
-              end
-            end
-            emails
+          def instrumenter
+            @instrumenter ||= Instrumenter.new(current_user)
+          end
+
+          def register_users
+            return unless params[:register]
+
+            @processor.register_users
+            flash[:warning] = t(".registered", count: @processor.emails.count,
+                                               registered: instrumenter.processed_count(:registered),
+                                               errors: instrumenter.errors_count(:registered))
+          end
+
+          def authorize_users
+            return unless params[:authorize] == "in"
+
+            @processor.authorize_users
+            flash[:notice] = t(".authorized", handler: t("#{@processor.authorization_handler}.name", scope: "decidim.authorization_handlers"),
+                                              count: @processor.emails.count,
+                                              authorized: instrumenter.processed_count(:authorized),
+                                              errors: instrumenter.errors_count(:authorized))
+          end
+
+          def revoke_users
+            return unless params[:authorize] == "out"
+
+            @processor.revoke_users
+            flash[:notice] = t(".revoked", handler: t("#{@processor.authorization_handler}.name", scope: "decidim.authorization_handlers"),
+                                           count: @processor.emails.count,
+                                           revoked: instrumenter.processed_count(:revoked),
+                                           errors: instrumenter.errors_count(:revoked))
+          end
+
+          def show_users_info
+            return if params[:authorize].in? %w(in out)
+
+            @stats.emails = @processor.emails.keys
+            flash.now[:info] = t(".info", handler: t("#{@processor.authorization_handler}.name", scope: "decidim.authorization_handlers"),
+                                          count: @processor.emails.count,
+                                          authorized: @stats.authorized,
+                                          unconfirmed: @stats.unconfirmed,
+                                          registered: @stats.registered)
+            true
+          end
+
+          def parser_class
+            Decidim::DirectVerifications.find_parser_class(Decidim::DirectVerifications.input_parser)
           end
 
           def authorization_handler(authorization_handler)
             @authorization_handler = authorization_handler.presence || :direct_verifications
           end
 
+          def current_authorization_handler
+            authorization_handler(params[:authorization_handler])
+          end
+
           def configured_workflows
             return Decidim::DirectVerifications.config.manage_workflows if Decidim::DirectVerifications.config
+
             ["direct_verifications"]
           end
 

data/app/controllers/decidim/direct_verifications/verification/admin/imports_controller.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DirectVerifications
+    module Verification
+      module Admin
+        class ImportsController < Decidim::Admin::ApplicationController
+          layout "decidim/admin/users"
+          helper_method :workflows, :current_authorization_handler
+
+          def new
+            enforce_permission_to :create, :authorization
+            @form = form(CreateImportForm).instance
+          end
+
+          def create
+            enforce_permission_to :create, :authorization
+
+            defaults = { organization: current_organization, user: current_user }
+            form = form(CreateImportForm).from_params(params.merge(defaults))
+
+            CreateImport.call(form) do
+              on(:ok) do
+                flash[:notice] = t(".success")
+              end
+
+              on(:invalid) do
+                flash[:alert] = t(".error")
+              end
+            end
+
+            redirect_to new_import_path
+          end
+
+          def workflows
+            workflows = configured_workflows & current_organization.available_authorizations.map.to_a
+            workflows.map do |workflow|
+              [t("#{workflow}.name", scope: "decidim.authorization_handlers"), workflow]
+            end
+          end
+
+          def configured_workflows
+            return Decidim::DirectVerifications.config.manage_workflows if Decidim::DirectVerifications.config
+
+            ["direct_verifications"]
+          end
+
+          def current_authorization_handler
+            params[:authorization_handler]
+          end
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/direct_verifications/registration_form.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DirectVerifications
+    class RegistrationForm < OpenStruct
+    end
+  end
+end

data/app/forms/decidim/direct_verifications/verification/create_import_form.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DirectVerifications
+    module Verification
+      class CreateImportForm < Form
+        ACTIONS = {
+          "in" => :authorize,
+          "out" => :revoke,
+          "check" => :check
+        }.freeze
+
+        attribute :file
+        attribute :organization, Decidim::Organization
+        attribute :user, Decidim::User
+        attribute :authorize, String
+        attribute :register, Boolean
+        attribute :authorization_handler, String
+
+        validates :file, :organization, :user, :authorize, :authorization_handler, presence: true
+        validates :authorize, inclusion: { in: ACTIONS.keys }
+
+        validate :available_authorization_handler
+
+        def available_authorization_handler
+          return if authorization_handler.in?(organization.available_authorizations)
+
+          errors.add(:authorization_handler, :inclusion)
+        end
+
+        def action
+          if register && authorize == "in"
+            :register_and_authorize
+          elsif register
+            :register
+          else
+            ACTIONS[authorize]
+          end
+        end
+      end
+    end
+  end
+end