decidim-action_delegator 0.8.2 → 0.9.0

data/app/packs/src/decidim/action_delegator/elections_live_results.js

@@ -0,0 +1,160 @@
+/* eslint-disable max-params */
+document.addEventListener("DOMContentLoaded", () => {
+  const watchingDiv = document.querySelector("[data-weight-results-live-update]");
+  const questionsContainer = document.querySelector("[data-questions-container]");
+  const questionTemplate = document.getElementById("question-0");
+  const optionTemplate = document.querySelector("[data-option-template]");
+  if (!watchingDiv) {
+    return;
+  }
+
+  const url = watchingDiv.dataset.weightResultsLiveUpdate;
+  const optionVotesPercentTexts = () => document.querySelectorAll("[data-option-votes-percent-text]");
+  const optionVotesCountTexts = () => document.querySelectorAll("[data-option-votes-count-text]");
+  const optionVotesWidths = () => document.querySelectorAll("[data-option-votes-width]");
+  const questionUnweightedCountTexts = () => document.querySelectorAll("[data-question-unweighted-count-text]");
+  const questionWeightedCountTexts = () => document.querySelectorAll("[data-question-weighted-count-text]");
+  const questionDelegatedCountTexts = () => document.querySelectorAll("[data-question-delegated-count-text]");
+  const questionParticipantsCountTexts = () => document.querySelectorAll("[data-question-participants-count-text]");
+
+  const animateText = (element, value) => {
+    if (element.textContent === value) {
+      return;
+    }
+    element.textContent = value;
+    element.classList.add("live_results-number_changing");
+    setTimeout(() => {
+      element.classList.remove("live_results-number_changing");
+    }, 1000);
+  };
+
+  const digOptionValue = (data, questionId, optionId, ponderationId, key) => {
+    data.questions = data.questions || [];
+    const question = data.questions.find((item) => item.id === parseInt(questionId, 10));
+    if (!question) {
+      return null;
+    }
+    const responseOptions = question.response_options || [];
+    if (!Array.isArray(responseOptions)) {
+      return null;
+    }
+    const option = responseOptions.find((item) => {
+      if (ponderationId) {
+        return item.id === parseInt(optionId, 10) && item.ponderation_id === parseInt(ponderationId, 10);
+      }
+      return item.id === parseInt(optionId, 10);
+    });
+    // console.log("Digging option:", questionId, optionId, ponderationId, option);
+    if (!option) {
+      return null;
+    }
+    if (key in option) {
+      return option[key];
+    }
+    return null;
+  };
+
+  const createAdditionalQuestions = (data) => {
+    if (!questionTemplate || !questionsContainer || !optionTemplate) {
+      return;
+    }
+    const questions = data.questions || [];
+    const additionalQuestions = questions.filter((question) => !document.getElementById(`question-${question.id}`) && question.published_results);
+    additionalQuestions.forEach((question) => {
+      const questionElement = questionTemplate.cloneNode(true);
+      questionElement.id = `question-${question.id}`;
+      questionElement.classList.remove("hidden");
+      questionElement.querySelector("[data-question-body]").textContent = question.body;
+      const optionsContainer = questionElement.querySelector("[data-options-container]");
+      question.response_options.forEach((option) => {
+        const optionElement = optionTemplate.cloneNode(true);
+        optionElement.classList.remove("hidden");
+        optionElement.querySelector("[data-option-body]").textContent = option.body;
+        optionElement.querySelector("[data-option-votes-count-text").dataset.optionVotesCountText = `${question.id},${option.id}`;
+        optionElement.querySelector("[data-option-votes-percent-text").dataset.optionVotesPercentText = `${question.id},${option.id}`;
+        optionElement.querySelector("[data-option-votes-width").dataset.optionVotesWidth = `${question.id},${option.id}`;
+        optionsContainer.appendChild(optionElement);
+      });
+      questionsContainer.appendChild(questionElement);
+        
+    });
+  };
+  const fetchResults = async () => {
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          "Accept": "application/json", 
+          "Content-Type": "application/json",
+          "X-Requested-With": "XMLHttpRequest"
+        }
+      });
+      if (!response.ok) {
+        throw new Error("Network response was not ok");
+      }
+      const data = await response.json();
+      // console.log("Fetched data:", data);
+
+      createAdditionalQuestions(data);
+      optionVotesCountTexts().forEach((el) => {
+        const [questionId, optionId, ponderationId] = el.dataset.optionVotesCountText.split(",");
+        console.log("Updating count text for:", questionId, optionId, ponderationId);
+        const val = digOptionValue(data, questionId, optionId, ponderationId, "votes_count_text")
+        if (val) {
+          animateText(el, val);
+        }
+      });
+      optionVotesPercentTexts().forEach((el) => {
+        const [questionId, optionId, ponderationId] = el.dataset.optionVotesPercentText.split(",");
+        const val = digOptionValue(data, questionId, optionId, ponderationId, "votes_percent_text")
+        if (val) {
+          animateText(el, val);
+        }
+      });
+      optionVotesWidths().forEach((el) => {
+        const [questionId, optionId, ponderationId] = el.dataset.optionVotesWidth.split(",");
+        const val = digOptionValue(data, questionId, optionId, ponderationId, "votes_percent")
+        if (val) {
+          el.style.width = `${val}%`;
+        }
+      });
+      questionUnweightedCountTexts().forEach((el) => {
+        const questionId = el.dataset.questionUnweightedCountText;
+        const question = data.questions.find((item) => item.id === parseInt(questionId, 10));
+        if (question && question.unweighted_votes_text) {
+          animateText(el, question.unweighted_votes_text);
+        }
+      });
+      questionWeightedCountTexts().forEach((el) => {
+        const questionId = el.dataset.questionWeightedCountText;
+        const question = data.questions.find((item) => item.id === parseInt(questionId, 10));
+        if (question && question.weighted_votes_text) {
+          animateText(el, question.weighted_votes_text);
+        }
+      });
+      questionDelegatedCountTexts().forEach((el) => {
+        const questionId = el.dataset.questionDelegatedCountText;
+        const question = data.questions.find((item) => item.id === parseInt(questionId, 10));
+        if (question && question.delegated_votes_text) {
+          animateText(el, question.delegated_votes_text);
+        }
+      });
+      questionParticipantsCountTexts().forEach((el) => {
+        const questionId = el.dataset.questionParticipantsCountText;
+        const question = data.questions.find((item) => item.id === parseInt(questionId, 10));
+        if (question && question.participants_text) {
+          animateText(el, question.participants_text);
+        }
+      });
+
+      // repeat for ongoing elections only
+      if (data.ongoing) {
+        setTimeout(fetchResults, 4000);
+      }
+    } catch (error) {
+      console.error("Error fetching results:", error);
+    }
+  };
+
+  fetchResults();
+});

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    module Admin
+      class Permissions < Decidim::DefaultPermissions
+        def permissions
+          return permission_action if permission_action.scope != :admin
+          return permission_action unless user && user.admin?
+          return permission_action unless [:delegation, :ponderation, :participant, :setting].include?(permission_action.subject)
+
+          if permission_action.action == :destroy
+            toggle_allow(resource.present?)
+          else
+            allow!
+          end
+
+          permission_action
+        end
+
+        private
+
+        def resource
+          @resource ||= context.fetch(:resource, nil)
+        end
+      end
+    end
+  end
+end

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

@@ -3,16 +3,12 @@
 module Decidim
   module ActionDelegator
     class Permissions < Decidim::DefaultPermissions
-      SUBJECTS_WHITELIST = [:delegation, :ponderation, :participant, :setting, :consultation].freeze
-
       def permissions
-        allowed_delegation_action?
+        return permission_action unless user
 
-        return permission_action unless user && user.admin?
-        return permission_action unless permission_action.scope == :admin
-        return permission_action unless action_delegator_subject?
+        return Decidim::ActionDelegator::Admin::Permissions.new(user, permission_action, context).permissions if permission_action.scope == :admin
 
-        allow! if can_perform_action?
+        allowed_delegation_action?
 
         permission_action
       end
@@ -20,9 +16,9 @@ module Decidim
       private
 
       def allowed_delegation_action?
-        return unless delegation
+        return false unless delegation
         # Check that the required question verifications are fulfilled
-        return unless authorized?(:vote, delegation.grantee)
+        return false unless authorized?(:vote, delegation.grantee)
 
         case permission_action.action
         when :vote_delegation
@@ -33,7 +29,7 @@ module Decidim
       end
 
       def authorized?(permission_action, user, resource: nil)
-        return unless resource || question
+        return false unless resource || question
 
         ActionAuthorizer.new(user, permission_action, question, resource).authorize.ok?
       end
@@ -50,26 +46,6 @@ module Decidim
         @ponderation ||= context.fetch(:ponderation, 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

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class SettingPresenter < SimpleDelegator
+      include Decidim::TranslationsHelper
+
+      def initialize(setting)
+        @setting = setting
+
+        super
+      end
+
+      def translated_title
+        translated_attribute(__getobj__.title).html_safe
+      end
+
+      def translated_description
+        ActionView::Base.full_sanitizer.sanitize(translated_attribute(__getobj__.description)).html_safe
+      end
+
+      def translated_resources_list
+        Decidim::ActionDelegator::AuthorizedResources.new(setting: self).query.map(&:presenter)
+      end
+
+      def path_for(resource)
+        return nil unless resource
+
+        Decidim::ResourceLocatorPresenter.new(resource).path
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    # Query to find eligible users for corporate governance census elections
+    class ActionDelegatorCensusUsers < Decidim::Query
+      def initialize(election)
+        @election = election
+        @setting_id = election.census_settings["setting_id"]
+        @authorization_handlers = election.census_settings["authorization_handlers"]&.keys
+      end
+
+      def query
+        return Decidim::User.none unless @setting_id
+
+        setting = Decidim::ActionDelegator::Setting.find_by(id: @setting_id)
+        return Decidim::User.none unless setting
+
+        if @authorization_handlers.present?
+          authorized_participants_and_delegates(setting)
+        else
+          all_confirmed_users
+        end
+      end
+
+      private
+
+      attr_reader :election
+
+      def authorized_participants_and_delegates(setting)
+        participant_ids = setting.participants.pluck(:decidim_user_id)
+        delegation_ids = setting.delegations.joins(:grantee).pluck("decidim_action_delegator_delegations.grantee_id")
+
+        eligible_user_ids = (participant_ids + delegation_ids).compact.uniq
+        return @election.organization.users.none if eligible_user_ids.empty?
+
+        base_scope = @election.organization.users.where(id: eligible_user_ids)
+
+        Decidim::AuthorizedUsers.new(
+          organization: @election.organization,
+          handlers: @authorization_handlers,
+          strict: true
+        ).query.where(id: base_scope.select(:id))
+      end
+
+      def all_confirmed_users
+        @election.organization.users.not_deleted.not_blocked.confirmed
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class AuthorizedResources < Decidim::Query
+      # Finds all the resources that have configured the action delegator verifier
+      # Note that currently only returns elections (Decidim::Election)
+      # In the future components could be returned here as well
+      def initialize(setting:)
+        @setting = setting
+      end
+
+      def query
+        condition = [
+          "(census_manifest = 'internal_users' AND census_settings -> 'authorization_handlers' -> 'delegations_verifier' -> 'options' -> 'setting' ? :setting_id) OR " \
+          "(census_manifest = 'action_delegator_census' AND census_settings ->> 'setting_id' = :setting_id)",
+          { setting_id: @setting.id.to_s }
+        ]
+
+        Decidim::Elections::Election.where(component: components).where(condition)
+      end
+
+      def components
+        Decidim::PublicComponents.for(@setting.organization, manifest_name: "elections")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class ElectionSettings < Decidim::Query
+      # Finds all the settings for the given election that have the action delegator verifier configured
+      def initialize(election)
+        @election = election
+      end
+
+      def query
+        setting_id = case @election.census_manifest
+                     when "action_delegator_census"
+                       @election.census_settings["setting_id"]
+                     when "internal_users"
+                       @election.census_settings.dig("authorization_handlers", "delegations_verifier", "options", "setting")
+                     end
+
+        setting_id.present? ? Decidim::ActionDelegator::Setting.where(id: setting_id) : Decidim::ActionDelegator::Setting.none
+      end
+    end
+  end
+end

data/app/queries/decidim/action_delegator/{delegated_votes_versions.rb → elections_delegated_votes_versions.rb}

@@ -2,24 +2,24 @@
 
 module Decidim
   module ActionDelegator
-    # Returns all PaperTrail versions of a consultation's delegated votes for auditing purposes.
+    # Returns all PaperTrail versions of a election'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
+    class ElectionsDelegatedVotesVersions
+      def initialize(election)
+        @election = election
+        @settings = ElectionSettings.new(election).query
       end
 
       def query
         PaperTrail::Version
           .joins("INNER JOIN decidim_action_delegator_delegations ON decidim_action_delegator_delegations.id = versions.decidim_action_delegator_delegation_id")
           .joins("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 })
+          .where(item_type: "Decidim::Elections::Vote")
+          .where(decidim_action_delegator_settings: { id: @settings.select(:id) })
           .order("versions.created_at ASC")
       end
 
-      private
-
-      attr_reader :consultation
+      attr_reader :election, :settings
     end
   end
 end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class ElectionsQuestionResponsesByType
+      # Add your query logic here
+
+      def initialize(question, settings)
+        @question = question
+        @settings = settings
+      end
+
+      def query
+        return Decidim::Elections::ResponseOption.none if question.blank? || settings.blank?
+
+        ElectionsVotesWithPonderations
+          .new(question.response_options, settings)
+          .query
+          .select("#{Decidim::Elections::ResponseOption.table_name}.*,
+           COALESCE(decidim_action_delegator_ponderation_id, 0) AS ponderation_id,
+           COALESCE(CAST(decidim_action_delegator_ponderations.weight AS FLOAT), 1.0) AS ponderation_weight,
+           COUNT(decidim_elections_votes.id) AS votes_total")
+          .group("#{Decidim::Elections::ResponseOption.table_name}.id,
+           COALESCE(decidim_action_delegator_ponderation_id, 0),
+           COALESCE(CAST(decidim_action_delegator_ponderations.weight AS FLOAT), 1.0)")
+      end
+
+      private
+
+      attr_reader :question, :settings
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class ElectionsQuestionWeightedResponses
+      def initialize(question, settings)
+        @question = question
+        @settings = settings
+      end
+
+      def query
+        return Decidim::Elections::ResponseOption.none if question.blank? || settings.blank?
+
+        subquery = ElectionsQuestionResponsesByType.new(question, settings).query
+        Decidim::Elections::ResponseOption.unscoped
+                                          .joins("INNER JOIN (#{subquery.to_sql}) AS subquery ON subquery.id = #{Decidim::Elections::ResponseOption.table_name}.id")
+                                          .select(
+                                            "#{Decidim::Elections::ResponseOption.table_name}.*, SUM(subquery.votes_total * subquery.ponderation_weight) AS weighted_votes_total"
+                                          )
+                                          .group("#{Decidim::Elections::ResponseOption.table_name}.id")
+      end
+
+      private
+
+      attr_reader :question, :settings
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActionDelegator
+    class ElectionsVotesWithPonderations < Decidim::Query
+      def initialize(relation, settings)
+        @relation = relation
+        @settings = settings
+
+        @participants = Arel::Table.new("decidim_action_delegator_participants")
+        @ponderations = Arel::Table.new("decidim_action_delegator_ponderations")
+        @votes = Arel::Table.new("decidim_elections_votes")
+        @user_global_id_prefix = Decidim::User.new(id: 0).to_global_id.to_s.sub(%r{/0\z}, "/")
+      end
+
+      def query
+        return relation.none if settings.blank?
+
+        relation
+          .left_joins(:votes)
+          .joins(participants_join)
+          .joins(ponderations_join)
+      end
+
+      private
+
+      attr_reader :relation, :settings, :participants, :ponderations, :votes, :user_global_id_prefix
+
+      # LEFT OUTER JOIN "decidim_action_delegator_participants"
+      #       ON "decidim_action_delegator_participants"."decidim_action_delegator_setting_id" IN (1, 2, 3)
+      #       AND CONCAT(#{user_global_id_prefix}, "decidim_action_delegator_participants"."decidim_user_id") = "decidim_election_votes"."voter_uid"
+      #     LEFT OUTER JOIN "decidim_action_delegator_ponderations"
+      #       ON "decidim_action_delegator_ponderations"."id" = "decidim_action_delegator_participants"."decidim_action_delegator_ponderation_id"
+      def participants_join
+        Arel::Nodes::OuterJoin.new(
+          participants,
+          Arel::Nodes::On.new(
+            participants[:decidim_action_delegator_setting_id].in(settings.pluck(:id))
+            .and(
+              Arel::Nodes::NamedFunction.new(
+                "CONCAT",
+                [
+                  Arel::Nodes.build_quoted(user_global_id_prefix),
+                  participants[:decidim_user_id]
+                ]
+              ).eq(votes[:voter_uid])
+            )
+          )
+        )
+      end
+
+      def ponderations_join
+        Arel::Nodes::OuterJoin.new(
+          ponderations,
+          Arel::Nodes::On.new(
+            ponderations[:id].eq(participants[:decidim_action_delegator_ponderation_id])
+          )
+        )
+      end
+    end
+  end
+end

data/app/services/decidim/action_delegator/participants_csv_importer.rb

@@ -83,7 +83,7 @@ module Decidim
       end
 
       def check_exists?(field, form)
-        @participant = Decidim::ActionDelegator::Participant.find_by(field => form.send(field), setting: @current_setting) if form.send(field).present?
+        @participant = Decidim::ActionDelegator::Participant.find_by(field => form.send(field), :setting => @current_setting) if form.send(field).present?
         @participant.present?
       end
 

data/app/services/decidim/action_delegator/sms_gateway.rb

@@ -30,11 +30,11 @@ module Decidim
       end
 
       def sender
-        ENV["SMS_SENDER"]
+        ENV.fetch("SMS_SENDER", nil)
       end
 
       def sms_gateway_provider
-        ENV["SMS_GATEWAY_PROVIDER"]
+        ENV.fetch("SMS_GATEWAY_PROVIDER", nil)
       end
 
       def sms_gateway_provider_valid?

data/app/views/decidim/action_delegator/admin/censuses/_action_delegator_census_form.html.erb

@@ -0,0 +1,44 @@
+<div class="row column form__wrapper pb-4" id="corporate-governance-census-settings">
+  <%= form.select(:setting_id,
+                  options_for_select(form.object.settings_for_select, form.object.setting_id),
+                  { label: t("setting_group", scope: "decidim.action_delegator.admin.census"), prompt: false },
+                  { id: "action_delegator_census_setting_id" }) %>
+</div>
+
+<div class="row column font-semibold pb-4"><%= t("decidim.elections.censuses.internal_users.internal_type_title") %></div>
+<div class="row column">
+  <div class="callout">
+    <%= t("decidim.elections.censuses.action_delegator_census.authorizer_handler_admin_callout_html") %>
+  </div>
+
+</div>
+<div class="mt-4 form__wrapper gap-1">
+  <%= form.collection_check_boxes :authorization_handlers_names,
+                                  @form.available_authorizations,
+                                  :name,
+                                  :description do |builder| %>
+    <div class="row">
+      <%= builder.label { builder.check_box + builder.text } %>
+      <div id="authorization-handler-<%= builder.value %>" class="authorization-handler my-4 ml-6" style="display: <%= form.object.authorization_handlers_names.include?(builder.value) ? "block" : "none" %>;">
+        <%= render "decidim/action_delegator/admin/censuses/action_delegator_census_options_form", form: form, handler_name: builder.value %>
+      </div>
+    </div>
+  <% end %>
+</div>
+
+<script>
+  document.addEventListener("turbo:load", function() {
+    const checkboxes = document.querySelectorAll("input[type='checkbox'][id^='action_delegator_census_authorization_handlers_names_']");
+    checkboxes.forEach(checkbox => {
+      checkbox.addEventListener("change", function() {
+        const handlerId = `authorization-handler-${this.value}`;
+        const handlerElement = document.getElementById(handlerId);
+        if (this.checked) {
+          handlerElement.style.display = "block";
+        } else {
+          handlerElement.style.display = "none";
+        }
+      });
+    });
+  });
+</script>

data/app/views/decidim/action_delegator/admin/censuses/_action_delegator_census_options_form.html.erb

@@ -0,0 +1,25 @@
+<%
+  handler_name = local_assigns[:handler_name]
+  schema = form.object.options_schema(handler_name)
+  attributes = form.object.options_attributes(handler_name)
+  # this variable is send as a context in the settings_attribute_input helper
+  @component = current_component
+%>
+
+<%= form.fields_for(:authorization_handlers_options) do |options_form| %>
+  <%= options_form.fields_for(handler_name, schema) do |attribute_options_form| %>
+    <% attributes.each do |name, attribute| %>
+      <%# Skip the 'setting' field for delegations_verifier when using action_delegator_census %>
+      <%# because the setting is already selected at the census level %>
+      <% next if handler_name == "delegations_verifier" && name.to_s == "setting" %>
+
+      <%= settings_attribute_input(
+            attribute_options_form,
+            attribute,
+            name,
+            "decidim.authorization_handlers.#{handler_name}.fields",
+            tabs_prefix: "#{name}_tabs_prefix"
+          ) %>
+    <% end %>
+  <% end %>
+<% end %>