auction_fun_core 0.8.5 → 0.8.9

data/lib/auction_fun_core/operations/auction_context/processor/finish/closed_operation.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    module AuctionContext
+      module Processor
+        module Finish
+          ##
+          # Operation class for finalizing a closed auction.
+          # By default, this changes the auction status from 'running' to 'finished'.
+          #
+          class ClosedOperation < AuctionFunCore::Operations::Base
+            include Import["repos.auction_context.auction_repository"]
+            include Import["contracts.auction_context.processor.finish.closed_contract"]
+            include Import["workers.operations.auction_context.post_auction.winner_operation_job"]
+            include Import["workers.operations.auction_context.post_auction.participant_operation_job"]
+
+            ##
+            # Executes the closed operation with the provided attributes.
+            #
+            # @param attributes [Hash] The attributes for the closed operation.
+            # @option attributes auction_id [Integer] The ID of the auction.
+            # @yield [Dry::Matcher::Evaluator] The block to handle the result of the operation.
+            # @return [Dry::Matcher::Evaluator] The result of the operation.
+            #
+            # @example
+            #   attributes = { auction_id: 123 }
+            #
+            #   AuctionFunCore::Operations::AuctionContext::Processor::Finish::ClosedOperation.call(attributes) do |result|
+            #     result.success { |auction| puts "Finished closed auction sucessfully! #{auction.to_h}" }
+            #     result.failure { |failure| puts "Failed to finished closed auction: #{failure.errors.to_h}"}
+            #   end
+            def self.call(attributes, &block)
+              operation = new.call(attributes)
+
+              return operation unless block
+
+              Dry::Matcher::ResultMatcher.call(operation, &block)
+            end
+
+            ##
+            # Performs the closing of a closed auction.
+            #
+            # @param attributes [Hash] The attributes for the closed operation.
+            # @option attributes auction_id [Integer] The ID of the auction.
+            # @return [Dry::Monads::Result] The result of the operation.
+            #
+            # @example
+            #   attributes = { auction_id: 123 }
+            #
+            #   operation = AuctionFunCore::Operations::AuctionContext::Processor::Finish::ClosedOperation.call(attributes)
+            #
+            #   if operation.success?
+            #     auction = operation.success
+            #     puts "Finished closed auction sucessfully! #{auction.to_h}"
+            #   end
+            #
+            #   if operation.failure?
+            #     failure = operation.failure
+            #     puts "Failed to finished closed auction: #{failure.errors.to_h}"
+            #   end
+            def call(attributes)
+              auction = yield validate_contract(attributes)
+              summary = yield load_closed_auction_winners_and_participants(auction.id)
+              update_auction_attributes = yield update_finished_auction(auction, summary)
+
+              auction_repository.transaction do |_t|
+                auction, _ = auction_repository.update(auction.id, update_auction_attributes)
+
+                yield winner_operation(auction.id, summary.winner_id)
+
+                summary.participant_ids.each do |participant_id|
+                  yield participant_operation(auction.id, participant_id)
+                end
+
+                publish_auction_finish_event(auction)
+              end
+
+              Success(auction)
+            end
+
+            private
+
+            ##
+            # Validates the contract with the provided attributes.
+            #
+            # @param attributes [Hash] The attributes to validate.
+            # @option auction_id [Integer] The ID of the auction.
+            # @return [Dry::Monads::Result] The result of the validation.
+            #
+            def validate_contract(attributes)
+              contract = closed_contract.call(attributes)
+
+              return Failure(contract.errors.to_h) if contract.failure?
+
+              Success(contract.context[:auction])
+            end
+
+            ##
+            # Loads the winners and participants of the closed auction.
+            #
+            # @param auction_id [Integer] The ID of the auction.
+            # @return [Dry::Monads::Result] The result of loading the winners and participants.
+            #
+            def load_closed_auction_winners_and_participants(auction_id)
+              summary = relation.load_closed_auction_winners_and_participants(auction_id).first
+
+              Success(summary)
+            end
+
+            ##
+            # Updates the attributes of the finished auction.
+            #
+            # @param auction [Auction] The auction object.
+            # @param summary [Summary] The summary of winners and participants.
+            # @return [Dry::Monads::Result] The result of updating the attributes.
+            #
+            def update_finished_auction(auction, summary)
+              attrs = {status: "finished"}
+              attrs[:winner_id] = summary.winner_id if summary.winner_id.present?
+
+              Success(attrs)
+            end
+
+            ##
+            # Retrieves the relation.
+            #
+            # @return [ROM::Relation] The relation object.
+            #
+            def relation
+              AuctionFunCore::Application[:container].relations[:auctions]
+            end
+
+            ##
+            # Executes the winner operation asynchronously.
+            #
+            # @param auction_id [Integer] The ID of the auction.
+            # @param winner_id [Integer] The ID of the winner.
+            # @return [Dry::Monads::Result] The result of executing the operation.
+            #
+            def winner_operation(auction_id, winner_id)
+              return Success() if winner_id.blank?
+
+              Success(winner_operation_job.class.perform_async(auction_id, winner_id))
+            end
+
+            ##
+            # Executes the participant operation asynchronously.
+            #
+            # @param auction_id [Integer] The ID of the auction.
+            # @param participant_id [Integer] The ID of the participant.
+            # @return [Dry::Monads::Result] The result of executing the operation.
+            #
+            def participant_operation(auction_id, participant_id)
+              Success(participant_operation_job.class.perform_async(auction_id, participant_id))
+            end
+
+            ##
+            # Publishes the auction finish event.
+            #
+            # @param auction [ROM::Struct::Auction] The auction object.
+            # @return [void]
+            #
+            def publish_auction_finish_event(auction)
+              Application[:event].publish("auctions.finished", auction.to_h)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/operations/auction_context/processor/finish/penny_operation.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    module AuctionContext
+      module Processor
+        module Finish
+          ##
+          # Operation class for finalizing a penny auction.
+          # By default, this changes the auction status from 'running' to 'finished'.
+          #
+          class PennyOperation < AuctionFunCore::Operations::Base
+            include Import["repos.auction_context.auction_repository"]
+            include Import["contracts.auction_context.processor.finish.penny_contract"]
+            include Import["workers.operations.auction_context.post_auction.winner_operation_job"]
+            include Import["workers.operations.auction_context.post_auction.participant_operation_job"]
+
+            ##
+            # Executes the penny operation with the provided attributes.
+            #
+            # @param attributes [Hash] The attributes for the penny operation.
+            # @option attributes auction_id [Integer] The ID of the auction.
+            # @yield [Dry::Matcher::Evaluator] The block to handle the result of the operation.
+            # @return [Dry::Matcher::Evaluator] The result of the operation.
+            #
+            # @example
+            #   attributes = { auction_id: 123 }
+            #
+            #   AuctionFunCore::Operations::AuctionContext::Processor::Finish::PennyOperation.call(attributes) do |result|
+            #     result.success { |auction| puts "Finished penny auction sucessfully! #{auction.to_h}" }
+            #     result.failure { |failure| puts "Failed to finished penny auction: #{failure.errors.to_h}"}
+            #   end
+            def self.call(attributes, &block)
+              operation = new.call(attributes)
+
+              return operation unless block
+
+              Dry::Matcher::ResultMatcher.call(operation, &block)
+            end
+
+            ##
+            # Performs the closing of a penny auction.
+            #
+            # @param attributes [Hash] The attributes for the penny operation.
+            # @option attributes auction_id [Integer] The ID of the auction.
+            # @return [Dry::Monads::Result] The result of the operation.
+            #
+            # @example
+            #   attributes = { auction_id: 123 }
+            #
+            #   operation = AuctionFunCore::Operations::AuctionContext::Processor::Finish::PennyOperation.call(attributes)
+            #
+            #   if operation.success?
+            #     auction = operation.success
+            #     puts "Finished penny auction sucessfully! #{auction.to_h}"
+            #   end
+            #
+            #   if operation.failure?
+            #     failure = operation.failure
+            #     puts "Failed to finished penny auction: #{failure.errors.to_h}"
+            #   end
+            def call(attributes)
+              auction = yield validate_contract(attributes)
+              summary = yield load_penny_auction_winners_and_participants(auction.id)
+              update_auction_attributes = yield update_finished_auction(auction, summary)
+
+              auction_repository.transaction do |_t|
+                auction, _ = auction_repository.update(auction.id, update_auction_attributes)
+
+                yield winner_operation(auction.id, summary.winner_id)
+
+                summary.participant_ids.each do |participant_id|
+                  yield participant_operation(auction.id, participant_id)
+                end
+
+                publish_auction_finish_event(auction)
+              end
+
+              Success(auction)
+            end
+
+            private
+
+            ##
+            # Validates the contract with the provided attributes.
+            #
+            # @param attributes [Hash] The attributes to validate.
+            # @return [Dry::Monads::Result] The result of the validation.
+            #
+            def validate_contract(attributes)
+              contract = penny_contract.call(attributes)
+
+              return Failure(contract.errors.to_h) if contract.failure?
+
+              Success(contract.context[:auction])
+            end
+
+            ##
+            # Loads the winners and participants of the penny auction.
+            #
+            # @param auction_id [Integer] The ID of the auction.
+            # @return [Dry::Monads::Result] The result of loading the winners and participants.
+            #
+            def load_penny_auction_winners_and_participants(auction_id)
+              summary = relation.load_penny_auction_winners_and_participants(auction_id).first
+
+              Success(summary)
+            end
+
+            ##
+            # Updates the attributes of the finished auction.
+            #
+            # @param auction [ROM::Struct::Auction] The auction object.
+            # @param summary [ROM::OpenStruct] The summary of winners and participants.
+            # @return [Dry::Monads::Result] The result of updating the attributes.
+            #
+            def update_finished_auction(auction, summary)
+              attrs = {status: "finished"}
+              attrs[:winner_id] = summary.winner_id if summary.winner_id.present?
+
+              Success(attrs)
+            end
+
+            ##
+            # Retrieves the relation.
+            #
+            # @return [ROM::Relation] The relation object.
+            #
+            def relation
+              AuctionFunCore::Application[:container].relations[:auctions]
+            end
+
+            ##
+            # Executes the winner operation asynchronously.
+            #
+            # @param auction_id [Integer] The ID of the auction.
+            # @param winner_id [Integer] The ID of the winner.
+            # @return [Dry::Monads::Result] The result of executing the operation.
+            #
+            def winner_operation(auction_id, winner_id)
+              return Success() if winner_id.blank?
+
+              Success(winner_operation_job.class.perform_async(auction_id, winner_id))
+            end
+
+            ##
+            # Executes the participant operation asynchronously.
+            #
+            # @param auction_id [Integer] The ID of the auction.
+            # @param participant_id [Integer] The ID of the participant.
+            # @return [Dry::Monads::Result] The result of executing the operation.
+            #
+            def participant_operation(auction_id, participant_id)
+              Success(participant_operation_job.class.perform_async(auction_id, participant_id))
+            end
+
+            ##
+            # Publishes the auction finish event.
+            #
+            # @param auction [ROM::Struct::Auction] The auction object.
+            # @return [void]
+            #
+            def publish_auction_finish_event(auction)
+              Application[:event].publish("auctions.finished", auction.to_h)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/operations/auction_context/processor/finish/standard_operation.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    module AuctionContext
+      module Processor
+        module Finish
+          ##
+          # Operation class for finalizing a standard auction.
+          # By default, this changes the auction status from 'running' to 'finished'.
+          #
+          class StandardOperation < AuctionFunCore::Operations::Base
+            include Import["repos.auction_context.auction_repository"]
+            include Import["contracts.auction_context.processor.finish.standard_contract"]
+            include Import["workers.operations.auction_context.post_auction.winner_operation_job"]
+            include Import["workers.operations.auction_context.post_auction.participant_operation_job"]
+
+            ##
+            # Executes the standard operation with the provided attributes.
+            #
+            # @param attributes [Hash] The attributes for the standard operation.
+            # @option attributes auction_id [Integer] The ID of the auction.
+            # @yield [Dry::Matcher::Evaluator] The block to handle the result of the operation.
+            # @return [Dry::Matcher::Evaluator] The result of the operation.
+            #
+            # @example
+            #   attributes = { auction_id: 123 }
+            #
+            #   AuctionFunCore::Operations::AuctionContext::Processor::Finish::StandardOperation.call(attributes) do |result|
+            #     result.success { |auction| puts "Finished standard auction sucessfully! #{auction.to_h}" }
+            #     result.failure { |failure| puts "Failed to finished standard auction: #{failure.errors.to_h}"}
+            #   end
+            def self.call(attributes, &block)
+              operation = new.call(attributes)
+
+              return operation unless block
+
+              Dry::Matcher::ResultMatcher.call(operation, &block)
+            end
+
+            ##
+            # Performs the closing of a standard auction.
+            #
+            # @param attributes [Hash] The attributes for the standard operation.
+            # @option attributes auction_id [Integer] The ID of the auction.
+            # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure] The result of the operation.
+            #
+            # @example
+            #   attributes = { auction_id: 123 }
+            #
+            #   operation = AuctionFunCore::Operations::AuctionContext::Processor::Finish::StandardOperation.call(attributes)
+            #
+            #   if operation.success?
+            #     auction = operation.success
+            #     puts "Finished standard auction sucessfully! #{auction.to_h}"
+            #   end
+            #
+            #   if operation.failure?
+            #     failure = operation.failure
+            #     puts "Failed to finished standard auction: #{failure.errors.to_h}"
+            #   end
+            def call(attributes)
+              auction = yield validate_contract(attributes)
+              summary = yield load_standard_auction_winners_and_participants(auction.id)
+              update_auction_attributes = yield update_finished_auction(auction, summary)
+
+              auction_repository.transaction do |_t|
+                auction, _ = auction_repository.update(auction.id, update_auction_attributes)
+
+                yield winner_operation(auction.id, summary.winner_id)
+
+                summary.participant_ids.each do |participant_id|
+                  yield participant_operation(auction.id, participant_id)
+                end
+
+                publish_auction_finish_event(auction)
+              end
+
+              Success(auction)
+            end
+
+            private
+
+            ##
+            # Validates the contract with the provided attributes.
+            #
+            # @param attributes [Hash] The attributes to validate.
+            # @return [Dry::Monads::Result] The result of the validation.
+            #
+            def validate_contract(attributes)
+              contract = standard_contract.call(attributes)
+
+              return Failure(contract.errors.to_h) if contract.failure?
+
+              Success(contract.context[:auction])
+            end
+
+            ##
+            # Loads the winners and participants of the standard auction.
+            #
+            # @param auction_id [Integer] The ID of the auction.
+            # @return [Dry::Monads::Result] The result of loading the winners and participants.
+            #
+            def load_standard_auction_winners_and_participants(auction_id)
+              summary = relation.load_standard_auction_winners_and_participants(auction_id).first
+
+              Success(summary)
+            end
+
+            ##
+            # Updates the attributes of the finished auction.
+            #
+            # @param auction [Auction] The auction object.
+            # @param summary [Summary] The summary of winners and participants.
+            # @return [Dry::Monads::Result] The result of updating the attributes.
+            #
+            def update_finished_auction(auction, summary)
+              attrs = {status: "finished"}
+              attrs[:winner_id] = summary.winner_id if summary.winner_id.present?
+
+              Success(attrs)
+            end
+
+            ##
+            # Retrieves the relation.
+            #
+            # @return [ROM::Relation] The relation object.
+            #
+            def relation
+              AuctionFunCore::Application[:container].relations[:auctions]
+            end
+
+            ##
+            # Executes the winner operation asynchronously.
+            #
+            # @param auction_id [Integer] The ID of the auction.
+            # @param winner_id [Integer] The ID of the winner.
+            # @return [Dry::Monads::Result] The result of executing the operation.
+            #
+            def winner_operation(auction_id, winner_id)
+              return Success() if winner_id.blank?
+
+              Success(winner_operation_job.class.perform_async(auction_id, winner_id))
+            end
+
+            ##
+            # Executes the participant operation asynchronously.
+            #
+            # @param auction_id [Integer] The ID of the auction.
+            # @param participant_id [Integer] The ID of the participant.
+            # @return [Dry::Monads::Result] The result of executing the operation.
+            #
+            def participant_operation(auction_id, participant_id)
+              Success(participant_operation_job.class.perform_async(auction_id, participant_id))
+            end
+
+            ##
+            # Publishes the auction finish event.
+            #
+            # @param auction [ROM::Struct::Auction] The auction object.
+            # @return [void]
+            #
+            def publish_auction_finish_event(auction)
+              Application[:event].publish("auctions.finished", auction.to_h)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/operations/auction_context/processor/pause_operation.rb

@@ -12,7 +12,21 @@ module AuctionFunCore
           include Import["repos.auction_context.auction_repository"]
           include Import["contracts.auction_context.processor.pause_contract"]
 
-          # @todo Add custom doc
+          ##
+          # Executes the pause operation with the provided attributes.
+          #
+          # @param attributes [Hash] The attributes for the pause operation.
+          # @option attributes auction_id [Integer] The ID of the auction.
+          # @yield [Dry::Matcher::Evaluator] The block to handle the result of the operation.
+          # @return [Dry::Matcher::Evaluator] The result of the operation.
+          #
+          # @example
+          #   attributes = { auction_id: 123 }
+          #
+          #   AuctionFunCore::Operations::AuctionContext::Processor::PauseOperation.call(attributes) do |result|
+          #     result.success { |auction| puts "Paused auction sucessfully! #{auction.to_h}" }
+          #     result.failure { |failure| puts "Failed to pause auction: #{failure.errors.to_h}"}
+          #   end
           def self.call(attributes, &block)
             operation = new.call(attributes)
 
@@ -21,6 +35,27 @@ module AuctionFunCore
             Dry::Matcher::ResultMatcher.call(operation, &block)
           end
 
+          ##
+          # Performing an auction pause
+          #
+          # @param attributes [Hash] The attributes for the pause operation.
+          # @option attributes auction_id [Integer] The ID of the auction.
+          # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure] The result of the operation.
+          #
+          # @example
+          #   attributes = { auction_id: 123 }
+          #
+          #   operation = AuctionFunCore::Operations::AuctionContext::Processor::PauseOperation.call(attributes)
+          #
+          #   if operation.success?
+          #     auction = operation.success
+          #     puts "Paused auction sucessfully! #{auction.to_h}"
+          #   end
+          #
+          #   if operation.failure?
+          #     failure = operation.failure
+          #     puts "Failed to pause auction: #{failure.errors.to_h}"
+          #   end
           def call(attributes)
             attrs = yield validate(attributes)
 

data/lib/auction_fun_core/operations/auction_context/processor/start_operation.rb

@@ -11,7 +11,9 @@ module AuctionFunCore
         class StartOperation < AuctionFunCore::Operations::Base
           include Import["repos.auction_context.auction_repository"]
           include Import["contracts.auction_context.processor.start_contract"]
-          include Import["workers.operations.auction_context.processor.finish_operation_job"]
+          include Import["workers.operations.auction_context.processor.finish.closed_operation_job"]
+          include Import["workers.operations.auction_context.processor.finish.penny_operation_job"]
+          include Import["workers.operations.auction_context.processor.finish.standard_operation_job"]
 
           # @todo Add custom doc
           def self.call(attributes, &block)
@@ -28,10 +30,10 @@ module AuctionFunCore
           # @option opts [Integer] :stopwatch auction stopwatch
           # @return [ROM::Struct::Auction] auction object
           def call(attributes)
-            attrs = yield validate(attributes)
+            auction, attrs = yield validate_contract(attributes)
 
             auction_repository.transaction do |_t|
-              @auction, _ = auction_repository.update(attrs[:auction_id], update_params(attrs))
+              @auction, _ = auction_repository.update(auction.id, update_params(auction, attrs))
 
               yield publish_auction_start_event(@auction)
               yield scheduled_finished_auction(@auction)
@@ -46,36 +48,46 @@ module AuctionFunCore
           # of the informed attributes.
           # @param attributes [Hash] auction attributes
           # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
-          def validate(attributes)
+          def validate_contract(attributes)
             contract = start_contract.call(attributes)
 
             return Failure(contract.errors.to_h) if contract.failure?
 
-            Success(contract.to_h)
+            Success([contract.context[:auction], contract.to_h])
           end
 
           # Updates the status of the auction and depending on the type of auction,
           # it already sets the final date.
           # @param attrs [Hash] auction attributes
           # @return [Hash]
-          def update_params(attrs)
-            return {status: "running"} unless attrs[:kind] == "penny"
+          def update_params(auction, attrs)
+            return {kind: auction.kind, status: "running"} unless attrs[:kind] == "penny"
 
-            {status: "running", finished_at: attrs[:stopwatch].seconds.from_now}
+            {kind: auction.kind, status: "running", finished_at: attrs[:stopwatch].seconds.from_now}
           end
 
           def publish_auction_start_event(auction)
             Success(Application[:event].publish("auctions.started", auction.to_h))
           end
 
+          # TODO: Added a small delay to perform operations (such as sending broadcasts and/or other operations).
           # Calls the background job class that will schedule the finish of the auction.
-          # Added a small delay to perform operations (such as sending broadcasts and/or other operations).
+          # In the case of the penny auction, the end of the auction occurs after the first timer resets.
           # @param auction [ROM::Struct::Auction]
           # @return [String] sidekiq jid
           def scheduled_finished_auction(auction)
-            return Success() if auction.kind == "penny"
+            perform_at = auction.finished_at
 
-            Success(finish_operation_job.class.perform_at(auction.finished_at, auction.id))
+            case auction.kind
+            in "penny"
+              perform_at = auction.started_at + auction.stopwatch.seconds
+
+              Success(penny_operation_job.class.perform_at(perform_at, auction.id))
+            in "standard"
+              Success(standard_operation_job.class.perform_at(perform_at, auction.id))
+            in "closed"
+              Success(closed_operation_job.class.perform_at(perform_at, auction.id))
+            end
           end
         end
       end