decidim-action_delegator 0.5.0 → 0.7.0

data/app/controllers/decidim/action_delegator/verifications/delegations_verifier/authorizations_controller.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    module Verifications
+      module DelegationsVerifier
+        class AuthorizationsController < ApplicationController
+          include Decidim::FormFactory
+          include Decidim::Verifications::Renewable
+
+          helper_method :authorization, :setting
+
+          def new
+            enforce_permission_to :create, :authorization, authorization: authorization
+
+            @form = form(DelegationsVerifierForm).instance(setting: setting)
+          end
+
+          def create
+            enforce_permission_to :create, :authorization, authorization: authorization
+
+            @form = form(DelegationsVerifierForm).from_params(params, setting: setting)
+            participant = @form&.participant
+
+            Decidim::Verifications::PerformAuthorizationStep.call(authorization, @form) do
+              on(:ok) do
+                if setting.phone_required?
+                  flash[:notice] = t("authorizations.create.success", scope: "decidim.verifications.sms")
+                  authorization_method = Decidim::Verifications::Adapter.from_element(authorization.name)
+                  redirect_to authorization_method.resume_authorization_path(redirect_url: redirect_url)
+                else
+                  authorization.grant!
+                  participant.update!(decidim_user: authorization.user)
+                  flash[:notice] = t("authorizations.update.success", scope: "decidim.verifications.sms")
+
+                  if redirect_url
+                    redirect_to redirect_url
+                  else
+                    redirect_to decidim_verifications.authorizations_path
+                  end
+                end
+              end
+              on(:invalid) do
+                flash.now[:alert] = t("authorizations.create.error", scope: "decidim.verifications.sms")
+                render :new
+              end
+            end
+          end
+
+          def edit
+            enforce_permission_to :update, :authorization, authorization: authorization
+
+            @form = form(Decidim::Verifications::Sms::ConfirmationForm).from_params(params)
+          end
+
+          def update
+            enforce_permission_to :update, :authorization, authorization: authorization
+
+            @form = form(Decidim::Verifications::Sms::ConfirmationForm).from_params(params)
+
+            Decidim::Verifications::ConfirmUserAuthorization.call(authorization, @form, session) do
+              on(:ok) do
+                flash[:notice] = t("authorizations.update.success", scope: "decidim.verifications.sms")
+
+                if redirect_url
+                  redirect_to redirect_url
+                else
+                  redirect_to decidim_verifications.authorizations_path
+                end
+              end
+
+              on(:invalid) do
+                flash.now[:alert] = t("authorizations.update.error", scope: "decidim.verifications.sms")
+                render :edit
+              end
+            end
+          end
+
+          def destroy
+            enforce_permission_to :destroy, :authorization, authorization: authorization
+
+            authorization.destroy!
+            flash[:notice] = t("authorizations.destroy.success", scope: "decidim.verifications.sms")
+
+            redirect_to action: :new
+          end
+
+          private
+
+          def authorization
+            @authorization ||= Decidim::Authorization.find_or_initialize_by(
+              user: current_user,
+              name: "delegations_verifier"
+            )
+          end
+
+          def setting
+            @setting ||= all_settings.first
+          end
+
+          def all_settings
+            @all_settings ||= OrganizationSettings.new(current_user.organization).active
+          end
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/action_delegator/admin/delegation_form.rb

@@ -6,18 +6,37 @@ module Decidim
       # A form object used to create a Delegation
       #
       class DelegationForm < Form
+        mimic :delegation
+
         attribute :granter_id, Integer
         attribute :grantee_id, Integer
 
-        validates :granter_id, presence: true
-        validates :grantee_id, presence: true
+        attribute :granter_email, String
+        attribute :grantee_email, String
+
+        validate :granter_exists
+        validate :grantee_exists
 
         def granter
-          User.find_by(id: granter_id)
+          User.find_by(id: granter_id) || User.find_by(email: granter_email)
         end
 
         def grantee
-          User.find_by(id: grantee_id)
+          User.find_by(id: grantee_id) || User.find_by(email: grantee_email)
+        end
+
+        private
+
+        def granter_exists
+          return if granter.present?
+
+          errors.add :granter_email, I18n.t("decidim.action_delegator.admin.delegations.granter_missing")
+        end
+
+        def grantee_exists
+          return if grantee.present?
+
+          errors.add :grantee_email, I18n.t("decidim.action_delegator.admin.delegations.grantee_missing")
         end
       end
     end

data/app/forms/decidim/action_delegator/admin/invitation_participant_form.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    module Admin
+      class InvitationParticipantForm < OpenStruct
+      end
+    end
+  end
+end

data/app/forms/decidim/action_delegator/admin/participant_form.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    module Admin
+      class ParticipantForm < Form
+        mimic :participant
+
+        attribute :email, String
+        attribute :phone, String
+        attribute :decidim_action_delegator_ponderation_id, Integer
+        attribute :weight, String
+
+        validates :email, presence: true, if: ->(form) { form.authorization_method.in? %w(email both) }
+        validates :phone, presence: true, if: ->(form) { form.authorization_method.in? %w(phone both) }
+        validate :ponderation_belongs_to_setting
+
+        # When there's a phone number, sanitize it allowing only numbers and +.
+        def phone
+          return unless super
+
+          super.gsub(/[^+0-9]/, "")
+        end
+
+        def setting
+          @setting ||= context[:setting]
+        end
+
+        def authorization_method
+          @authorization_method ||= setting&.authorization_method
+        end
+
+        private
+
+        def ponderation_belongs_to_setting
+          return if decidim_action_delegator_ponderation_id.blank?
+          return if setting.ponderations.where(id: decidim_action_delegator_ponderation_id).any?
+
+          errors.add(:decidim_action_delegator_ponderation_id, :invalid)
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/action_delegator/admin/ponderation_form.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    module Admin
+      class PonderationForm < Form
+        mimic :ponderation
+
+        attribute :weight, Decimal, default: 1.0
+        attribute :name, String
+
+        validates :weight, :name, presence: true
+        validate :name_uniqueness
+
+        def name_uniqueness
+          return unless setting
+          return unless setting.ponderations.where(name: name).where.not(id: id).any?
+
+          errors.add(:name, :taken)
+        end
+
+        def setting
+          @setting ||= context[:setting]
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/action_delegator/admin/setting_form.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    module Admin
+      class SettingForm < Form
+        mimic :setting
+
+        attribute :max_grants, Integer
+        attribute :decidim_consultation_id, Integer
+        attribute :authorization_method, String
+        attribute :copy_from_setting_id, Integer
+
+        validates :max_grants, :decidim_consultation_id, presence: true
+        validate :consultation_uniqueness
+
+        # TODO: validate consultation vote starting in the future
+        def consultation_uniqueness
+          errors.add(:decidim_consultation_id, :taken) if record.exists?(decidim_consultation_id: decidim_consultation_id)
+        end
+
+        def record
+          Setting.where.not(id: id)
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/action_delegator/verifications/delegations_verifier_form.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Decidim
+  module ActionDelegator
+    module Verifications
+      # A form object to be used when public users want to get verified using their phone.
+      class DelegationsVerifierForm < AuthorizationHandler
+        attribute :email, String
+        attribute :phone, String
+
+        validates :verification_code, :sms_gateway, presence: true
+        validates :phone, presence: true, if: ->(form) { form.setting&.phone_required? }
+        validates :email, presence: true, if: ->(form) { form.setting&.email_required? }
+        validate :setting_exists
+        validate :user_in_census
+
+        alias user current_user
+
+        def handler_name
+          "delegations_verifier"
+        end
+
+        def unique_id
+          Digest::MD5.hexdigest(
+            "#{setting&.phone_required? ? phone : email}-#{setting&.organization&.id}-#{Digest::MD5.hexdigest(Rails.application.secrets.secret_key_base)}"
+          )
+        end
+
+        # email is predefined always
+        delegate :email, to: :current_user
+
+        # When there's a phone number, sanitize it allowing only numbers and +.
+        def phone
+          return find_phone if setting&.verify_with_both?
+          return unless super
+
+          super.gsub(/[^+0-9]/, "")
+        end
+
+        def metadata
+          {
+            phone: phone
+          }
+        end
+
+        # The verification metadata to validate in the next step.
+        def verification_metadata
+          {
+            verification_code: verification_code,
+            code_sent_at: Time.current
+          }
+        end
+
+        # currently, we rely on the last setting.
+        # This could be improved by allowing the user to select the setting (or related phone).
+        def setting
+          @setting ||= context[:setting]
+        end
+
+        def participants
+          @participants ||= Decidim::ActionDelegator::Participant.where(setting: setting)
+        end
+
+        def participant
+          return unless setting
+
+          @participant ||= begin
+            params = {}
+            params[:email] = email if setting.email_required?
+            if setting.phone_required?
+              return setting.participants.none if phone.blank?
+
+              params[:phone] = phone
+              params[:phone] = phone_prefixes.map { |prefix| "#{prefix}#{phone}" }
+              params[:phone] += phone_prefixes.map { |prefix| phone.delete_prefix(prefix).to_s }
+            end
+
+            setting.participants.find_by(params)
+          end
+        end
+
+        private
+
+        def phone_prefixes
+          return [] unless ActionDelegator.phone_prefixes.respond_to?(:map)
+
+          ActionDelegator.phone_prefixes
+        end
+
+        def user_in_census
+          return if errors.any?
+          return if participant
+
+          errors.add(:phone, :phone_not_found) if setting.phone_required?
+          errors.add(:email, :email_not_found) if setting.email_required?
+        end
+
+        def setting_exists
+          return if errors.any?
+          return if setting
+
+          errors.add(:phone, :invalid)
+          errors.add(:email, :invalid)
+        end
+
+        def verification_code
+          return unless sms_gateway
+          return @verification_code if defined?(@verification_code)
+
+          return unless sms_gateway.new(phone, generated_code).deliver_code
+
+          @verification_code = generated_code
+        end
+
+        def sms_gateway
+          (Decidim.sms_gateway_service || ActionDelegator.sms_gateway_service).to_s.safe_constantize
+        end
+
+        def generated_code
+          @generated_code ||= SecureRandom.random_number(1_000_000).to_s
+        end
+
+        def find_phone
+          @find_phone ||= setting.participants.find_by(email: email)&.phone
+        end
+      end
+    end
+  end
+end

data/app/helpers/decidim/action_delegator/admin/delegation_helper.rb

@@ -13,14 +13,51 @@ module Decidim
         end
 
         def consultations_for_select
-          organization_consultations.map do |consultation|
-            ConsultationPresenter.new(consultation)
-          end
+          organization_consultations.map { |consultation| [translated_attribute(consultation.title), consultation.id] }
+        end
+
+        def ponderations_for_select(setting)
+          setting.ponderations.map { |ponderation| [ponderation.title, ponderation.id] }
         end
 
         def organization_consultations
           Decidim::Consultations::OrganizationConsultations.new(current_organization).query
         end
+
+        def missing_verifications_for(resources, action)
+          resources.where.not(id: Decidim::ResourcePermission.select(:resource_id)
+            .where(resource: resources)
+            .where(Arel.sql("permissions->'#{action}'->'authorization_handlers'->>'delegations_verifier' IS NOT NULL")))
+        end
+
+        def missing_decidim_users(participants)
+          participants.where(decidim_user: nil).or(Participant.where.not(decidim_user: current_organization.users)).where.not(id: missing_registered_users(participants))
+        end
+
+        def missing_registered_users(participants)
+          participants.where.not(email: current_organization.users.select(:email))
+                      .where.not("MD5(CONCAT(phone,'-',?,'-',?)) IN (?)",
+                                 current_organization.id,
+                                 Digest::MD5.hexdigest(Rails.application.secret_key_base),
+                                 Authorization.select(:unique_id).where.not(unique_id: nil))
+        end
+
+        def participants_uniq_ids(participants)
+          phones = Participant.phone_combinations(participants.pluck(:phone))
+          Participant.verifier_ids(Participant.phone_combinations(phones.map { |phone| "#{phone}-#{current_organization.id}" }))
+        end
+
+        def existing_authorizations(participants)
+          uniq_ids = participants_uniq_ids(participants)
+          user_ids = current_organization.users.select(:id).where(email: participants.select(:email))
+          Decidim::Authorization.select(:decidim_user_id).where(unique_id: uniq_ids).or(
+            Decidim::Authorization.select(:decidim_user_id).where(decidim_user_id: user_ids)
+          )
+        end
+
+        def total_missing_authorizations(participants)
+          participants.count - existing_authorizations(participants).count
+        end
       end
     end
   end

data/app/helpers/decidim/action_delegator/delegation_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    module DelegationHelper
+      def has_any_delegate_vote?(question)
+        Decidim::ActionDelegator::GranteeDelegations.for(question.consultation, current_user).detect do |delegation|
+          question.voted_by?(delegation.granter)
+        end
+      end
+    end
+  end
+end

data/app/jobs/decidim/action_delegator/admin/import_csv_job.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    module Admin
+      class ImportCsvJob < ApplicationJob
+        queue_as :exports
+
+        def perform(importer_type, csv_file, current_user, current_setting)
+          importer = if importer_type == "DelegationsCsvImporter"
+                       Decidim::ActionDelegator::DelegationsCsvImporter.new(csv_file, current_user, current_setting)
+                     else
+                       Decidim::ActionDelegator::ParticipantsCsvImporter.new(csv_file, current_user, current_setting)
+                     end
+
+          import_summary = importer.import!
+
+          Decidim::ActionDelegator::ImportMailer
+            .import(current_user, import_summary, import_summary[:details_csv_path])
+            .deliver_later
+
+          import_summary
+        end
+      end
+    end
+  end
+end

data/app/jobs/decidim/action_delegator/admin/invite_participants_job.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    module Admin
+      class InviteParticipantsJob < ApplicationJob
+        queue_as :invite_participants
+
+        def perform(current_setting, organization)
+          @current_setting = current_setting
+          @organization = organization
+
+          users_list_to_invite.find_each do |participant|
+            form = InvitationParticipantForm.new(
+              name: participant.email.split("@").first&.gsub(/\W/, ""),
+              email: participant.email.downcase,
+              organization: organization,
+              admin: false
+            )
+
+            Decidim::InviteUser.call(form)
+          end
+        end
+
+        private
+
+        def users_list_to_invite
+          @users_list_to_invite ||= @current_setting.participants.where(decidim_user: nil)
+                                                    .where.not(email: @organization.users.select(:email))
+                                                    .where.not("MD5(CONCAT(phone,'-',?,'-',?)) IN (?)",
+                                                               @organization.id,
+                                                               Digest::MD5.hexdigest(Rails.application.secret_key_base),
+                                                               Authorization.select(:unique_id)
+                                                                            .where.not(unique_id: nil))
+        end
+      end
+    end
+  end
+end

data/app/jobs/decidim/action_delegator/sync_participants_job.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class SyncParticipantsJob < ApplicationJob
+      queue_as :default
+
+      def perform(setting)
+        @setting = setting
+
+        return unless setting&.participants
+
+        setting.participants.each do |participant|
+          next if participant.decidim_user.present?
+          next if participant.user_from_metadata.blank?
+
+          participant.decidim_user = participant.user_from_metadata
+          participant.save
+        end
+      end
+
+      private
+
+      attr_reader :setting
+    end
+  end
+end

data/app/mailers/decidim/action_delegator/import_mailer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    # This mailer sends a notification email containing the result of importing a
+    # CSV of results.
+    class ImportMailer < Decidim::ApplicationMailer
+      # Public: Sends a notification email with the result of a CSV import
+      # of results.
+      #
+      # user   - The user to be notified.
+      # errors - The list of errors generated by the import
+      #
+      # Returns nothing.
+      def import(user, import_summary, csv_file_path)
+        @user = user
+        @organization = user.organization
+        @import_summary = import_summary
+        @csv_file_path = csv_file_path
+
+        @csv_file_path = "" if @import_summary[:total_rows] == @import_summary[:imported_rows]
+
+        attachments["details.csv"] = File.read(@csv_file_path) if @csv_file_path.present? && File.exist?(@csv_file_path)
+
+        with_user(user) do
+          mail(to: "#{user.name} <#{user.email}>", subject: I18n.t("decidim.action_delegator.import_mailer.import.subject"))
+        end
+      end
+    end
+  end
+end

data/app/models/decidim/action_delegator/delegation.rb

@@ -18,9 +18,20 @@ module Decidim
 
       delegate :consultation, to: :setting
 
+      before_destroy { |record| throw(:abort) if record.grantee_voted? }
+
       def self.granted_to?(user, consultation)
         GranteeDelegations.for(consultation, user).exists?
       end
+
+      def grantee_voted?
+        return false unless consultation.questions.any?
+
+        @grantee_voted ||= begin
+          granter_votes = Decidim::Consultations::Vote.where(author: granter, question: consultation.questions)
+          granter_votes&.detect { |vote| vote.versions.exists?(whodunnit: grantee&.id) } ? true : false
+        end
+      end
     end
   end
 end