decidim-bulletin_board 0.6.0 → 0.9.0

data/lib/decidim/bulletin_board/authority.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require "decidim/bulletin_board/authority/create_election"
+require "decidim/bulletin_board/authority/end_vote"
 require "decidim/bulletin_board/authority/get_election_status"
-require "decidim/bulletin_board/authority/open_ballot_box"
-require "decidim/bulletin_board/authority/close_ballot_box"
+require "decidim/bulletin_board/authority/start_key_ceremony"
+require "decidim/bulletin_board/authority/start_tally"
+require "decidim/bulletin_board/authority/start_vote"
+require "decidim/bulletin_board/authority/publish_results"

data/lib/decidim/bulletin_board/authority/create_election.rb

@@ -10,28 +10,34 @@ module Decidim
           @election_data = election_data
         end
 
+        # Returns the message_id related to the operation
+        def message_id
+          @message_id ||= build_message_id(unique_election_id(election_id), "create_election")
+        end
+
         def call
-          message_id = message_id(unique_election_id(election_id), "create_election")
-          signed_data = sign_message(message_id, election_data)
-
-          begin
-            response = client.query do
-              mutation do
-                createElection(messageId: message_id, signedData: signed_data) do
-                  election do
-                    status
-                  end
-                  error
+          # arguments used inside the graphql operation
+          args = {
+            message_id: message_id,
+            signed_data: sign_message(message_id, election_data)
+          }
+
+          response = client.query do
+            mutation do
+              createElection(messageId: args[:message_id], signedData: args[:signed_data]) do
+                election do
+                  status
                 end
+                error
               end
             end
+          end
 
-            return broadcast(:error, response.data.create_election.error) if response.data.create_election.error.present?
+          return broadcast(:error, response.data.create_election.error) if response.data.create_election.error.present?
 
-            broadcast(:ok, response.data.create_election.election)
-          rescue Graphlient::Errors::ServerError
-            broadcast(:error, "Sorry, something went wrong")
-          end
+          broadcast(:ok, response.data.create_election.election)
+        rescue Graphlient::Errors::ServerError
+          broadcast(:error, "Sorry, something went wrong")
         end
 
         private

data/lib/decidim/bulletin_board/authority/end_vote.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Decidim
+  module BulletinBoard
+    module Authority
+      # This command uses the GraphQL client to request the ending of the voting period.
+      class EndVote < Decidim::BulletinBoard::Command
+        # Public: Initializes the command.
+        #
+        # election_id - The local election identifier
+        def initialize(election_id)
+          @election_id = election_id
+        end
+
+        # Returns the message_id related to the operation
+        def message_id
+          @message_id ||= build_message_id(unique_election_id(election_id), "end_vote")
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid and the query operation is successful.
+        # - :error if query operation was not successful.
+        #
+        # Returns nothing.
+        def call
+          # arguments used inside the graphql operation
+          args = {
+            message_id: message_id,
+            signed_data: sign_message(message_id, {})
+          }
+
+          response = client.query do
+            mutation do
+              endVote(messageId: args[:message_id], signedData: args[:signed_data]) do
+                pendingMessage do
+                  status
+                end
+                error
+              end
+            end
+          end
+
+          return broadcast(:error, response.data.end_vote.error) if response.data.end_vote.error.present?
+
+          broadcast(:ok, response.data.end_vote.pending_message)
+        rescue Graphlient::Errors::FaradayServerError
+          broadcast(:error, "Sorry, something went wrong")
+        end
+
+        private
+
+        attr_reader :election_id
+      end
+    end
+  end
+end

data/lib/decidim/bulletin_board/authority/get_election_status.rb

@@ -19,21 +19,22 @@ module Decidim
         #
         # Returns nothing.
         def call
-          unique_id = unique_election_id(election_id)
+          # arguments used inside the graphql operation
+          args = {
+            unique_id: unique_election_id(election_id)
+          }
 
-          begin
-            response = client.query do
-              query do
-                election(uniqueId: unique_id) do
-                  status
-                end
+          response = client.query do
+            query do
+              election(uniqueId: args[:unique_id]) do
+                status
               end
             end
-
-            broadcast(:ok, response.data.election.status)
-          rescue Graphlient::Errors::ServerError
-            broadcast(:error, "Sorry, something went wrong")
           end
+
+          broadcast(:ok, response.data.election.status)
+        rescue Graphlient::Errors::ServerError
+          broadcast(:error, "Sorry, something went wrong")
         end
 
         private

data/lib/decidim/bulletin_board/authority/publish_results.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Decidim
+  module BulletinBoard
+    module Authority
+      # This command uses the GraphQL client to publish the election results.
+      class PublishResults < Decidim::BulletinBoard::Command
+        # Public: Initializes the command.
+        #
+        # election_id - The local election identifier
+        def initialize(election_id)
+          @election_id = election_id
+        end
+
+        # Returns the message_id related to the operation
+        def message_id
+          @message_id ||= build_message_id(unique_election_id(election_id), "publish_results")
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid and the query operation is successful.
+        # - :error if query operation was not successful.
+        #
+        # Returns nothing.
+        def call
+          # arguments used inside the graphql operation
+          args = {
+            message_id: message_id,
+            signed_data: sign_message(message_id, {})
+          }
+
+          response = client.query do
+            mutation do
+              publishResults(messageId: args[:message_id], signedData: args[:signed_data]) do
+                election do
+                  status
+                end
+                error
+              end
+            end
+          end
+
+          return broadcast(:error, response.data.publish_results.error) if response.data.publish_results.error.present?
+
+          broadcast(:ok, response.data.publish_results.election)
+        rescue Graphlient::Errors::ServerError
+          broadcast(:error, "Sorry, something went wrong")
+        end
+
+        private
+
+        attr_reader :election_id
+      end
+    end
+  end
+end

data/lib/decidim/bulletin_board/authority/start_key_ceremony.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Decidim
+  module BulletinBoard
+    module Authority
+      # This command uses the GraphQL client to request the starting of the key ceremony.
+      class StartKeyCeremony < Decidim::BulletinBoard::Command
+        # Public: Initializes the command.
+        #
+        # election_id - The local election identifier
+        def initialize(election_id)
+          @election_id = election_id
+        end
+
+        # Returns the message_id related to the operation
+        def message_id
+          @message_id ||= build_message_id(unique_election_id(election_id), "start_key_ceremony")
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid and the query operation is successful.
+        # - :error if query operation was not successful.
+        #
+        # Returns nothing.
+        def call
+          # arguments used inside the graphql operation
+          args = {
+            message_id: message_id,
+            signed_data: sign_message(message_id, {})
+          }
+
+          response = client.query do
+            mutation do
+              startKeyCeremony(messageId: args[:message_id], signedData: args[:signed_data]) do
+                pendingMessage do
+                  status
+                end
+                error
+              end
+            end
+          end
+
+          return broadcast(:error, response.data.start_key_ceremony.error) if response.data.start_key_ceremony.error.present?
+
+          broadcast(:ok, response.data.start_key_ceremony.pending_message)
+        rescue Graphlient::Errors::FaradayServerError
+          broadcast(:error, "Sorry, something went wrong")
+        end
+
+        private
+
+        attr_reader :election_id
+      end
+    end
+  end
+end

data/lib/decidim/bulletin_board/authority/start_tally.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Decidim
+  module BulletinBoard
+    module Authority
+      # This command uses the GraphQL client to start the tally process.
+      class StartTally < Decidim::BulletinBoard::Command
+        # Public: Initializes the command.
+        #
+        # election_id - The local election identifier
+        def initialize(election_id)
+          @election_id = election_id
+        end
+
+        # Returns the message_id related to the operation
+        def message_id
+          @message_id ||= build_message_id(unique_election_id(election_id), "start_tally")
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid and the query operation is successful.
+        # - :error if query operation was not successful.
+        #
+        # Returns nothing.
+        def call
+          # arguments used inside the graphql operation
+          args = {
+            message_id: message_id,
+            signed_data: sign_message(message_id, {})
+          }
+
+          response = client.query do
+            mutation do
+              startTally(messageId: args[:message_id], signedData: args[:signed_data]) do
+                pendingMessage do
+                  status
+                end
+                error
+              end
+            end
+          end
+
+          return broadcast(:error, response.data.start_tally.error) if response.data.start_tally.error.present?
+
+          broadcast(:ok, response.data.start_tally.pending_message)
+        rescue Graphlient::Errors::ServerError
+          broadcast(:error, "Sorry, something went wrong")
+        end
+
+        private
+
+        attr_reader :election_id
+      end
+    end
+  end
+end

data/lib/decidim/bulletin_board/authority/start_vote.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Decidim
+  module BulletinBoard
+    module Authority
+      # This command uses the GraphQL client to request the starting of the voting period.
+      class StartVote < Decidim::BulletinBoard::Command
+        # Public: Initializes the command.
+        #
+        # election_id - The local election identifier
+        def initialize(election_id)
+          @election_id = election_id
+        end
+
+        # Returns the message_id related to the operation
+        def message_id
+          @message_id ||= build_message_id(unique_election_id(election_id), "start_vote")
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid and the query operation is successful.
+        # - :error if query operation was not successful.
+        #
+        # Returns nothing.
+        def call
+          # arguments used inside the graphql operation
+          args = {
+            message_id: message_id,
+            signed_data: sign_message(message_id, {})
+          }
+
+          response = client.query do
+            mutation do
+              startVote(messageId: args[:message_id], signedData: args[:signed_data]) do
+                pendingMessage do
+                  status
+                end
+                error
+              end
+            end
+          end
+
+          return broadcast(:error, response.data.start_vote.error) if response.data.start_vote.error.present?
+
+          broadcast(:ok, response.data.start_vote.pending_message)
+        rescue Graphlient::Errors::FaradayServerError
+          broadcast(:error, "Sorry, something went wrong")
+        end
+
+        private
+
+        attr_reader :election_id
+      end
+    end
+  end
+end

data/lib/decidim/bulletin_board/client.rb

@@ -21,9 +21,7 @@ module Decidim
       delegate :authority_slug, to: Decidim::BulletinBoard::Command
 
       def quorum
-        return 0 if @scheme.dig(:parameters, :quorum).blank?
-
-        @scheme.dig(:parameters, :quorum)
+        @scheme.dig(:parameters, :quorum) || number_of_trustees
       end
 
       def public_key
@@ -36,37 +34,72 @@ module Decidim
 
       def create_election(election_id, election_data)
         create_election = Decidim::BulletinBoard::Authority::CreateElection.new(election_id, election_data)
+        yield create_election.message_id if block_given?
         create_election.on(:ok) { |election| return election }
         create_election.on(:error) { |error_message| raise StandardError, error_message }
         create_election.call
       end
 
-      def open_ballot_box(election_id)
-        open_ballot_box = Decidim::BulletinBoard::Authority::OpenBallotBox.new(election_id)
-        open_ballot_box.on(:ok) { |election| return election }
-        open_ballot_box.on(:error) { |error_message| raise StandardError, error_message }
-        open_ballot_box.call
+      def start_key_ceremony(election_id)
+        start_key_ceremony = Decidim::BulletinBoard::Authority::StartKeyCeremony.new(election_id)
+        yield start_key_ceremony.message_id if block_given?
+        start_key_ceremony.on(:ok) { |pending_message| return pending_message }
+        start_key_ceremony.on(:error) { |error_message| raise StandardError, error_message }
+        start_key_ceremony.call
       end
 
-      def close_ballot_box(election_id)
-        close_ballot_box = Decidim::BulletinBoard::Authority::CloseBallotBox.new(election_id)
-        close_ballot_box.on(:ok) { |election| return election }
-        close_ballot_box.on(:error) { |error_message| raise StandardError, error_message }
-        close_ballot_box.call
+      def start_vote(election_id)
+        start_vote = Decidim::BulletinBoard::Authority::StartVote.new(election_id)
+        yield start_vote.message_id if block_given?
+        start_vote.on(:ok) { |pending_message| return pending_message }
+        start_vote.on(:error) { |error_message| raise StandardError, error_message }
+        start_vote.call
       end
 
       def cast_vote(election_id, voter_id, encrypted_vote)
         cast_vote = Decidim::BulletinBoard::Voter::CastVote.new(election_id, voter_id, encrypted_vote)
+        yield cast_vote.message_id if block_given?
         cast_vote.on(:ok) { |pending_message| return pending_message }
         cast_vote.on(:error) { |error_message| raise StandardError, error_message }
         cast_vote.call
       end
 
-      def get_status(election_id)
-        get_status = Decidim::BulletinBoard::Authority::GetElectionStatus.new(election_id)
-        get_status.on(:ok) { |status| return status }
-        get_status.on(:error) { |error_message| raise StandardError, error_message }
-        get_status.call
+      def get_pending_message_status(message_id)
+        get_pending_message_status = Decidim::BulletinBoard::Voter::GetPendingMessageStatus.new(message_id)
+        get_pending_message_status.on(:ok) { |status| return status }
+        get_pending_message_status.on(:error) { |error_message| raise StandardError, error_message }
+        get_pending_message_status.call
+      end
+
+      def end_vote(election_id)
+        end_vote = Decidim::BulletinBoard::Authority::EndVote.new(election_id)
+        yield end_vote.message_id if block_given?
+        end_vote.on(:ok) { |pending_message| return pending_message }
+        end_vote.on(:error) { |error_message| raise StandardError, error_message }
+        end_vote.call
+      end
+
+      def get_election_status(election_id)
+        get_election_status = Decidim::BulletinBoard::Authority::GetElectionStatus.new(election_id)
+        get_election_status.on(:ok) { |status| return status }
+        get_election_status.on(:error) { |error_message| raise StandardError, error_message }
+        get_election_status.call
+      end
+
+      def start_tally(election_id)
+        start_tally = Decidim::BulletinBoard::Authority::StartTally.new(election_id)
+        yield start_tally.message_id if block_given?
+        start_tally.on(:ok) { |pending_message| return pending_message }
+        start_tally.on(:error) { |error_message| raise StandardError, error_message }
+        start_tally.call
+      end
+
+      def publish_results(election_id)
+        publish_results = Decidim::BulletinBoard::Authority::PublishResults.new(election_id)
+        yield publish_results.message_id if block_given?
+        publish_results.on(:ok) { |status| return status }
+        publish_results.on(:error) { |error_message| raise StandardError, error_message }
+        publish_results.call
       end
 
       private