decidim-elections 0.24.3 → 0.25.0.rc1

data/app/controllers/decidim/votings/polling_officer_zone/closures_controller.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module PollingOfficerZone
+      # Space to manage the election closure of a Polling Station
+      class ClosuresController < Decidim::Votings::PollingOfficerZone::ApplicationController
+        helper_method :election, :polling_officer, :polling_station, :closure
+
+        def show
+          enforce_permission_to :manage, :polling_station_results, polling_officer: polling_officer
+
+          @form = if closure.certificate_phase?
+                    form(ClosureCertifyForm).instance.with_context(closure: closure)
+                  elsif closure.signature_phase?
+                    form(ClosureSignForm).instance
+                  end
+        end
+
+        def new
+          enforce_permission_to :manage, :polling_station_results, polling_officer: polling_officer
+
+          @form = EnvelopesResultForm.new(
+            polling_station_id: polling_station.id,
+            election_id: election.id,
+            election_votes_count: polling_station_election_votes_count
+          )
+        end
+
+        def create
+          enforce_permission_to :manage, :polling_station_results, polling_officer: polling_officer
+          @form = form(EnvelopesResultForm).from_params(params).with_context(polling_officer: polling_officer)
+
+          CreatePollingStationClosure.call(@form) do
+            on(:ok) do
+              flash[:notice] = t(".success")
+              redirect_to edit_polling_officer_election_closure_path(polling_officer, election)
+            end
+
+            on(:invalid) do
+              flash[:alert] = t(".error")
+
+              render :new
+            end
+          end
+        end
+
+        def edit
+          enforce_permission_to :manage, :polling_station_results, polling_officer: polling_officer
+
+          @form = form(ClosureResultForm).from_model(closure)
+        end
+
+        def update
+          enforce_permission_to :manage, :polling_station_results, polling_officer: polling_officer
+          @form = form(ClosureResultForm).from_params(params)
+
+          CreatePollingStationResults.call(@form, closure) do
+            on(:ok) do
+              flash[:notice] = t(".success")
+            end
+
+            on(:invalid) do
+              flash[:alert] = t(".error")
+            end
+          end
+
+          redirect_to polling_officer_election_closure_path(polling_officer, election)
+        end
+
+        def certify
+          enforce_permission_to :manage, :polling_station_results, polling_officer: polling_officer
+
+          @form = form(ClosureCertifyForm).from_params(params).with_context(closure: closure)
+
+          CertifyPollingStationClosure.call(@form, closure) do
+            on(:ok) do
+              flash[:notice] = t(".success")
+            end
+
+            on(:invalid) do
+              flash[:alert] = t(".error")
+            end
+          end
+
+          redirect_to polling_officer_election_closure_path(polling_officer, election)
+        end
+
+        def sign
+          enforce_permission_to :manage, :polling_station_results, polling_officer: polling_officer
+
+          @form = form(ClosureSignForm).from_params(params)
+
+          SignPollingStationClosure.call(@form, closure) do
+            on(:ok) do
+              flash[:notice] = t(".success")
+            end
+
+            on(:invalid) do
+              flash[:alert] = t(".error")
+            end
+          end
+
+          redirect_to polling_officer_election_closure_path(polling_officer, election)
+        end
+
+        private
+
+        def polling_officer
+          @polling_officer ||= polling_officers.find_by(id: params[:polling_officer_id])
+        end
+
+        def election
+          @election ||= Decidim::Elections::Election.includes(questions: :answers).find_by(id: params[:election_id])
+        end
+
+        def polling_station
+          @polling_station ||= polling_officer.polling_station
+        end
+
+        def closure
+          @closure ||= polling_station.closures.find_by(election: election)
+        end
+
+        def polling_station_election_votes_count
+          @polling_station_election_votes_count ||= polling_station.in_person_votes.where(election: election).count
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/votings/polling_officer_zone/in_person_votes_controller.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module PollingOfficerZone
+      # Space to manage the elections for a Polling Station Officer
+      class InPersonVotesController < Decidim::Votings::PollingOfficerZone::ApplicationController
+        include FormFactory
+        include Decidim::Elections::HasVoteFlow
+
+        helper_method :polling_officer, :election, :in_person_form, :has_voter?,
+                      :vote_check, :cant_vote_reason, :questions, :in_person_vote_form, :voted_online?,
+                      :in_person_vote, :bulletin_board_server, :exit_path
+
+        helper Decidim::Admin::IconLinkHelper
+
+        def new
+          enforce_permission_to :manage, :in_person_vote, polling_officer: polling_officer
+
+          has_pending_in_person_vote?
+        end
+
+        def create
+          enforce_permission_to :manage, :in_person_vote, polling_officer: polling_officer
+
+          return if has_pending_in_person_vote?
+
+          if verified_voter?
+            store_in_person_vote
+          else
+            identify_voter
+          end
+        end
+
+        def show
+          enforce_permission_to :manage, :in_person_vote, polling_officer: polling_officer
+        end
+
+        def update
+          enforce_permission_to :manage, :in_person_vote, polling_officer: polling_officer
+
+          Decidim::Votings::Voter::UpdateInPersonVoteStatus.call(in_person_vote) do
+            on(:ok) do
+              message_type = in_person_vote.accepted? ? :notice : :alert
+              flash[message_type] = I18n.t("in_person_votes.update.success.#{in_person_vote.status}", scope: "decidim.votings.polling_officer_zone")
+            end
+            on(:invalid) do
+              flash[:alert] = I18n.t("in_person_votes.update.error", scope: "decidim.votings.polling_officer_zone")
+            end
+          end
+          redirect_to exit_path
+        end
+
+        private
+
+        attr_reader :cant_vote_reason
+
+        delegate :bulletin_board_server, to: :bulletin_board_client
+        delegate :has_voter?, to: :vote_flow
+        delegate :polling_station, to: :polling_officer
+
+        def bulletin_board_client
+          @bulletin_board_client ||= Decidim::Elections.bulletin_board
+        end
+
+        def has_pending_in_person_vote?
+          if pending_in_person_vote.present?
+            redirect_to(polling_officer_election_in_person_vote_path(polling_officer, election, id: pending_in_person_vote.id))
+            true
+          end
+        end
+
+        def identify_voter
+          vote_flow.voter_in_person(params) if in_person_form.valid?
+
+          render :new
+        end
+
+        def vote_check
+          @vote_check ||= vote_flow.vote_check
+        end
+
+        def verified_voter?
+          params[:in_person_vote] &&
+            vote_flow.voter_from_token(params.require(:in_person_vote).permit(:voter_token, :voter_id))
+        end
+
+        def store_in_person_vote
+          return redirect_to exit_path, alert: vote_check.error_message unless vote_check.allowed?
+
+          Decidim::Votings::Voter::InPersonVote.call(in_person_vote_form) do
+            on(:ok) do |created_in_person_vote|
+              redirect_to polling_officer_election_in_person_vote_path(polling_officer, election, created_in_person_vote)
+            end
+            on(:invalid) do
+              flash[:alert] = I18n.t("in_person_votes.create.error", scope: "decidim.votings.polling_officer_zone")
+              redirect_to exit_path
+            end
+          end
+        end
+
+        def in_person_form
+          @in_person_form ||= form(Decidim::Votings::Census::InPersonForm).from_params(params)
+        end
+
+        def in_person_vote_form
+          @in_person_vote_form ||= form(Decidim::Votings::Voter::InPersonVoteForm).from_params(
+            {
+              voter_token: voter_token,
+              voter_id: voter_id,
+              voted: params.dig(:in_person_vote, :voted)
+            },
+            election: election,
+            polling_station: polling_station,
+            polling_officer: polling_officer
+          )
+        end
+
+        def voted_online?
+          Decidim::Elections::Votes::LastVoteForVoter.for(election, vote_flow.voter_id) if vote_flow.has_voter?
+        end
+
+        def election
+          @election ||= Decidim::Elections::Election.find(params[:election_id])
+        end
+
+        def polling_officer
+          @polling_officer ||= Decidim::Votings::PollingOfficer.find(params[:polling_officer_id])
+        end
+
+        def questions
+          @questions ||= ballot_questions.includes(:answers).order(weight: :asc, id: :asc)
+        end
+
+        def in_person_vote
+          @in_person_vote ||= Decidim::Votings::InPersonVote.find_by(id: params[:id]) if params[:id]
+        end
+
+        def pending_in_person_vote
+          @pending_in_person_vote ||= Decidim::Votings::Votes::PendingInPersonVotes.for.find_by(polling_officer: polling_officer, election: election)
+        end
+
+        def exit_path
+          @exit_path ||= new_polling_officer_election_in_person_vote_path(polling_officer, election)
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/votings/polling_officer_zone/polling_officers_controller.rb

@@ -6,11 +6,19 @@ module Decidim
       # Exposes the polling officer zone for polling officer users
       class PollingOfficersController < Decidim::Votings::PollingOfficerZone::ApplicationController
         helper Decidim::Admin::IconLinkHelper
-        helper_method :polling_stations
+        helper Decidim::ResourceHelper
 
-        def show
+        helper_method :polling_stations, :polling_officers_elections
+
+        def index
           enforce_permission_to :view, :polling_officers, polling_officers: polling_officers
         end
+
+        private
+
+        def polling_officers_elections
+          @polling_officers_elections ||= polling_officers.flat_map { |polling_officer| polling_officer.voting.published_elections }
+        end
       end
     end
   end

data/app/controllers/decidim/votings/votings_controller.rb

@@ -5,15 +5,17 @@ module Decidim
     # A controller that holds the logic to show votings in a
     # public layout.
     class VotingsController < Decidim::Votings::ApplicationController
-      layout "layouts/decidim/voting", only: :show
+      layout "layouts/decidim/voting_landing", only: :show
 
+      include FormFactory
       include ParticipatorySpaceContext
       include NeedsVoting
       include FilterResource
       include Paginable
       include Decidim::Votings::Orderable
+      include Decidim::Elections::HasVoteFlow
 
-      helper_method :published_votings, :paginated_votings, :filter, :promoted_votings, :only_finished_votings?
+      helper_method :published_votings, :paginated_votings, :filter, :promoted_votings, :only_finished_votings?, :landing_content_blocks, :census_contact_information
 
       helper Decidim::FiltersHelper
       helper Decidim::OrdersHelper
@@ -22,6 +24,7 @@ module Decidim
       helper Decidim::IconHelper
       helper Decidim::WidgetUrlsHelper
       helper Decidim::ResourceHelper
+      helper Decidim::Admin::IconLinkHelper
 
       def index
         raise ActionController::RoutingError, "Not Found" if published_votings.none?
@@ -31,13 +34,90 @@ module Decidim
       end
 
       def show
-        raise ActionController::RoutingError, "Not Found" unless current_voting
+        raise ActionController::RoutingError, "Not Found" unless current_participatory_space
 
-        enforce_permission_to :read, :voting, voting: current_voting
+        enforce_permission_to :read, :voting, voting: current_participatory_space
+      end
+
+      helper_method :election, :exit_path, :election_log_path, :elections
+
+      def login
+        @form = form(Census::LoginForm).from_params(params, election: election)
+
+        render :login,
+               layout: "decidim/election_votes"
+      end
+
+      def show_check_census
+        @form = form(Census::CheckForm).instance
+        render :check_census, locals: { success: false, not_found: false }
+      end
+
+      def check_census
+        @form = form(Census::CheckForm).from_params(params).with_context(
+          current_participatory_space: current_participatory_space
+        )
+
+        success = not_found = false
+        datum = nil
+        CheckCensus.call(@form) do
+          on(:ok) do |census|
+            success = true
+            datum = census
+          end
+          on(:not_found) do
+            not_found = true
+          end
+          on(:invalid) do
+            flash[:alert] = t("check_census.invalid", scope: "decidim.votings.votings")
+          end
+        end
+
+        render action: :check_census, locals: { success: success, not_found: not_found, datum: datum }
+      end
+
+      def send_access_code
+        SendAccessCode.call(datum, params[:medium]) do
+          on(:ok) do
+            flash[:notice] = t("send_access_code.success", scope: "decidim.votings.votings")
+          end
+          on(:invalid) do
+            flash[:alert] = t("send_access_code.invalid", scope: "decidim.votings.votings")
+          end
+        end
+        render action: :check_census, locals: { success: true, not_found: false, datum: datum }
+      end
+
+      def elections_log
+        redirect_to election_log_path(elections.first) if elections.length == 1
       end
 
       private
 
+      def datum
+        @datum ||= Decidim::Votings::Census::Datum.find(params[:datum_id])
+      end
+
+      def election
+        @election ||= Decidim::Elections::Election.find(params[:election_id])
+      end
+
+      def elections
+        Decidim::Elections::Election.where(component: current_participatory_space.components).where.not(bb_status: nil)
+      end
+
+      def exit_path
+        EngineRouter.main_proxy(election.component).election_path(election)
+      end
+
+      def election_log_path(election)
+        EngineRouter.main_proxy(election.component).election_log_election_path(election)
+      end
+
+      def census_contact_information
+        @census_contact_information ||= current_participatory_space.census_contact_information.presence || t("no_census_contact_information", scope: "decidim.votings.votings")
+      end
+
       def current_participatory_space_manifest
         @current_participatory_space_manifest ||= Decidim.find_participatory_space_manifest(:votings)
       end
@@ -93,6 +173,13 @@ module Decidim
       def single
         published_votings.first if single?
       end
+
+      def landing_content_blocks
+        @landing_content_blocks ||= Decidim::ContentBlock.published
+                                                         .for_scope(:voting_landing_page, organization: current_organization)
+                                                         .where(scoped_resource_id: current_participatory_space.id)
+                                                         .reject { |content_block| content_block.manifest.nil? }
+      end
     end
   end
 end

data/app/events/decidim/elections/votes/vote_accepted_event.rb

@@ -16,7 +16,7 @@ module Decidim
         end
 
         def verify_url
-          Decidim::EngineRouter.main_proxy(resource.component).verify_election_vote_url(resource)
+          extra[:verify_url]
         end
       end
     end

data/app/forms/decidim/elections/admin/action_form.rb

@@ -28,6 +28,11 @@ module Decidim
         def bulletin_board
           @bulletin_board ||= context[:bulletin_board] || Decidim::Elections.bulletin_board
         end
+
+        def refresh
+          remove_instance_variable(:@pending_action)
+          remove_instance_variable(:@current_step)
+        end
       end
     end
   end