decidim-elections 0.23.5 → 0.24.2

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Admin
+      # This command is executed when the user destroys a polling station
+      # from the admin panel.
+      class DestroyPollingStation < Rectify::Command
+        def initialize(polling_station, current_user)
+          @polling_station = polling_station
+          @current_user = current_user
+        end
+
+        # Destroys the polling station if valid.
+        #
+        # Broadcasts :ok if successful, :invalid otherwise.
+        def call
+          destroy_polling_station!
+
+          broadcast(:ok, polling_station)
+        end
+
+        private
+
+        attr_reader :polling_station, :current_user
+
+        def destroy_polling_station!
+          Decidim.traceability.perform_action!(
+            :delete,
+            polling_station,
+            current_user,
+            visibility: "all"
+          ) do
+            polling_station.destroy!
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Admin
+      # A command with the shared business logic to manage a polling station
+      class ManagePollingStation < Rectify::Command
+        def manage_polling_officers(polling_station, president_id, managers_ids)
+          manage_president(polling_station, president_id)
+          manage_managers(polling_station, managers_ids)
+        end
+
+        private
+
+        def manage_president(polling_station, president_id)
+          unassign_president(polling_station)
+          return if president_id.nil?
+
+          assign_president(president_id, polling_station)
+          notify_officer(president_id, polling_station.voting)
+        end
+
+        def unassign_president(polling_station)
+          assign_president(polling_station.polling_station_president.id, nil) if polling_station.polling_station_president.present?
+        end
+
+        def assign_president(president_id, polling_station)
+          polling_officer_for(president_id).update(presided_polling_station: polling_station)
+        end
+
+        def manage_managers(polling_station, managers_ids)
+          unassign_managers(polling_station.polling_station_manager_ids - managers_ids)
+          assign_managers(polling_station, managers_ids - polling_station.polling_station_manager_ids)
+        end
+
+        def unassign_managers(managers_ids)
+          managers_ids.each { |manager_id| polling_officer_for(manager_id).update(managed_polling_station: nil) }
+        end
+
+        def assign_managers(polling_station, managers_ids)
+          managers_ids.each do |manager_id|
+            polling_officer_for(manager_id).update(managed_polling_station: polling_station)
+            notify_officer(manager_id, polling_station.voting)
+          end
+        end
+
+        def notify_officer(polling_officer_id, voting)
+          Decidim::EventsManager.publish(
+            event: "decidim.events.votings.polling_officers.polling_station_assigned",
+            event_class: ::Decidim::Votings::PollingOfficers::PollingStationAssignedEvent,
+            resource: voting,
+            affected_users: [polling_officer_for(polling_officer_id).user],
+            followers: [],
+            extra: { polling_officer_id: polling_officer_id }
+          )
+        end
+
+        def polling_officer_for(polling_officer_id)
+          PollingOfficer.find_by(id: polling_officer_id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Admin
+      # This command gets called when a voting is published from the admin panel.
+      class PublishVoting < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # voting - The voting to publish.
+        # current_user - the user performing the action
+        def initialize(voting, current_user)
+          @voting = voting
+          @current_user = current_user
+        end
+
+        # Public: Publishes the Voting.
+        #
+        # Broadcasts :ok if published, :invalid otherwise.
+        def call
+          return broadcast(:invalid) if voting.nil? || voting.published?
+
+          publish_voting
+
+          broadcast(:ok, voting)
+        end
+
+        private
+
+        attr_reader :voting, :current_user
+
+        def publish_voting
+          Decidim.traceability.perform_action!(:publish, voting, current_user, visibility: "all") do
+            voting.publish!
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Admin
+      # This command gets called when a voting is unpublished from the admin panel.
+      class UnpublishVoting < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # voting - The voting to unpublish.
+        # current_user - the user performing the action
+        def initialize(voting, current_user)
+          @voting = voting
+          @current_user = current_user
+        end
+
+        # Public: Unpublishes the Voting.
+        #
+        # Broadcasts :ok if unpublished, :invalid otherwise.
+        def call
+          return broadcast(:invalid) if voting.nil? || !voting.published?
+
+          unpublish_voting
+
+          broadcast(:ok, voting)
+        end
+
+        private
+
+        attr_reader :voting, :current_user
+
+        def unpublish_voting
+          Decidim.traceability.perform_action!(:unpublish, voting, current_user, visibility: "all") do
+            voting.unpublish!
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Admin
+      # This command is executed when the user updates a polling station
+      # from the admin panel.
+      class UpdatePollingStation < ManagePollingStation
+        def initialize(form, polling_station)
+          @form = form
+          @polling_station = polling_station
+        end
+
+        # Updates the polling station if valid.
+        #
+        # Broadcasts :ok if successful, :invalid otherwise.
+        def call
+          return broadcast(:invalid) if form.invalid?
+
+          update_polling_station!
+          manage_polling_officers(polling_station, form.polling_station_president_id, form.polling_station_manager_ids)
+
+          broadcast(:ok, polling_station)
+        end
+
+        private
+
+        attr_reader :form, :polling_station
+
+        def update_polling_station!
+          attributes = {
+            title: form.title,
+            address: form.address,
+            latitude: form.latitude,
+            longitude: form.longitude,
+            location: form.location,
+            location_hints: form.location_hints
+          }
+
+          Decidim.traceability.update!(
+            polling_station,
+            form.current_user,
+            attributes,
+            visibility: "all"
+          )
+        end
+      end
+    end
+  end
+end

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