decidim-elections 0.24.3 → 0.25.0.rc1

data/app/commands/decidim/votings/voter/in_person_vote.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Voter
+      # This command allows the user to register an in person vote.
+      class InPersonVote < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A form with necessary info to register an in person vote.
+        def initialize(form)
+          @form = form
+        end
+
+        # Store and register the in person vote in the bulletin board
+        #
+        # Broadcasts :ok if successful, :invalid otherwise
+        def call
+          return broadcast(:invalid) if form.invalid?
+
+          transaction do
+            register_in_person_vote
+          end
+
+          broadcast(:ok, in_person_vote)
+        rescue StandardError => e
+          broadcast(:invalid, e.message)
+        end
+
+        private
+
+        attr_reader :form, :in_person_vote
+
+        delegate :bulletin_board, to: :form
+
+        def register_in_person_vote
+          bulletin_board.in_person_vote(form.election_id, form.voter_id, form.polling_station_slug) do |message_id|
+            create_in_person_vote(message_id)
+          end
+        end
+
+        def create_in_person_vote(message_id)
+          @in_person_vote = Decidim::Votings::InPersonVote.create!(
+            election: form.election,
+            polling_station: form.polling_station,
+            polling_officer: form.polling_officer,
+            message_id: message_id,
+            voter_id: form.voter_id,
+            status: :pending
+          )
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/votings/voter/update_in_person_vote_status.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Voter
+      # This command updates the in person vote status
+      class UpdateInPersonVoteStatus < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # in_person_vote     - the in person vote that has been updated
+        def initialize(in_person_vote)
+          @in_person_vote = in_person_vote
+        end
+
+        # Update status and send notification
+        #
+        # Broadcasts :ok if successful, :invalid otherwise
+        def call
+          return broadcast(:ok) unless status_changed?
+
+          transaction do
+            update_vote_status
+          end
+
+          broadcast(:ok)
+        rescue StandardError => e
+          broadcast(:invalid, e.message)
+        end
+
+        private
+
+        attr_reader :in_person_vote, :locale
+
+        def status_changed?
+          in_person_vote.status != vote_status
+        end
+
+        def bulletin_board
+          @bulletin_board ||= Decidim::Elections.bulletin_board
+        end
+
+        def vote_status
+          @vote_status ||= bulletin_board.get_pending_message_status(in_person_vote.message_id)
+        end
+
+        def update_vote_status
+          in_person_vote.update!(status: vote_status)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module Elections
+    # Common logic for the vote flow
+    module HasVoteFlow
+      extend ActiveSupport::Concern
+
+      included do
+        helper_method :voter_id, :voter_token, :voter_name, :preview_mode?, :ballot_style_id
+        delegate :voter_id, :ballot_style_id, :voter_token, :voter_name, :email, to: :vote_flow
+      end
+
+      def vote_flow
+        @vote_flow ||= election.participatory_space.try(:vote_flow_for, election) || default_vote_flow
+      end
+
+      def default_vote_flow
+        Decidim::Elections::CurrentUserVoteFlow.new(election, current_user) do
+          allowed_to?(:user_vote, :election, election: election)
+        end
+      end
+
+      def preview_mode?
+        return @preview_mode if defined?(@preview_mode)
+
+        @preview_mode = !election.published? || !election.started?
+      end
+
+      def can_preview?
+        return @can_preview if defined?(@can_preview)
+
+        @preview_mode = allowed_to?(:preview, :election, election: election)
+      end
+
+      def ballot_questions
+        vote_flow.questions_for(election)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module MonitoringCommitteePollingStationClosures
+    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
+                      LEFT JOIN decidim_votings_polling_station_closures closure ON closure.decidim_votings_polling_station_id = decidim_votings_polling_stations.id
+                        AND closure.decidim_elections_election_id = #{election_id}")
+
+            query = filter_by_validated(query)
+            filter_by_signed(query)
+          end
+
+          def election_id
+            params[:election_id]
+          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 extra_allowed_params
+            [:election_id, :per_page]
+          end
+
+          def filters
+            [:validated_eq, :signed_eq]
+          end
+
+          def filter_by_validated(query)
+            case ransack_params[:validated_eq]
+            when "false"
+              query.where(Arel.sql("closure.validated_at IS NOT NULL"))
+            when "true"
+              query.where(Arel.sql("closure.validated_at IS NULL"))
+            else
+              query
+            end
+          end
+
+          def filter_by_signed(query)
+            case ransack_params[:signed_eq]
+            when "false"
+              query.where(Arel.sql("closure.signed_at IS NOT NULL"))
+            when "true"
+              query.where(Arel.sql("closure.signed_at IS NULL"))
+            else
+              query
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,7 +7,7 @@ module Decidim
     module NeedsVoting
       def self.enhance_controller(instance_or_module)
         instance_or_module.class_eval do
-          helper_method :current_voting
+          helper_method :current_participatory_space
         end
       end
 
@@ -22,16 +22,16 @@ module Decidim
         # context.
         #
         # Returns the current Voting.
-        def current_voting
-          @current_voting ||= detect_voting
+        def current_participatory_space
+          @current_participatory_space ||= detect_voting
         end
 
-        alias current_participatory_space current_voting
+        alias current_voting current_participatory_space
 
         private
 
         def detect_voting
-          request.env["current_voting"] ||
+          request.env["current_participatory_space"] ||
             organization_votings.find_by(slug: params[:voting_slug] || params[:slug])
         end
 

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

@@ -6,7 +6,7 @@ module Decidim
       # This controller allows to manage the steps of an election.
       class StepsController < Admin::ApplicationController
         helper StepsHelper
-        helper_method :elections, :election, :current_step, :vote_stats
+        helper_method :elections, :election, :current_step, :vote_stats, :bulletin_board_server
 
         def index
           enforce_permission_to :read, :steps, election: election
@@ -22,7 +22,6 @@ module Decidim
           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)
@@ -46,6 +45,10 @@ module Decidim
 
         private
 
+        def bulletin_board_server
+          Decidim::Elections.bulletin_board.bulletin_board_server
+        end
+
         def current_step_form_class
           @current_step_form_class ||= {
             "create_election" => SetupForm,

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

@@ -7,8 +7,9 @@ module Decidim
       include FilterResource
       include Paginable
       include Decidim::Elections::Orderable
+      include HasVoteFlow
 
-      helper_method :elections, :election, :paginated_elections, :scheduled_elections, :single?, :last_vote
+      helper_method :elections, :election, :paginated_elections, :scheduled_elections, :single?, :onboarding, :authority_public_key, :bulletin_board_server, :authority_slug
 
       def index
         redirect_to election_path(single, single: true) if single?
@@ -18,8 +19,12 @@ module Decidim
         enforce_permission_to :view, :election, election: election
       end
 
+      def election_log; end
+
       private
 
+      delegate :bulletin_board_server, :authority_slug, to: :bulletin_board_client
+
       def elections
         @elections ||= Election.where(component: current_component).published
       end
@@ -28,6 +33,18 @@ module Decidim
         @election ||= Election.where(component: current_component).find(params[:id])
       end
 
+      def onboarding
+        @onboarding ||= params[:onboarding].present?
+      end
+
+      def bulletin_board_client
+        @bulletin_board_client ||= Decidim::Elections.bulletin_board
+      end
+
+      def authority_public_key
+        @authority_public_key ||= bulletin_board_client.authority_public_key.to_json
+      end
+
       # Public: Checks if the component has only one election resource.
       #
       # Returns Boolean.
@@ -39,10 +56,6 @@ module Decidim
         elections.first if single?
       end
 
-      def last_vote
-        @last_vote ||= Decidim::Elections::Votes::UserElectionLastVote.new(current_user, election).query
-      end
-
       def paginated_elections
         @paginated_elections ||= paginate(search.results.published)
         @paginated_elections = reorder(@paginated_elections)

data/app/controllers/decidim/elections/feedbacks_controller.rb

@@ -5,6 +5,8 @@ module Decidim
     # This controller allows a user to give feedback once finished voting
     class FeedbacksController < Decidim::Elections::ApplicationController
       include Decidim::Forms::Concerns::HasQuestionnaire
+      include HasVoteFlow
+
       helper_method :election
 
       def questionnaire_for
@@ -13,7 +15,17 @@ module Decidim
 
       # where the questionnaire will be submitted.
       def update_url
-        answer_election_feedback_path(election)
+        answer_election_feedback_path(election, hash: params[:hash], token: params[:token])
+      end
+
+      # Overwrites the 'after_answer_path' that gets passed to 'redirect_to'
+      # after answering the questionnaire. By default it redirects to the questionnaire_for.
+      def after_answer_path
+        if current_user.nil?
+          election_path(election, onboarding: true)
+        else
+          election_path(election)
+        end
       end
 
       private
@@ -23,7 +35,11 @@ module Decidim
       end
 
       def allow_answers?
-        current_user.present? && election.ongoing?
+        can_preview? || (election.ongoing? && valid_token?)
+      end
+
+      def visitor_already_answered?
+        election.questionnaire.answered_by?(session_token)
       end
 
       def i18n_flashes_scope
@@ -31,7 +47,25 @@ module Decidim
       end
 
       def enforce_permission_to_answer_questionnaire
-        enforce_permission_to :answer, :questionnaire, election: election
+        can_preview? || valid_token?
+      end
+
+      def allow_unregistered?
+        true
+      end
+
+      def valid_token?
+        return @valid_token if defined?(@valid_token)
+
+        @valid_token = vote_flow.voter_id_token(vote.voter_id) == session_token
+      end
+
+      def session_token
+        @session_token ||= params[:token]
+      end
+
+      def vote
+        @vote ||= Decidim::Elections::Vote.find_by(encrypted_vote_hash: params[:hash])
       end
     end
   end

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

@@ -5,7 +5,7 @@ module Decidim
     module TrusteeZone
       # Handles the KeyCeremony for trustee users
       class ElectionsController < Decidim::Elections::TrusteeZone::ApplicationController
-        helper_method :election
+        helper_method :election, :bulletin_board_server, :authority_slug, :authority_public_key, :current_step, :scheme_name
 
         def show
           enforce_permission_to :view, :election, trustee: trustee
@@ -26,9 +26,23 @@ module Decidim
 
         private
 
+        delegate :bulletin_board_server, :authority_slug, :scheme_name, to: :bulletin_board_client
+
         def election
           @election ||= Decidim::Elections::Election.find(params[:election_id])
         end
+
+        def bulletin_board_client
+          @bulletin_board_client ||= Decidim::Elections.bulletin_board
+        end
+
+        def authority_public_key
+          @authority_public_key ||= bulletin_board_client.authority_public_key.to_json
+        end
+
+        def current_step
+          @current_step ||= election.bb_status if election.bb_key_ceremony? || election.bb_tally?
+        end
       end
     end
   end

data/app/controllers/decidim/elections/votes_controller.rb

@@ -6,80 +6,95 @@ module Decidim
     class VotesController < Decidim::Elections::ApplicationController
       layout "decidim/election_votes"
       include FormFactory
+      include HasVoteFlow
 
       helper VotesHelper
-      helper_method :elections, :election, :questions, :questions_count, :booth_mode, :vote
+      helper_method :bulletin_board_server, :authority_public_key, :scheme_name, :election_unique_id,
+                    :exit_path, :elections, :election, :questions, :questions_count, :vote, :valid_questionnaire?
 
       delegate :count, to: :questions, prefix: true
 
       def new
-        return redirect_to(return_path, alert: t("votes.messages.not_allowed", scope: "decidim.elections")) if booth_mode.nil?
-        return redirect_to(pending_vote_path) if pending_vote?
+        vote_flow.voter_login(params)
+        return unless vote_allowed?
 
-        @form = form(Voter::EncryptedVoteForm).instance(election: election)
+        @form = form(Voter::VoteForm).from_params({ voter_token: voter_token, voter_id: voter_id },
+                                                  election: election, user: vote_flow.user)
       end
 
-      def update
-        Voter::UpdateVoteStatus.call(vote) do
-          on(:ok) do
-            flash[:notice] = I18n.t("votes.update.success", scope: "decidim.elections")
+      def create
+        vote_flow.voter_from_token(params.require(:vote).permit(:voter_token, :voter_id))
+        return unless valid_voter_token?
+        return unless vote_allowed?
+
+        return redirect_to election_vote_path(election, id: params[:vote][:encrypted_data_hash], token: vote_flow.voter_id_token) if preview_mode?
+
+        @form = form(Voter::VoteForm).from_params(params, election: election, user: vote_flow.user, email: vote_flow.email)
+        Voter::CastVote.call(@form) do
+          on(:ok) do |vote|
+            redirect_to election_vote_path(election, id: vote.encrypted_vote_hash, token: vote_flow.voter_id_token)
           end
           on(:invalid) do
-            flash[:alert] = I18n.t("votes.update.error", scope: "decidim.elections")
+            flash[:alert] = I18n.t("votes.create.error", scope: "decidim.elections")
+            redirect_to exit_path
           end
         end
       end
 
-      def cast
-        @form = form(Voter::EncryptedVoteForm).from_params(params, election: election)
-        return render :cast_success, locals: { message_id: "PreviewMessageId", vote_id: nil } if preview?
+      def show
+        enforce_permission_to :view, :election, election: election
+      end
+
+      def update
+        enforce_permission_to :view, :election, election: election
 
-        Voter::CastVote.call(@form) do
-          on(:ok) do |vote|
-            render :cast_success, locals: { message_id: vote.message_id, vote_id: vote.id }
+        Voter::UpdateVoteStatus.call(vote) do
+          on(:ok) do
+            redirect_to election_vote_path(election, id: vote.encrypted_vote_hash, token: vote_flow.voter_id_token(vote.voter_id))
           end
           on(:invalid) do
-            render :cast_failed
+            flash[:alert] = I18n.t("votes.update.error", scope: "decidim.elections")
+            redirect_to exit_path
           end
         end
       end
 
       def verify
-        @form = form(Ballot::VerifyVoteForm).instance(election: election)
+        enforce_permission_to :view, :election, election: election
+
+        @form = form(Voter::VerifyVoteForm).instance(election: election)
       end
 
       private
 
+      delegate :bulletin_board_server, :scheme_name, to: :bulletin_board_client
+
+      def election_unique_id
+        @election_unique_id ||= Decidim::BulletinBoard::MessageIdentifier.unique_election_id(bulletin_board_client.authority_slug, election.id)
+      end
+
       def vote
-        @vote ||= Decidim::Elections::Vote.find_by(id: params[:vote_id])
+        @vote ||= Decidim::Elections::Vote.find_by(election: election, encrypted_vote_hash: params[:id]) if params[:id]
       end
 
-      def pending_vote?
-        Decidim::Elections::Votes::PendingVotes.for.exists?(user: current_user, election: election)
+      def exit_path
+        @exit_path ||= if allowed_to? :view, :election, election: election
+                         election_path(election)
+                       else
+                         elections_path
+                       end
       end
 
-      def booth_mode
-        @booth_mode ||= if allowed_to? :vote, :election, election: election
-                          :vote
-                        elsif allowed_to? :preview, :election, election: election
-                          :preview
-                        end
+      def pending_vote
+        @pending_vote ||= Decidim::Elections::Votes::PendingVotes.for.find_by(voter_id: voter_id, election: election)
       end
 
-      def return_path
-        @return_path ||= if allowed_to? :view, :election, election: election
-                           election_path(election)
-                         else
-                           elections_path
-                         end
+      def bulletin_board_client
+        @bulletin_board_client ||= Decidim::Elections.bulletin_board
       end
 
-      def pending_vote_path
-        @pending_vote_path ||= if allowed_to? :view, :election, election: election
-                                 verify_election_vote_path(election)
-                               else
-                                 elections_path
-                               end
+      def authority_public_key
+        @authority_public_key ||= bulletin_board_client.authority_public_key.to_json
       end
 
       def elections
@@ -91,11 +106,56 @@ module Decidim
       end
 
       def questions
-        @questions ||= election.questions.includes(:answers).order(weight: :asc, id: :asc)
+        @questions ||= ballot_questions.includes(:answers).order(weight: :asc, id: :asc)
       end
 
-      def preview?
-        booth_mode == :preview
+      def vote_allowed?
+        if preview_mode?
+          return true if can_preview?
+
+          redirect_to(
+            exit_path,
+            alert: t("votes.messages.not_allowed",
+                     scope: "decidim.elections")
+          )
+          return false
+        end
+
+        if pending_vote.present?
+          redirect_to(
+            election_vote_path(election,
+                               id: pending_vote.encrypted_vote_hash,
+                               token: vote_flow.voter_id_token)
+          )
+          return false
+        end
+
+        vote_check_result = vote_flow.vote_check(online_vote_path: new_election_vote_path)
+        unless vote_check_result.allowed?
+          redirect_to(
+            vote_check_result.exit_path || exit_path,
+            alert: vote_check_result.error_message,
+            status: :temporary_redirect
+          )
+
+          return false
+        end
+
+        enforce_permission_to :vote, :election, election: election
+
+        true
+      end
+
+      def valid_voter_token?
+        return true if preview_mode? || vote_flow.valid_received_data?
+
+        redirect_to(exit_path, alert: t("votes.messages.invalid_token", scope: "decidim.elections"))
+      end
+
+      def valid_questionnaire?
+        return @valid_questionnaire if defined?(@valid_questionnaire)
+
+        @valid_questionnaire = election.questionnaire.questions.any?
       end
     end
   end