decidim-elections 0.23.6 → 0.24.0.rc1

data/app/commands/decidim/votings/admin/update_voting.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Admin
+      # A command with all the business logic when updating an existing
+      # voting in the system.
+      class UpdateVoting < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # voting - the Voting to update
+        # form - A form object with the params.
+        def initialize(voting, form)
+          image_fields.each do |field|
+            form.send("#{field}=".to_sym, voting.send(field)) if form.send(field).blank?
+          end
+          @voting = voting
+          @form = form
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) if form.invalid?
+
+          update_voting!
+
+          if voting.valid?
+            broadcast(:ok, voting)
+          else
+            image_fields.each do |field|
+              form.errors.add(field, voting.errors[field]) if voting.errors.include? field
+            end
+            broadcast(:invalid)
+          end
+        end
+
+        private
+
+        attr_reader :form, :voting
+
+        def image_fields
+          [:banner_image, :introductory_image]
+        end
+
+        def update_voting!
+          voting.assign_attributes(attributes)
+          return unless voting.valid?
+
+          voting.save!
+
+          Decidim.traceability.perform_action!(:update, voting, form.current_user) do
+            voting
+          end
+        end
+
+        def attributes
+          {
+            title: form.title,
+            description: form.description,
+            slug: form.slug,
+            start_time: form.start_time,
+            end_time: form.end_time,
+            scope: form.scope,
+            promoted: form.promoted,
+            voting_type: form.voting_type
+          }.merge(uploader_attributes)
+        end
+
+        def uploader_attributes
+          {
+            banner_image: form.banner_image,
+            remove_banner_image: form.remove_banner_image,
+            introductory_image: form.introductory_image,
+            remove_introductory_image: form.remove_introductory_image
+          }.delete_if { |_k, val| val.is_a?(Decidim::ApplicationUploader) }
+        end
+      end
+    end
+  end
+end

data/app/constraints/decidim/votings/current_component.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    # This class infers the current component on an voting context
+    # request parameters and injects it into the environment.
+    class CurrentComponent
+      # Public: Initializes the class.
+      #
+      # manifest - The manifest of the component to check against.
+      def initialize(manifest)
+        @manifest = manifest
+      end
+
+      # Public: Matches the request against a component and injects it into the
+      #         environment.
+      #
+      # request - The request that holds the current component relevant information.
+      #
+      # Returns a true if the request matches an voting and a
+      # component belonging to that voting, false otherwise
+      def matches?(request)
+        CurrentVoting.new.matches?(request) &&
+          Decidim::CurrentComponent.new(@manifest).matches?(request)
+      end
+    end
+  end
+end

data/app/constraints/decidim/votings/current_voting.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    # This class infers the current voting we're scoped to by
+    # looking at the request parameters and the organization in the request
+    # environment, and injects it into the environment.
+    class CurrentVoting
+      # Public: Matches the request against an voting and injects it
+      #         into the environment.
+      #
+      # request - The request that holds the voting relevant
+      #           information.
+      #
+      # Returns a true if the request matched, false otherwise
+      def matches?(request)
+        env = request.env
+
+        @organization = env["decidim.current_organization"]
+        return false unless @organization
+
+        current_voting(env, request.params).present?
+      end
+
+      private
+
+      def current_voting(env, params)
+        env["decidim.current_participatory_space"] ||=
+          detect_current_voting(params)
+      end
+
+      def detect_current_voting(params)
+        organization_votings.where(slug: params["voting_slug"]).or(
+          organization_votings.where(id: params["voting_slug"])
+        ).first!
+      end
+
+      def organization_votings
+        @organization_votings ||= OrganizationVotings.new(@organization).query
+      end
+    end
+  end
+end

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

@@ -25,9 +25,9 @@ module Decidim
         def reorder(elections)
           case order
           when "recent"
-            elections.order(start_time: :asc)
-          else
             elections.order(start_time: :desc)
+          else
+            elections.order(start_time: :asc)
           end
         end
       end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module PollingOfficers
+    module Admin
+      module Filterable
+        extend ActiveSupport::Concern
+
+        included do
+          include Decidim::Admin::Filterable
+
+          private
+
+          def base_query
+            query = Decidim::Votings::Admin::PollingOfficersJoinPollingStationsAndUser.for(collection)
+
+            filter_by_role(query)
+          end
+
+          def search_field_predicate
+            :name_or_email_or_nickname_or_presided_station_title_or_managed_station_title_cont
+          end
+
+          def filters
+            [
+              :role_eq
+            ]
+          end
+
+          def filters_with_values
+            {
+              role_eq: roles
+            }
+          end
+
+          def roles
+            [:president, :manager, :unassigned]
+          end
+
+          def filter_by_role(query)
+            case ransack_params[:role_eq]
+            when :president.to_s
+              query.where(Arel.sql("presided_station.id IS NOT NULL"))
+            when :manager.to_s
+              query.where(Arel.sql("managed_station.id IS NOT NULL"))
+            when :unassigned.to_s
+              query.where(Arel.sql("presided_station.id IS NULL")).where(Arel.sql("managed_station.id IS NULL"))
+            else
+              query
+            end
+          end
+        end
+      end
+    end
+  end
+end

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