decidim-elections 0.23.3 → 0.24.0.rc1

data/app/commands/decidim/elections/voter/update_vote_status.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Elections
+    module Voter
+      # This command updates the vote status and sends a notification.
+      class UpdateVoteStatus < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # message_id - the message_id to find a pending_message that is related to a vote.
+        def initialize(vote)
+          @vote = 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
+            send_vote_notification
+          end
+
+          broadcast(:ok)
+        rescue StandardError => e
+          broadcast(:invalid, e.message)
+        end
+
+        private
+
+        attr_reader :vote
+
+        def status_changed?
+          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(vote.message_id)
+        end
+
+        def update_vote_status
+          vote.status = vote_status
+          vote.save!
+        end
+
+        def send_vote_notification
+          return unless vote.accepted?
+
+          data = {
+            event: "decidim.events.elections.votes.accepted_votes",
+            event_class: Decidim::Elections::Votes::VoteAcceptedEvent,
+            resource: vote.election,
+            affected_users: [vote.user],
+            extra: {
+              vote: vote
+            }
+          }
+
+          Decidim::EventsManager.publish(data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Admin
+      # A command with the business logic to create a new monitoring committee member
+      class CreateMonitoringCommitteeMember < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params
+        # current_user - The user creating the monitoring committee member
+        # voting - The Voting that will hold the monitoring committee member
+        def initialize(form, current_user, voting)
+          @form = form
+          @current_user = current_user
+          @voting = voting
+        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?
+
+          ActiveRecord::Base.transaction do
+            user = retrieve_or_invite_user
+            create_monitoring_committee_member(user)
+          end
+
+          broadcast(:ok)
+        rescue ActiveRecord::RecordInvalid
+          form.errors.add(:email, :taken)
+          broadcast(:invalid)
+        end
+
+        private
+
+        attr_reader :form, :voting, :current_user
+
+        def retrieve_or_invite_user
+          form.user || existing_user || new_user
+        end
+
+        def create_monitoring_committee_member(user)
+          Decidim.traceability.perform_action!(
+            :create,
+            Decidim::Votings::MonitoringCommitteeMember,
+            current_user,
+            resource: {
+              title: user.name
+            }
+          ) do
+            Decidim::Votings::MonitoringCommitteeMember.find_or_create_by!(
+              user: user,
+              voting: voting
+            )
+          end
+        end
+
+        def existing_user
+          @existing_user ||= begin
+            tentative_user = User.find_by(
+              email: form.email,
+              organization: voting.organization
+            )
+
+            InviteUserAgain.call(tentative_user, invitation_instructions) if tentative_user && !tentative_user.invitation_accepted?
+
+            tentative_user
+          end
+        end
+
+        def new_user
+          @new_user ||= InviteUser.call(invite_user_form) do
+            on(:ok) do |invited_user|
+              return invited_user
+            end
+          end
+        end
+
+        def invite_user_form
+          OpenStruct.new(name: form.name,
+                         email: form.email.downcase,
+                         organization: voting.organization,
+                         admin: false,
+                         invited_by: current_user,
+                         invitation_instructions: invitation_instructions)
+        end
+
+        def invitation_instructions
+          "invite_collaborator"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Admin
+      # A command with the business logic to create a new polling officer
+      class CreatePollingOfficer < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params
+        # current_user - The user creating the polling officer
+        # voting - The Voting that will hold the polling officer
+        def initialize(form, current_user, voting)
+          @form = form
+          @current_user = current_user
+          @voting = voting
+        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?
+
+          ActiveRecord::Base.transaction do
+            user = retrieve_or_invite_user
+            create_polling_officer(user)
+          end
+
+          broadcast(:ok)
+        rescue ActiveRecord::RecordInvalid
+          form.errors.add(:email, :taken)
+          broadcast(:invalid)
+        end
+
+        private
+
+        attr_reader :form, :voting, :current_user
+
+        def retrieve_or_invite_user
+          form.user || existing_user || new_user
+        end
+
+        def create_polling_officer(user)
+          Decidim.traceability.perform_action!(
+            :create,
+            Decidim::Votings::PollingOfficer,
+            current_user,
+            resource: {
+              title: user.name
+            }
+          ) do
+            Decidim::Votings::PollingOfficer.find_or_create_by!(
+              user: user,
+              voting: voting
+            )
+          end
+        end
+
+        def existing_user
+          @existing_user ||= begin
+            tentative_user = User.find_by(
+              email: form.email,
+              organization: voting.organization
+            )
+
+            InviteUserAgain.call(tentative_user, invitation_instructions) if tentative_user && !tentative_user.invitation_accepted?
+
+            tentative_user
+          end
+        end
+
+        def new_user
+          @new_user ||= InviteUser.call(invite_user_form) do
+            on(:ok) do |invited_user|
+              return invited_user
+            end
+          end
+        end
+
+        def invite_user_form
+          OpenStruct.new(name: form.name,
+                         email: form.email.downcase,
+                         organization: voting.organization,
+                         admin: false,
+                         invited_by: current_user,
+                         invitation_instructions: invitation_instructions)
+        end
+
+        def invitation_instructions
+          "invite_collaborator"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Admin
+      # A command with all the business logic when creating a new polling station
+      class CreatePollingStation < ManagePollingStation
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params.
+        def initialize(form)
+          @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?
+
+          polling_station = create_polling_station!
+          manage_polling_officers(polling_station, form.polling_station_president_id, form.polling_station_manager_ids)
+
+          if polling_station.persisted?
+            broadcast(:ok, polling_station)
+          else
+            broadcast(:invalid)
+          end
+        end
+
+        private
+
+        attr_reader :form
+
+        def create_polling_station!
+          params = {
+            voting: form.voting,
+            title: form.title,
+            address: form.address,
+            latitude: form.latitude,
+            longitude: form.longitude,
+            location: form.location,
+            location_hints: form.location_hints
+          }
+
+          Decidim.traceability.create!(
+            PollingStation,
+            form.current_user,
+            params,
+            visibility: "all"
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Admin
+      # A command with all the business logic when creating a new voting space
+      class CreateVoting < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params.
+        def initialize(form)
+          @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?
+
+          voting = create_voting!
+
+          if voting.persisted?
+            broadcast(:ok, voting)
+          else
+            form.errors.add(:banner_image, voting.errors[:banner_image]) if voting.errors.include? :banner_image
+            form.errors.add(:introductory_image, voting.errors[:introductory_image]) if voting.errors.include? :introductory_image
+            broadcast(:invalid)
+          end
+        end
+
+        private
+
+        attr_reader :form
+
+        def create_voting!
+          Decidim.traceability.create(
+            Voting,
+            form.current_user,
+            organization: form.current_organization,
+            title: form.title,
+            slug: form.slug,
+            description: form.description,
+            scope: form.scope,
+            start_time: form.start_time,
+            end_time: form.end_time,
+            promoted: form.promoted,
+            banner_image: form.banner_image,
+            introductory_image: form.introductory_image,
+            voting_type: form.voting_type
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Admin
+      # A command with the business logic to destroy a monitoring committee member
+      class DestroyMonitoringCommitteeMember < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # monitoring_committee_member - the MonitoringCommitteeMember to destroy
+        # current_user - the user performing this action
+        def initialize(monitoring_committee_member, current_user)
+          @monitoring_committee_member = monitoring_committee_member
+          @current_user = current_user
+        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
+          destroy_monitoring_committee_member!
+          broadcast(:ok)
+        end
+
+        private
+
+        attr_reader :monitoring_committee_member, :current_user
+
+        def destroy_monitoring_committee_member!
+          extra_info = {
+            resource: {
+              title: monitoring_committee_member.user.name
+            }
+          }
+
+          Decidim.traceability.perform_action!(
+            "delete",
+            monitoring_committee_member,
+            current_user,
+            extra_info
+          ) do
+            monitoring_committee_member.destroy!
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Admin
+      # A command with the business logic to destroy a poling officer
+      class DestroyPollingOfficer < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # polling_officer - the PollingOfficer to destroy
+        # current_user - the user performing this action
+        def initialize(polling_officer, current_user)
+          @polling_officer = polling_officer
+          @current_user = current_user
+        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
+          destroy_polling_officer!
+          broadcast(:ok)
+        end
+
+        private
+
+        attr_reader :polling_officer, :current_user
+
+        def destroy_polling_officer!
+          extra_info = {
+            resource: {
+              title: polling_officer.user.name
+            }
+          }
+
+          Decidim.traceability.perform_action!(
+            "delete",
+            polling_officer,
+            current_user,
+            extra_info
+          ) do
+            polling_officer.destroy!
+            polling_officer
+          end
+        end
+      end
+    end
+  end
+end