decidim-action_delegator 0.4

data/app/permissions/decidim/action_delegator/permissions.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class Permissions < Decidim::DefaultPermissions
+      SUBJECTS_WHITELIST = [:delegation, :setting, :consultation].freeze
+
+      def permissions
+        allowed_delegation_action?
+
+        return permission_action unless user.admin?
+        return permission_action unless permission_action.scope == :admin
+        return permission_action unless action_delegator_subject?
+
+        allow! if can_perform_action?
+
+        permission_action
+      end
+
+      private
+
+      def allowed_delegation_action?
+        return unless delegation
+        # Check that the required question verifications are fulfilled
+        return unless authorized?(:vote, delegation.grantee)
+
+        case permission_action.action
+        when :vote_delegation
+          toggle_allow(question.can_be_voted_by?(delegation.granter) && delegation.grantee == user)
+        when :unvote_delegation
+          toggle_allow(question.can_be_unvoted_by?(delegation.granter) && delegation.grantee == user)
+        end
+      end
+
+      def authorized?(permission_action, user, resource: nil)
+        return unless resource || question
+
+        ActionAuthorizer.new(user, permission_action, question, resource).authorize.ok?
+      end
+
+      def question
+        @question ||= context.fetch(:question, nil)
+      end
+
+      def delegation
+        @delegation ||= context.fetch(:delegation, nil)
+      end
+
+      def consultation_results_exports_action?
+        permission_action.subject == :consultation && permission_action.action == :export_results
+      end
+
+      def consultation
+        @consultation ||= context.fetch(:consultation)
+      end
+
+      def action_delegator_subject?
+        SUBJECTS_WHITELIST.include?(permission_action.subject)
+      end
+
+      def can_perform_action?
+        if permission_action.action == :destroy
+          resource.present?
+        else
+          true
+        end
+      end
+
+      def resource
+        @resource ||= context.fetch(:resource, nil)
+      end
+    end
+  end
+end

data/app/presenters/decidim/action_delegator/admin/consultation_presenter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    module Admin
+      class ConsultationPresenter < SimpleDelegator
+        include Decidim::TranslationsHelper
+
+        def translated_title
+          @translated_title ||= translated_attribute(title)
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/action_delegator/admin/setting_presenter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    module Admin
+      class SettingPresenter < SimpleDelegator
+        def consultation
+          Admin::ConsultationPresenter.new(__getobj__.consultation)
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/action_delegator/question_with_totals.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class QuestionWithTotals < SimpleDelegator
+      def initialize(question, questions_by_id)
+        super(question)
+        @questions_by_id = questions_by_id
+      end
+
+      def total_delegates
+        questions_by_id[id].total_delegates
+      end
+
+      def total_participants
+        questions_by_id[id].total_participants
+      end
+
+      private
+
+      attr_reader :questions_by_id
+    end
+  end
+end

data/app/queries/decidim/action_delegator/consultation_delegations.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class ConsultationDelegations < Rectify::Query
+      def self.for(consultation)
+        new(consultation).query
+      end
+
+      def initialize(consultation)
+        @consultation = consultation
+      end
+
+      def query
+        Delegation
+          .joins(setting: :consultation)
+          .where(decidim_consultations: { id: consultation.id })
+      end
+
+      private
+
+      attr_reader :consultation
+    end
+  end
+end

data/app/queries/decidim/action_delegator/decrypted_authorizations.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "json_key"
+
+module Decidim
+  module ActionDelegator
+    class DecryptedAuthorizations < Rectify::Query
+      METADATA_FIELDS = %w(
+        membership_type
+        membership_weight
+      ).freeze
+
+      def initialize(relation)
+        @relation = relation
+      end
+
+      def query
+        authorizations
+          .project(
+            authorizations[:id],
+            authorizations[:name],
+            authorizations[:decidim_user_id],
+            *decrypted_authorizations_metadata_fields
+          )
+          .where(authorizations[:id].in(authorization_ids))
+      end
+
+      private
+
+      attr_reader :relation
+
+      def authorizations
+        Decidim::Authorization.arel_table
+      end
+
+      def decrypted_authorizations_metadata_fields
+        METADATA_FIELDS.map do |field|
+          decrypted_authorizations_metadata_field(field)
+        end
+      end
+
+      def decrypted_authorizations_metadata_field(field)
+        JsonBuildObjectQuery.new(
+          metadata_field_by_authorization_id(field).flatten,
+          authorizations[:id],
+          field
+        ).to_sql
+      end
+
+      def metadata_field_by_authorization_id(field)
+        decrypted_authorizations.map do |hash|
+          [
+            hash.fetch("id"),
+            hash.fetch(field)
+          ]
+        end
+      end
+
+      def decrypted_authorizations
+        @decrypted_authorizations ||=
+          sql_query_results(encrypted_authorizations).map do |hash|
+            hash.transform_values! do |value|
+              if value.nil?
+                Arel.sql("NULL")
+              else
+                value.is_a?(String) ? decrypt_and_parse(value) : value
+              end
+            end
+          end
+      end
+
+      def sql_query_results(sql)
+        ActiveRecord::Base.connection.exec_query(sql).to_a
+      end
+
+      def encrypted_authorizations
+        Decidim::Authorization
+          .select(
+            :id,
+            *authorizations_metadata_fields
+          )
+          .where(id: authorization_ids)
+          .to_sql
+      end
+
+      def authorizations_metadata_fields
+        METADATA_FIELDS.map do |field|
+          authorizations_metadata_field(field).as(field)
+        end
+      end
+
+      def authorizations_metadata_field(field)
+        JSONKey.new(authorizations[:metadata], field)
+      end
+
+      def authorization_ids
+        @authorization_ids ||= relation.pluck("decidim_authorizations.id").compact
+      end
+
+      def decrypt_and_parse(value)
+        Arel.sql("'#{JSON.parse(decrypt_value(value))}'")
+      end
+
+      def decrypt_value(value)
+        Decidim::AttributeEncryptor.decrypt(value)
+      rescue ActiveSupport::MessageEncryptor::InvalidMessage, ActiveSupport::MessageVerifier::InvalidSignature
+        # Support for legacy unencrypted values.
+        value
+      end
+    end
+  end
+end

data/app/queries/decidim/action_delegator/delegated_votes_versions.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    # Returns all PaperTrail versions of a consultation's delegated votes for auditing purposes.
+    # It is intended to be used to easily fetch this data when a judge ask us so.
+    class DelegatedVotesVersions
+      def initialize(consultation)
+        @consultation = consultation
+      end
+
+      def query
+        statement = <<-SQL.squish
+          SELECT *
+          FROM versions
+          INNER JOIN decidim_action_delegator_delegations
+            ON decidim_action_delegator_delegations.id = versions.decidim_action_delegator_delegation_id
+          INNER JOIN decidim_action_delegator_settings
+            ON decidim_action_delegator_settings.id = decidim_action_delegator_delegations.decidim_action_delegator_setting_id
+          WHERE decidim_action_delegator_settings.decidim_consultation_id = #{consultation.id}
+        SQL
+
+        ActiveRecord::Base.connection.execute(statement).to_a
+      end
+
+      private
+
+      attr_reader :consultation
+    end
+  end
+end

data/app/queries/decidim/action_delegator/delegates_votes_by_consultation.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class DelegatesVotesByConsultation < Rectify::Query
+      def initialize(consultation, relation = DelegationVotes)
+        @consultation = consultation
+        @relation = relation
+      end
+
+      def query
+        relation.new.query.merge(consultation_delegations).count
+      end
+
+      private
+
+      attr_reader :consultation, :relation
+
+      def consultation_delegations
+        ConsultationDelegations.for(consultation)
+      end
+    end
+  end
+end

data/app/queries/decidim/action_delegator/delegates_votes_by_question.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class DelegatesVotesByQuestion < Rectify::Query
+      def initialize(question)
+        @question = question
+      end
+
+      def query
+        DelegationVotes.new.query
+                       .merge(question.votes)
+                       .merge(consultation_delegations)
+                       .distinct.count(:granter_id)
+      end
+
+      private
+
+      attr_reader :question
+
+      def consultation_delegations
+        ConsultationDelegations.for(question.consultation)
+      end
+    end
+  end
+end

data/app/queries/decidim/action_delegator/delegation_votes.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    # This query object replaces the ActiveRecord association we would have between the Vote and
+    # Delegation models. Unfortunately we can't use custom foreign keys on both ends of the
+    # association so this aims to replace `delegation.votes`.
+    class DelegationVotes < Rectify::Query
+      def query
+        Delegation.joins(
+          delegations.join(votes).on(vote_author_eq_granter).join_sources
+        )
+      end
+
+      private
+
+      def votes
+        Decidim::Consultations::Vote.arel_table
+      end
+
+      def delegations
+        Delegation.arel_table
+      end
+
+      def vote_author_eq_granter
+        votes[:decidim_author_id].eq(delegations[:granter_id])
+      end
+    end
+  end
+end

data/app/queries/decidim/action_delegator/grantee_delegations.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class GranteeDelegations
+      def self.for(consultation, user)
+        new(consultation, user).query
+      end
+
+      def initialize(consultation, user)
+        @consultation = consultation
+        @user = user
+      end
+
+      def query
+        ConsultationDelegations.for(consultation).where(grantee_id: user.id)
+      end
+
+      private
+
+      attr_reader :consultation, :user
+    end
+  end
+end

data/app/queries/decidim/action_delegator/json_build_object_query.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class JsonBuildObjectQuery
+      def initialize(json_args, query_field, aliaz)
+        @json_args = json_args
+        @query_field = query_field
+        @aliaz = aliaz
+      end
+
+      def to_sql
+        Arel::Nodes::InfixOperation.new(
+          "->>",
+          json_build_object(json_args),
+          cast(query_field, :text)
+        ).as(aliaz).to_sql
+      end
+
+      private
+
+      attr_reader :json_args, :query_field, :aliaz
+
+      # Returns the equivalent of `JSON_BUILD_OBJECT (ARRAY)` in Arel
+      def json_build_object(array)
+        Arel::Nodes::NamedFunction.new(
+          "JSON_BUILD_OBJECT",
+          [array]
+        )
+      end
+
+      # Returns the equivalent of `CAST ((<exprs>) AS <type>)` in Arel
+      def cast(*exprs, type)
+        Arel::Nodes::NamedFunction.new(
+          "CAST",
+          [Arel::Nodes::As.new(Arel::Nodes::Grouping.new(exprs), Arel.sql(type.to_s.upcase))]
+        )
+      end
+
+      def coalesce(*exprs)
+        Arel::Nodes::NamedFunction.new("COALESCE", exprs)
+      end
+    end
+  end
+end

data/app/queries/decidim/action_delegator/organization_delegations.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class OrganizationDelegations < Rectify::Query
+      def initialize(organization)
+        @organization = organization
+      end
+
+      def query
+        Delegation
+          .joins(setting: :consultation)
+          .merge(organization_consultations)
+          .includes(:grantee, :granter)
+      end
+
+      private
+
+      attr_reader :organization
+
+      def organization_consultations
+        Decidim::Consultations::OrganizationConsultations.new(organization).query
+      end
+    end
+  end
+end

data/app/queries/decidim/action_delegator/organization_settings.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class OrganizationSettings < Rectify::Query
+      def initialize(organization)
+        @organization = organization
+      end
+
+      def query
+        Setting
+          .joins(:consultation)
+          .merge(organization_consultations)
+      end
+
+      private
+
+      attr_reader :organization
+
+      def organization_consultations
+        Decidim::Consultations::OrganizationConsultations.new(organization).query
+      end
+    end
+  end
+end

data/app/queries/decidim/action_delegator/published_responses.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class PublishedResponses < Rectify::Query
+      def initialize(consultation)
+        @consultation = consultation
+      end
+
+      # The Question's default_scope, `order(order: :asc)`, messes up the ordering in our queries so
+      # we have to explicitly remove the ORDER BY close using `#reorder`.
+      def query
+        Decidim::Consultations::Response
+          .joins(question: :consultation)
+          .merge(Consultation.finished)
+          .where(decidim_consultations_questions: { decidim_consultation_id: consultation.id })
+          .where.not(decidim_consultations_questions: { published_at: nil })
+      end
+
+      private
+
+      attr_reader :consultation
+    end
+  end
+end

data/app/queries/decidim/action_delegator/responses_by_membership.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    # Returns total votes of each response by memberships' type and weight.
+    #
+    # This query completely relies on the schema of the `metadata` of the relevant
+    # `decidim_authorizations` records, which is expected to be like:
+    #
+    #   "{ membership_type: '',   membership_weight: '' }"
+    #
+    # Note that although we assume `membership_type` to be a string and `membership_weight` to be an
+    # integer, there are no implications in the code for their actual data types.
+    class ResponsesByMembership < Rectify::Query
+      DEFAULT_METADATA = I18n.t("decidim.admin.consultations.results.default_metadata")
+
+      def initialize(relation)
+        @relation = relation
+      end
+
+      def query
+        relation
+          .select(
+            responses[:decidim_consultations_questions_id],
+            responses[:title],
+            membership(:type),
+            membership(:weight),
+            votes_count
+          )
+          .group(
+            responses[:decidim_consultations_questions_id],
+            responses[:title],
+            sql(:membership_type),
+            sql(:membership_weight)
+          )
+          .order(:title, :membership_type, { membership_weight: :desc }, "votes_count DESC")
+      end
+
+      private
+
+      attr_reader :relation
+
+      def membership(field)
+        full_field = "membership_#{field}"
+        coalesce(sql(full_field), default_metadata).as(full_field)
+      end
+
+      def memberships
+        Arel::Table.new(:memberships)
+      end
+
+      def default_metadata
+        sql("'#{DEFAULT_METADATA}'")
+      end
+
+      def votes_count
+        sql("COUNT(*)").as(sql(:votes_count))
+      end
+
+      def responses
+        Decidim::Consultations::Response.arel_table
+      end
+
+      def sql(name)
+        Arel.sql(name.to_s)
+      end
+
+      # This method comes with Rails 6. See:
+      # https://github.com/rails/rails/commit/e5190acacd1088211cfe6f128b782af216aa6570
+      def coalesce(*exprs)
+        Arel::Nodes::NamedFunction.new("COALESCE", exprs)
+      end
+    end
+  end
+end

data/app/queries/decidim/action_delegator/scrutiny.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class QuestionStats
+      attr_reader :total_delegates, :total_participants
+
+      def initialize(total_delegates, total_participants)
+        @total_delegates = total_delegates
+        @total_participants = total_participants
+      end
+    end
+
+    class Scrutiny
+      def initialize(consultation)
+        @consultation = consultation
+        @question_votes_by_id = questions_query.group_by(&:id)
+      end
+
+      def questions
+        questions_cache = build_questions_cache
+
+        question_votes_by_id.map do |_id, question_votes|
+          # They are all the same question so we can pick any
+          question = question_votes.first
+          QuestionWithTotals.new(question, questions_cache)
+        end
+      end
+
+      private
+
+      attr_reader :consultation, :questions_cache, :question_votes_by_id
+
+      # Returns a hash where the key is the question id and the value is an object that wraps some
+      # question's counts displayed in the view.
+      def build_questions_cache
+        question_votes_by_id.each_with_object({}) do |(id, question_votes), memo|
+          total_delegations = delegations_count(question_votes)
+          total_participants = participants_count(question_votes)
+
+          memo[id] = QuestionStats.new(total_delegations, total_participants)
+        end
+      end
+
+      # Computes the count of delegated votes out of rows returned by `#questions_query`, named
+      # `question_votes`.
+      def delegations_count(question_votes)
+        question_votes.count { |question| question.granter_id.present? }
+      end
+
+      # Computes the count of participants out of rows returned by `#questions_query`, named
+      # `question_votes`.
+      def participants_count(question_votes)
+        question_votes.map(&:decidim_author_id).uniq.compact.size
+      end
+
+      # Returns questions joined with their votes and delegations so that we can aggregate the data
+      # in Ruby in different ways but reaching out to DB just once.
+      def questions_query
+        @questions_query ||= Decidim::Consultations::Question
+                             .includes(:responses)
+                             .select(
+                               '"decidim_consultations_questions".*',
+                               '"decidim_consultations_votes"."decidim_author_id"',
+                               '"decidim_action_delegator_delegations"."granter_id"'
+                             )
+                             .from(questions_joined_votes_and_delegations)
+                             .where(decidim_consultation_id: consultation.id)
+                             .merge(Decidim::Consultations::Question.published)
+      end
+
+      def questions_joined_votes_and_delegations
+        <<-SQL.squish
+          "decidim_consultations_questions"
+          LEFT OUTER JOIN "decidim_consultations_votes"
+            ON "decidim_consultations_votes"."decidim_consultation_question_id" = "decidim_consultations_questions"."id"
+          LEFT JOIN "decidim_action_delegator_delegations"
+            ON "decidim_consultations_votes"."decidim_author_id" = "decidim_action_delegator_delegations"."granter_id"
+          LEFT JOIN "decidim_action_delegator_settings"
+            ON "decidim_action_delegator_settings"."id" = "decidim_action_delegator_delegations"."decidim_action_delegator_setting_id"
+          LEFT JOIN "decidim_consultations"
+            ON "decidim_consultations"."id" = "decidim_action_delegator_settings"."decidim_consultation_id"
+        SQL
+      end
+    end
+  end
+end