decidim-elections 0.23.2 → 0.24.0

data/app/controllers/concerns/decidim/polling_stations/admin/filterable.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module PollingStations
+    module Admin
+      module Filterable
+        extend ActiveSupport::Concern
+
+        included do
+          include Decidim::Admin::Filterable
+
+          private
+
+          def base_query
+            query = collection
+                    # Includes the officers (president and managers) and their correspective decidim users when they(=officers) are present
+                    .joins("LEFT JOIN decidim_votings_polling_officers president ON president.presided_polling_station_id = decidim_votings_polling_stations.id
+                            LEFT JOIN decidim_users president_user ON president_user.id = president.decidim_user_id
+                            LEFT JOIN decidim_votings_polling_officers managers ON managers.managed_polling_station_id = decidim_votings_polling_stations.id
+                            LEFT JOIN decidim_users manager_user ON manager_user.id = managers.decidim_user_id")
+
+            filter_by_assigned(query)
+          end
+
+          def search_field_predicate
+            :title_or_address_or_manager_name_or_manager_email_or_manager_nickname_or_president_name_or_president_email_or_president_nickname_cont
+          end
+
+          def filters
+            [
+              :officers_assigned_eq
+            ]
+          end
+
+          def filters_with_values
+            {
+              officers_assigned_eq: [:assigned, :unassigned]
+            }
+          end
+
+          def filter_by_assigned(query)
+            case ransack_params[:officers_assigned_eq]
+            when :assigned.to_s
+              query.where(Arel.sql("president.id IS NOT NULL")).where(Arel.sql("managers.id IS NOT NULL"))
+            when :unassigned.to_s
+              query.where(Arel.sql("president.id IS NULL OR managers.id IS NULL"))
+            else
+              query
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/decidim/votings/admin/filterable.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module Votings
+    module Admin
+      module Filterable
+        extend ActiveSupport::Concern
+
+        included do
+          include Decidim::Admin::Filterable
+
+          private
+
+          def base_query
+            collection
+          end
+
+          def filters
+            [:published_at_null]
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/decidim/votings/admin/voting_admin.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module Votings
+    module Admin
+      # This concern is meant to be included in all controllers that are scoped
+      # into a voting admin panel. It will override the layout so it shows
+      # the sidebar, preload the voting, etc.
+      module VotingAdmin
+        extend ActiveSupport::Concern
+
+        RegistersPermissions
+          .register_permissions(::Decidim::Votings::Admin::VotingAdmin,
+                                Decidim::Votings::Permissions,
+                                Decidim::Admin::Permissions)
+
+        included do
+          include Decidim::Admin::ParticipatorySpaceAdminContext
+          participatory_space_admin_layout
+
+          helper_method :current_voting
+
+          def current_voting
+            @current_voting ||= organization_votings.find_by!(
+              slug: params[:voting_slug] || params[:slug]
+            )
+          end
+
+          alias_method :current_participatory_space, :current_voting
+
+          def organization_votings
+            @organization_votings ||= OrganizationVotings.new(current_organization).query
+          end
+
+          def permissions_context
+            super.merge(current_participatory_space: current_participatory_space)
+          end
+
+          def permission_class_chain
+            PermissionsRegistry.chain_for(VotingAdmin)
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/decidim/votings/needs_voting.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    # This module, when injected into a controller, ensures there's a
+    # voting available and deducts it from the context.
+    module NeedsVoting
+      def self.enhance_controller(instance_or_module)
+        instance_or_module.class_eval do
+          helper_method :current_voting
+        end
+      end
+
+      def self.included(base)
+        base.include Decidim::NeedsOrganization, InstanceMethods
+
+        enhance_controller(base)
+      end
+
+      module InstanceMethods
+        # Public: Finds the current Voting given this controller's
+        # context.
+        #
+        # Returns the current Voting.
+        def current_voting
+          @current_voting ||= detect_voting
+        end
+
+        alias current_participatory_space current_voting
+
+        private
+
+        def detect_voting
+          request.env["current_voting"] ||
+            organization_votings.find_by(slug: params[:voting_slug] || params[:slug])
+        end
+
+        def organization_votings
+          @organization_votings ||= OrganizationVotings.new(current_organization).query
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/decidim/votings/orderable.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module Votings
+    # Common logic to ordering resources
+    module Orderable
+      extend ActiveSupport::Concern
+
+      included do
+        include Decidim::Orderable
+
+        private
+
+        # Available orders based on enabled settings
+        def available_orders
+          %w(random recent)
+        end
+
+        def reorder(votings)
+          case order
+          when "recent"
+            votings.order_by_most_recent
+          else
+            votings.order_randomly(random_seed)
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/elections/admin/answers_controller.rb

@@ -57,6 +57,38 @@ module Decidim
           end
         end
 
+        def select
+          change_selected(true)
+        end
+
+        def unselect
+          change_selected(false)
+        end
+
+        def change_selected(selected)
+          enforce_permission_to :select, :answer, election: election, question: question
+
+          UpdateAnswerSelection.call(answer, selected) do
+            on(:ok) do
+              flash[:notice] = if selected
+                                 I18n.t("answers.select.success", scope: "decidim.elections.admin")
+                               else
+                                 I18n.t("answers.unselect.success", scope: "decidim.elections.admin")
+                               end
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = if selected
+                                    I18n.t("answers.select.invalid", scope: "decidim.elections.admin")
+                                  else
+                                    I18n.t("answers.unselect.invalid", scope: "decidim.elections.admin")
+                                  end
+            end
+          end
+
+          redirect_to election_question_answers_path(election, question)
+        end
+
         def destroy
           enforce_permission_to :update, :answer, election: election, question: question
 

data/app/controllers/decidim/elections/admin/elections_controller.rb

@@ -64,7 +64,7 @@ module Decidim
             end
 
             on(:invalid) do
-              flash.now[:alert] = I18n.t("elections.destroy.invalid", scope: "decidim.elections.admin")
+              flash[:alert] = I18n.t("elections.destroy.invalid", scope: "decidim.elections.admin")
             end
           end
 
@@ -96,7 +96,7 @@ module Decidim
         private
 
         def elections
-          @elections ||= Election.where(component: current_component)
+          @elections ||= Election.where(component: current_component).order(start_time: :desc)
         end
 
         def election

data/app/controllers/decidim/elections/admin/feedback_forms_controller.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Elections
+    module Admin
+      # This controller allows an admin to manage the form to be filled when a user finishes voting
+      class FeedbackFormsController < Admin::ApplicationController
+        include Decidim::Forms::Admin::Concerns::HasQuestionnaire
+        include Decidim::Forms::Admin::Concerns::HasQuestionnaireAnswers
+
+        def questionnaire_for
+          election
+        end
+
+        def update_url
+          feedback_form_path(election_id: election.id)
+        end
+
+        def after_update_url
+          edit_feedback_form_path(id: election.id)
+        end
+
+        def public_url
+          Decidim::EngineRouter.main_proxy(current_component).election_feedback_path(election)
+        end
+
+        def answer_options_url(params)
+          answer_options_election_feedback_path(**params)
+        end
+
+        def questionnaire_participants_url
+          answers_feedback_form_path(id: election.id)
+        end
+
+        def questionnaire_participant_answers_url(session_token)
+          answer_feedback_form_path(id: election.id, session_token: session_token)
+        end
+
+        def questionnaire_export_response_url(session_token)
+          answer_export_feedback_form_path(id: election.id, session_token: session_token, format: "pdf")
+        end
+
+        def questionnaire_url
+          edit_feedback_form_path(id: election.id)
+        end
+
+        private
+
+        def election
+          @election ||= Election.where(component: current_component).find(params[:id])
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/elections/admin/steps_controller.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Elections
+    module Admin
+      # This controller allows to manage the steps of an election.
+      class StepsController < Admin::ApplicationController
+        helper StepsHelper
+        helper_method :elections, :election, :current_step, :vote_stats
+
+        def index
+          enforce_permission_to :read, :steps, election: election
+
+          if current_step_form_class
+            @form = form(current_step_form_class).instance(election: election)
+            @form.valid?
+          end
+        end
+
+        def update
+          enforce_permission_to :update, :steps, election: election
+          redirect_to election_steps_path(election) && return unless params[:id] == current_step
+
+          @form = form(current_step_form_class).from_params(params, election: election)
+
+          if @form.pending_action
+            Decidim::Elections::Admin::UpdateActionStatus.call(@form.pending_action)
+            return redirect_to election_steps_path(election)
+          end
+
+          current_step_command_class.call(@form) do
+            on(:ok) do
+              flash[:notice] = I18n.t("steps.#{current_step}.success", scope: "decidim.elections.admin")
+              return redirect_to election_steps_path(election)
+            end
+            on(:invalid) do |message|
+              flash.now[:alert] = message || I18n.t("steps.#{current_step}.invalid", scope: "decidim.elections.admin")
+            end
+          end
+          render :index
+        end
+
+        def stats
+          render "decidim/elections/admin/steps/_vote_stats", layout: false
+        end
+
+        private
+
+        def current_step_form_class
+          @current_step_form_class ||= {
+            "create_election" => SetupForm,
+            "created" => ActionForm,
+            "key_ceremony_ended" => VotePeriodForm,
+            "vote" => VotePeriodForm,
+            "vote_ended" => ActionForm,
+            "tally_ended" => ActionForm
+          }[current_step]
+        end
+
+        def current_step_command_class
+          @current_step_command_class ||= {
+            "create_election" => SetupElection,
+            "created" => StartKeyCeremony,
+            "key_ceremony_ended" => StartVote,
+            "vote" => EndVote,
+            "vote_ended" => StartTally,
+            "tally_ended" => PublishResults
+          }[current_step]
+        end
+
+        def current_step
+          @current_step ||= election.bb_status || "create_election"
+        end
+
+        def elections
+          @elections ||= Election.where(component: current_component)
+        end
+
+        def election
+          @election ||= elections.find_by(id: params[:election_id])
+        end
+
+        def vote_stats
+          @vote_stats ||= {
+            votes: vote_counts.first,
+            voters: vote_counts.last
+          }
+        end
+
+        def vote_counts
+          @vote_counts ||= Decidim::Elections::Admin::VotesForStatistics.for(election)
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/elections/admin/trustees_participatory_spaces_controller.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Elections
+    module Admin
+      # This controller allows to add a user as trustee, update the status and remove a
+      # trustee from a participatory space.
+      class TrusteesParticipatorySpacesController < Admin::ApplicationController
+        helper Decidim::ApplicationHelper
+
+        helper_method :trustees, :trustee
+
+        def new
+          enforce_permission_to :create, :trustee_participatory_space
+          @form = form(TrusteesParticipatorySpaceForm).instance
+        end
+
+        def create
+          enforce_permission_to :create, :trustee_participatory_space
+          @form = form(TrusteesParticipatorySpaceForm).from_params(params)
+
+          AddUserAsTrustee.call(@form, current_user) do
+            on(:ok) do
+              flash[:notice] = I18n.t("trustees_participatory_spaces.create.success", scope: "decidim.elections.admin")
+              redirect_to trustees_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("trustees_participatory_spaces.create.invalid", scope: "decidim.elections.admin")
+              render action: "new"
+            end
+
+            on(:exists) do
+              flash.now[:alert] = I18n.t("trustees_participatory_spaces.create.exists", scope: "decidim.elections.admin")
+              render action: "new"
+            end
+          end
+        end
+
+        def edit
+          enforce_permission_to :update, :trustee_participatory_space, trustee_participatory_space: trustee_participatory_space
+
+          UpdateTrusteeParticipatorySpace.call(trustee_participatory_space) do
+            on(:ok) do |trustee|
+              flash[:notice] = I18n.t("trustees_participatory_spaces.update.success", scope: "decidim.elections.admin", trustee: trustee.user.name)
+            end
+
+            on(:invalid) do |trustee|
+              flash.now[:alert] = I18n.t("trustees_participatory_spaces.update.invalid", scope: "decidim.elections.admin", trustee: trustee.user.name)
+            end
+
+            redirect_to trustees_path
+          end
+        end
+
+        def destroy
+          enforce_permission_to :delete, :trustee_participatory_space, trustee_participatory_space: trustee_participatory_space
+
+          RemoveTrusteeFromParticipatorySpace.call(trustee_participatory_space) do
+            on(:ok) do
+              flash[:notice] = I18n.t("trustees_participatory_spaces.delete.success", scope: "decidim.elections.admin")
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("trustees_participatory_spaces.delete.invalid", scope: "decidim.elections.admin")
+            end
+          end
+
+          redirect_to trustees_path
+        end
+
+        private
+
+        def trustee_participatory_space
+          @trustee_participatory_space ||= TrusteesParticipatorySpace.find_by(id: params[:id])
+        end
+
+        def trustees
+          trustees_space = TrusteesParticipatorySpace.where(participatory_space: current_participatory_space).includes(:trustee)
+          @trustees ||= Trustee.where(trustees_participatory_spaces: trustees_space).includes([:user]).page(params[:page]).per(15)
+        end
+
+        def trustee
+          @trustee ||= trustees.find_by(id: params[:id])
+        end
+      end
+    end
+  end
+end