decidim-action_delegator 0.8.2 → 0.9.0

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

@@ -5,15 +5,23 @@ require "securerandom"
 module Decidim
   module ActionDelegator
     module Verifications
-      # A form object to be used when public users want to get verified using their phone.
+      # This verifier checks if there is some setting in which the participant is required
+      # to verify it's phone (the first active setting will be used for that).
+      # If no setting requires phone verification, it will check if there is some setting
+      # in which the participant is required to verify it's email.
+      # If no setting requires email verification, the user won't be able to proceed.
+      # If there are multiple active settings, the user will be verified for the first one
+      #
+      # Note that the ActionAuthorizer associated with this handler will check the current status
+      # of the settings and delegations regardless of this verification metadata
       class DelegationsVerifierForm < AuthorizationHandler
         attribute :email, String
         attribute :phone, String
 
-        validates :verification_code, :sms_gateway, presence: true
+        validates :verification_code, :sms_gateway, presence: true, if: ->(form) { form.setting&.phone_required? }
         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
@@ -24,7 +32,7 @@ module Decidim
 
         def unique_id
           Digest::MD5.hexdigest(
-            "#{setting&.phone_required? ? phone : email}-#{setting&.organization&.id}-#{Digest::MD5.hexdigest(Rails.application.secrets.secret_key_base)}"
+            "#{setting&.phone_required? ? phone : email}-#{setting&.organization&.id}-#{Digest::MD5.hexdigest(Rails.application.secret_key_base)}"
           )
         end
 
@@ -41,10 +49,17 @@ module Decidim
 
         def metadata
           {
-            phone: phone
+            phone:,
+            setting_ids:
           }
         end
 
+        def setting_ids
+          return [] unless current_user
+
+          valid_participants&.map(&:decidim_action_delegator_setting_id)&.uniq || []
+        end
+
         # The verification metadata to validate in the next step.
         def verification_metadata
           {
@@ -55,34 +70,43 @@ module Decidim
 
         # 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]
+        def active_settings
+          @active_settings ||= context[:active_settings]
         end
 
-        def participants
-          @participants ||= Decidim::ActionDelegator::Participant.where(setting: setting)
+        # find the participant in any of the active settings
+        # If phone is required, just find the first participant and validate the phone
+        # if not, find by email in any of the active settings
+        def participant
+          valid_participants&.first
         end
 
-        def participant
-          return unless setting
+        def valid_participants
+          return [] unless setting
 
-          @participant ||= begin
+          @valid_participants ||= begin
             params = {}
             params[:email] = email if setting.email_required?
             if setting.phone_required?
               if phone.blank?
-                @participant = setting.participants.none
+                @valid_participants = setting.participants.none
               else
-                params[:phone] = phone
                 params[:phone] = phone_prefixes.map { |prefix| "#{prefix}#{phone}" }
                 params[:phone] += phone_prefixes.map { |prefix| phone.delete_prefix(prefix).to_s }
               end
             end
 
-            setting.participants.find_by(params)
+            setting.participants.where(params)
           end
         end
 
+        # find the first setting where phone is required or, if not, the first setting where email is required
+        # This works because the email is unique per user so it does not matter which setting we use to find the participant
+        # If the setting requires phone, only one active setting with phone verification is allowed to exist at a time
+        def setting
+          @setting ||= active_settings&.phone_required&.first || active_settings&.email_required&.first
+        end
+
         private
 
         def phone_prefixes
@@ -95,16 +119,8 @@ module Decidim
           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)
+          errors.add(:phone, :phone_not_found) if setting&.phone_required?
+          errors.add(:email, :email_not_found) if setting&.email_required?
         end
 
         def verification_code

data/app/helpers/decidim/action_delegator/admin/{delegation_helper.rb → settings_helper.rb}

@@ -3,7 +3,7 @@
 module Decidim
   module ActionDelegator
     module Admin
-      module DelegationHelper
+      module SettingsHelper
         def granters_for_select
           current_organization.users
         end
@@ -12,31 +12,18 @@ module Decidim
           current_organization.users
         end
 
-        def consultations_for_select
-          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(participants.where.not(decidim_user: current_organization.users)).where.not(id: missing_registered_users(participants))
         end
 
+        # TODO: need to check
         def missing_registered_users(participants)
           participants.where.not(email: current_organization.users.select(:email))
-                      .where.not("MD5(CONCAT(phone,'-',?,'-',?)) IN (?)",
+                      .where.not("MD5(CONCAT(phone, '-', CAST(? AS text), '-', CAST(? AS text))) IN (?)",
                                  current_organization.id,
                                  Digest::MD5.hexdigest(Rails.application.secret_key_base),
                                  Authorization.select(:unique_id).where.not(unique_id: nil))

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    module SettingsHelper
+      include ActionView::Helpers::NumberHelper
+
+      def current_resource_settings
+        @current_resource_settings ||= if defined?(election) && election.present?
+                                         settings_for(election)
+                                       elsif @election.present?
+                                         settings_for(@election)
+                                       else
+                                         Decidim::ActionDelegator::Setting.none
+                                       end
+      end
+
+      def settings_for(resource)
+        case resource
+        when Decidim::Elections::Election
+          Decidim::ActionDelegator::ElectionSettings.new(resource).query
+        else
+          Decidim::ActionDelegator::Setting.none
+        end
+      end
+
+      def delegations_for(resource, user)
+        case resource
+        when Decidim::Elections::Election
+          Decidim::ActionDelegator::Delegation.where(
+            setting: settings_for(resource),
+            grantee: user
+          )
+        else
+          Decidim::ActionDelegator::Delegation.none
+        end
+      end
+
+      def participant_voted?(resource, user)
+        case resource
+        when Decidim::Elections::Election
+          resource.votes.exists?(voter_uid: user.to_global_id.to_s)
+        else
+          false
+        end
+      end
+
+      def elections_question_responses_by_type(question)
+        # Use size instead of count since votes are preloaded
+        total_votes = question.votes.size
+
+        ElectionsQuestionResponsesByType.new(question, current_resource_settings).query.map do |option|
+          ponderation ||= Decidim::ActionDelegator::Ponderation.find_by(id: option.ponderation_id)
+          votes_count = option.votes_total || 0
+          votes_count_text = I18n.t("votes_count", scope: "decidim.elections.admin.dashboard.questions_table", count: votes_count)
+          votes_percent = total_votes.positive? ? (option.votes_total.to_f / total_votes) * 100 : 0
+          {
+            id: option.id,
+            body: translated_attribute(option.body),
+            votes_count: votes_count,
+            votes_count_text: votes_count_text,
+            votes_percent: votes_percent,
+            votes_percent_text: number_to_percentage(votes_percent, precision: 1),
+            ponderation_id: ponderation&.id,
+            ponderation_title: ponderation&.title || "-"
+          }
+        end
+      end
+
+      def elections_question_weighted_responses(question)
+        # Use size instead of count since votes are preloaded
+        total_votes = question.votes.size
+
+        question_totals = {}
+        responses = ElectionsQuestionWeightedResponses.new(question, current_resource_settings).query.map do |option|
+          question_totals[question.id] ||= 0.0
+          question_totals[question.id] += option.weighted_votes_total.to_f
+          option
+        end
+
+        responses.map do |option|
+          votes_count = option.weighted_votes_total || 0
+          votes_percent = total_votes.positive? ? (option.weighted_votes_total.to_f / question_totals[question.id]) * 100 : 0
+          {
+            id: option.id,
+            question_id: question.id,
+            body: translated_attribute(option.body),
+            votes_count: votes_count,
+            votes_count_text: I18n.t("votes_count", scope: "decidim.elections.admin.dashboard.questions_table", count: votes_count),
+            votes_percent: votes_percent,
+            votes_percent_text: number_to_percentage(votes_percent, precision: 1)
+          }
+        end
+      end
+
+      def elections_question_stats(question)
+        question_totals = {}
+        ElectionsQuestionWeightedResponses.new(question, current_resource_settings).query.each do |option|
+          question_totals[question.id] ||= 0.0
+          question_totals[question.id] += option.weighted_votes_total.to_f
+        end
+
+        # Use preloaded votes association
+        votes = question.votes
+        unweighted_votes = votes.size
+        weighted_votes = question_totals[question.id].to_f.round
+        # Note that this works because votes cannot be edited, only created or destroyed. So only one version will exist per vote (the creation event)
+        delegated_votes = votes.select { |vote| vote.versions.any? { |v| v.decidim_action_delegator_delegation_id.present? } }.size
+        participants = votes.map(&:voter_uid).uniq.size
+
+        {
+          participants: participants,
+          participants_text: I18n.t("participants_count", scope: "decidim.action_delegator.elections.admin.dashboard.questions_table", count: participants),
+          unweighted_votes: unweighted_votes,
+          unweighted_votes_text: I18n.t("votes_count", scope: "decidim.elections.admin.dashboard.questions_table", count: unweighted_votes),
+          weighted_votes: weighted_votes,
+          weighted_votes_text: I18n.t("votes_count", scope: "decidim.elections.admin.dashboard.questions_table", count: weighted_votes),
+          delegated_votes: delegated_votes,
+          delegated_votes_text: I18n.t("votes_count", scope: "decidim.elections.admin.dashboard.questions_table", count: delegated_votes)
+        }
+      end
+    end
+  end
+end

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

@@ -27,7 +27,7 @@ module Decidim
         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 (?)",
+                                                    .where.not("MD5(CONCAT(phone::text, '-', CAST(? AS text), '-', CAST(? AS text))) IN (?)",
                                                                @organization.id,
                                                                Digest::MD5.hexdigest(Rails.application.secret_key_base),
                                                                Authorization.select(:unique_id)

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

@@ -28,8 +28,8 @@ module Decidim
       def send_sms!
         @response = client.call(:send_sms,
                                 message: {
-                                  user: ENV["SMS_USER"],
-                                  pass: ENV["SMS_PASS"],
+                                  user: ENV.fetch("SMS_USER", nil),
+                                  pass: ENV.fetch("SMS_PASS", nil),
                                   src: sender,
                                   dst: mobile_phone_number,
                                   msg: message

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

@@ -32,11 +32,11 @@ module Decidim
       end
 
       def twilio_account_sid
-        ENV["TWILIO_ACCOUNT_SID"]
+        ENV.fetch("TWILIO_ACCOUNT_SID", nil)
       end
 
       def twilio_auth_token
-        ENV["TWILIO_AUTH_TOKEN"]
+        ENV.fetch("TWILIO_AUTH_TOKEN", nil)
       end
     end
   end

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

@@ -18,23 +18,25 @@ module Decidim
 
       validate :grantee_is_not_granter
       validate :granter_and_grantee_belongs_to_same_organization
-      validate :granter_is_same_organization_as_consultation
+      validate :granter_is_same_organization_as_context
 
-      delegate :consultation, to: :setting
+      delegate :resource, 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?
+        return false unless grantee && setting
+
+        @grantee_voted ||= PaperTrail::Version.exists?(
+          whodunnit: grantee.id,
+          object_changes: { decidim_action_delegator_delegation_id: id }
+        )
+      end
 
-        @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
+      # a safe way to get the user that represents the granter in this setting
+      # it might not exist if the granter is not in the census
+      def user
+        @user ||= setting.participants.find_by(decidim_user: granter)&.decidim_user
       end
 
       private
@@ -51,9 +53,8 @@ module Decidim
         errors.add(:grantee, :invalid)
       end
 
-      def granter_is_same_organization_as_consultation
-        return unless setting && setting.consultation
-        return unless consultation.organization != granter.organization
+      def granter_is_same_organization_as_context
+        return unless setting && granter.organization != setting.organization
 
         errors.add(:granter, :invalid)
       end

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

@@ -18,7 +18,6 @@ module Decidim
                  class_name: "Decidim::User",
                  optional: true
 
-      delegate :consultation, to: :setting
       delegate :organization, to: :setting
 
       validates :decidim_user, uniqueness: { scope: :setting }, if: -> { decidim_user.present? }
@@ -50,7 +49,7 @@ module Decidim
       end
 
       def self.verifier_ids(seeds)
-        seeds.map { |seed| Digest::MD5.hexdigest("#{seed}-#{Digest::MD5.hexdigest(Rails.application.secrets.secret_key_base)}") }
+        seeds.map { |seed| Digest::MD5.hexdigest("#{seed}-#{Digest::MD5.hexdigest(Rails.application.secret_key_base)}") }
       end
 
       def self.phone_combinations(phones)
@@ -82,15 +81,12 @@ module Decidim
         ponderation&.title
       end
 
-      # checks if the user has voted in the setting's consultation
+      # checks if the user has voted
       def voted?
         return false if user.blank?
 
-        @voted ||= Decidim::Consultations::Vote
-                   .joins(question: :consultation)
-                   .where(decidim_consultations_questions: {
-                            decidim_consultation_id: setting.consultation.id
-                          }, author: user).any?
+        # TODO: Replace vote check once new context is defined
+        false
       end
 
       private
@@ -100,8 +96,9 @@ module Decidim
       end
 
       def user_belongs_to_organization
-        return unless decidim_user && setting && setting.consultation
-        return if decidim_user.organization == organization
+        return if decidim_user.blank? || setting.blank?
+
+        return if decidim_user.organization == setting.organization
 
         errors.add(:decidim_user, :invalid)
       end

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

@@ -14,8 +14,6 @@ module Decidim
                class_name: "Decidim::ActionDelegator::Participant",
                dependent: :restrict_with_error
 
-      delegate :consultation, to: :setting
-
       def title
         @title ||= "#{name} (x#{weight})"
       end

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

@@ -2,14 +2,14 @@
 
 module Decidim
   module ActionDelegator
-    # Contains the delegation settings of a consultation. Rather than a single attribute here
+    # Contains the delegation settings of an election. Rather than a single attribute here
     # a setting is the record itself: a bunch of configuration values.
     class Setting < ApplicationRecord
       self.table_name = "decidim_action_delegator_settings"
 
-      belongs_to :consultation,
-                 foreign_key: "decidim_consultation_id",
-                 class_name: "Decidim::Consultation"
+      belongs_to :organization,
+                 foreign_key: "decidim_organization_id",
+                 class_name: "Decidim::Organization"
       has_many :delegations,
                inverse_of: :setting,
                foreign_key: "decidim_action_delegator_setting_id",
@@ -28,43 +28,25 @@ module Decidim
 
       validates :max_grants, presence: true
       validates :max_grants, numericality: { greater_than: 0 }
-      validates :consultation, uniqueness: true
 
-      enum authorization_method: { phone: 0, email: 1, both: 2 }, _prefix: :verify_with
+      enum :authorization_method, [:phone, :email, :both], prefix: :verify_with
 
-      delegate :title, to: :consultation
-      delegate :organization, to: :consultation
+      scope :active, -> { where(active: true) }
+      scope :phone_required, -> { where(authorization_method: [:phone, :both]) }
+      scope :email_required, -> { where(authorization_method: [:email, :both]) }
 
       default_scope { order(created_at: :desc) }
 
-      def state
-        @state ||= if consultation.end_voting_date < Time.zone.now
-                     :closed
-                   elsif consultation.start_voting_date <= Time.zone.now
-                     :ongoing
-                   else
-                     :pending
-                   end
-      end
-
-      def ongoing?
-        state == :ongoing
-      end
+      def editable? = active?
 
-      def editable?
-        state != :closed
-      end
+      def destroyable? = participants.empty? && ponderations.empty? && delegations.empty?
 
-      def destroyable?
-        participants.empty? && ponderations.empty? && delegations.empty?
-      end
+      def phone_required? = verify_with_phone? || verify_with_both?
 
-      def phone_required?
-        verify_with_phone? || verify_with_both?
-      end
+      def email_required? = verify_with_email? || verify_with_both?
 
-      def email_required?
-        verify_with_email? || verify_with_both?
+      def presenter
+        Decidim::ActionDelegator::SettingPresenter.new(self)
       end
     end
   end

data/app/overrides/decidim/elections/admin/dashboard/_results/_add_results_contents.html.erb.deface

@@ -0,0 +1,10 @@
+<!-- replace "erb[loud]:contains('decidim/elections/admin/dashboard/questions_with_results')" -->
+
+<%= render "decidim/action_delegator/elections/admin/dashboard/results_type_info" if current_resource_settings.present? %>
+
+<% if current_resource_settings.present? && lookup_context.exists?("decidim/action_delegator/elections/admin/dashboard/#{params[:results]}", [], true) %>
+  <%= render "decidim/action_delegator/elections/admin/dashboard/#{params[:results]}" %>
+  <% append_javascript_pack_tag("decidim_action_delegator_elections") %>
+<% else %>
+  <%= render "decidim/elections/admin/dashboard/questions_with_results" %>
+<% end %>

data/app/overrides/decidim/elections/admin/dashboard/_results/_add_results_tabs.html.erb.deface

@@ -0,0 +1,3 @@
+<!-- insert_top ".row.column" -->
+
+<%= render "decidim/action_delegator/elections/admin/dashboard/results_tabs" if settings_for(election).present? %>

data/app/overrides/decidim/elections/elections/_election_aside/add_delegation_buttons.html.erb.deface

@@ -0,0 +1,3 @@
+<!-- insert_bottom ".election__aside-vote" -->
+
+<%= render "decidim/action_delegator/elections/delegation_buttons" if election.ongoing? %>

data/app/overrides/decidim/elections/elections/_vote_results/replace_results_div.html.erb.deface

@@ -0,0 +1,8 @@
+<!-- surround "div[data-erb-data-results-live-update]" -->
+
+<% if current_resource_settings.present? %>
+  <%= render "decidim/action_delegator/elections/vote_results", questions: %>
+  <% append_javascript_pack_tag("decidim_action_delegator_elections") %>
+<% else %>
+  <%= render_original %>
+<% end %>

data/app/overrides/decidim/elections/per_question_votes/show/add_delegation_hidden_input.html.erb.deface

@@ -0,0 +1,3 @@
+<!-- insert_after "erb[loud]:contains('question_title')" -->
+
+<input type="hidden" name="delegation" value="<%= @delegation&.id %>">

data/app/overrides/decidim/elections/per_question_votes/show/add_delegation_id_to_links.html.erb.deface

@@ -0,0 +1,3 @@
+<!-- replace "erb[loud]:contains('link_to url_for(action: :show, id: question.previous_question)')" -->
+
+<%= link_to url_for(action: :show, id: question.previous_question, delegation: @delegation&.id), class: "button button__lg button__transparent-secondary" do %>

data/app/overrides/decidim/elections/per_question_votes/waiting/add_delegation_buttons.html.erb.deface

@@ -0,0 +1,3 @@
+<!-- insert_after ".vote-navigation" -->
+
+<%= render "decidim/action_delegator/elections/per_question_waiting_buttons" %>

data/app/overrides/decidim/elections/votes/receipt/add_delegation_buttons.html.erb.deface

@@ -0,0 +1,3 @@
+<!-- insert_bottom ".vote-submitted" -->
+
+<%= render "decidim/action_delegator/elections/per_question_waiting_buttons" if election.per_question? %>

data/app/packs/entrypoints/decidim_action_delegator_elections.js

@@ -0,0 +1 @@
+import "src/decidim/action_delegator/elections_live_results.js";