auction_fun_core 0.8.5

data/lib/auction_fun_core/contracts/user_context/phone_confirmation_contract.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Contracts
+    module UserContext
+      # Contract class responsible for validating the confirmation token for phone number.
+      class PhoneConfirmationContract < ApplicationContract
+        I18N_SCOPE = "contracts.errors.custom.default"
+
+        option :user_repository, default: proc { Repos::UserContext::UserRepository.new }
+
+        params do
+          required(:phone_confirmation_token)
+
+          before(:value_coercer) do |result|
+            result.to_h.compact
+          end
+        end
+
+        # Validation for token_confirmation_token.
+        # Searches for the user in the database from the phone_confirmation_token
+        rule do |context:|
+          next if schema_error?(:phone_confirmation_token)
+
+          context[:user] ||= user_repository.by_phone_confirmation_token(values[:phone_confirmation_token])
+
+          next if context[:user].present?
+
+          key(:phone_confirmation_token).failure(I18n.t("not_found", scope: I18N_SCOPE))
+        end
+
+        rule do |context:|
+          next if context[:user].blank? || context[:user].active?
+
+          key(:base).failure(I18n.t("inactive_account", scope: I18N_SCOPE))
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/contracts/user_context/registration_contract.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Contracts
+    module UserContext
+      # Contract class to create new users.
+      class RegistrationContract < ApplicationContract
+        I18N_SCOPE = "contracts.errors.custom.default"
+
+        option :user_repository, default: proc { Repos::UserContext::UserRepository.new }
+
+        # @param [Hash] opts Sets an allowed list of parameters, as well as some initial validations.
+        params do
+          required(:name)
+          required(:email)
+          required(:phone)
+          required(:password)
+          required(:password_confirmation)
+
+          before(:value_coercer) do |result|
+            result.to_h.compact
+          end
+
+          # Normalize and add default values
+          after(:value_coercer) do |result|
+            result.update(email: result[:email].strip.downcase) if result[:email]
+            result.update(phone: result[:phone].tr_s("^0-9", "")) if result[:phone]
+          end
+        end
+
+        rule(:name).validate(:name_format)
+
+        # Validation for email.
+        # It must validate the format and uniqueness in the database.
+        rule(:email).validate(:email_format)
+        rule(:email) do
+          # Email should be unique on database
+          if !rule_error?(:email) && user_repository.exists?(email: value)
+            key.failure(I18n.t(:taken, scope: I18N_SCOPE))
+          end
+        end
+
+        # Validation for phone.
+        # It must validate the format and uniqueness in the database.
+        rule(:phone).validate(:phone_format)
+        rule(:phone) do
+          if !rule_error?(:phone) && user_repository.exists?(phone: value)
+            key.failure(I18n.t(:taken, scope: I18N_SCOPE))
+          end
+        end
+
+        # Validation for password.
+        # Check if the confirmation matches the password.
+        rule(:password).validate(:password_format)
+        rule(:password, :password_confirmation) do
+          if !rule_error?(:password) && values[:password] != values[:password_confirmation]
+            key(:password_confirmation).failure(I18n.t(:password_confirmation, scope: I18N_SCOPE))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/entities/auction.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Entities
+    # Auction Relations class. This return simple objects with attribute readers
+    # to represent data in your auction.
+    class Auction < ROM::Struct
+      def initial_bid
+        Money.new(initial_bid_cents, initial_bid_currency)
+      end
+
+      def minimal_bid
+        Money.new(minimal_bid_cents, minimal_bid_currency)
+      end
+    end
+  end
+end

data/lib/auction_fun_core/entities/bid.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Entities
+    # Bid Relations class. This return simple objects with attribute readers
+    # to represent data in your bid.
+    class Bid < ROM::Struct
+    end
+  end
+end

data/lib/auction_fun_core/entities/staff.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Entities
+    # Staff Relations class. This return simple objects with attribute readers
+    # to represent data in your staff.
+    class Staff < ROM::Struct
+      def active?
+        active
+      end
+
+      def inactive?
+        !active
+      end
+
+      def info
+        attributes.except(:password_digest)
+      end
+    end
+  end
+end

data/lib/auction_fun_core/entities/user.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Entities
+    # User Relations class. This return simple objects with attribute readers
+    # to represent data in your user.
+    class User < ROM::Struct
+      def active?
+        active
+      end
+
+      def inactive?
+        !active
+      end
+
+      def confirmed?
+        confirmed_at.present?
+      end
+
+      def email_confirmed?
+        email_confirmation_at.present?
+      end
+
+      def phone_confirmed?
+        phone_confirmation_at.present?
+      end
+
+      def info
+        attributes.except(:password_digest)
+      end
+
+      def balance
+        Money.new(balance_cents, balance_currency)
+      end
+    end
+  end
+end

data/lib/auction_fun_core/events/app.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Events
+    # Event class to register business events on system.
+    # @see https://dry-rb.org/gems/dry-events/main/
+    class App
+      # @!parser include Dry::Events::Publisher[:app]
+      include Dry::Events::Publisher[:app]
+
+      register_event("auctions.created")
+      register_event("auctions.started")
+      register_event("auctions.finished")
+      register_event("auctions.paused")
+      register_event("auctions.unpaused")
+
+      register_event("bids.created")
+
+      register_event("staffs.authentication")
+      register_event("staffs.registration")
+
+      register_event("users.authentication")
+      register_event("users.registration")
+      register_event("users.confirmation")
+    end
+  end
+end

data/lib/auction_fun_core/events/listener.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Events
+    # Event class that can listen business events.
+    # @see https://dry-rb.org/gems/dry-events/main/#event-listeners
+    class Listener
+      # Listener for to *auctions.created* event.
+      # @param auction [ROM::Struct::Auction] the auction object
+      def on_auctions_created(auction)
+        logger("Create auction with: #{auction.to_h}")
+      end
+
+      # Listener for to *auctions.started* event.
+      # @param auction [ROM::Struct::Auction] the auction object
+      def on_auctions_started(auction)
+        logger("Started auction with: #{auction.to_h}")
+      end
+
+      # Listener for to *auctions.finished* event.
+      # @param auction [ROM::Struct::Auction] the auction object
+      def on_auctions_finished(auction)
+        logger("Finished auction: #{auction.to_h}")
+      end
+
+      # Listener for to *auctions.paused* event.
+      # @param event [ROM::Struct::Auction] the auction object
+      def on_auctions_paused(auction)
+        logger("Paused auction with: #{auction.to_h}")
+      end
+
+      # Listener for to *auctions.unpaused* event.
+      # @param event [ROM::Struct::Auction] the auction object
+      def on_auctions_unpaused(auction)
+        logger("Unpaused auction with: #{auction.to_h}")
+      end
+
+      # Listener for to *bids.created* event.
+      # @param event [Integer] Auction ID
+      def on_bids_created(bid)
+        logger("Create bid with: #{bid.to_h}")
+      end
+
+      # Listener for to *staffs.authentication* event.
+      # @param attributes [Hash] Authentication attributes
+      # @option staff_id [Integer] Staff ID
+      # @option time [DateTime] Authentication time
+      def on_staffs_authentication(attributes)
+        logger("Staff #{attributes[:staff_id]} authenticated on: #{attributes[:time].iso8601}")
+      end
+
+      # Listener for to *staffs.registration* event.
+      # @param user [ROM::Struct::Staff] the staff object
+      def on_staffs_registration(staff)
+        logger("New registered staff: #{staff.to_h}")
+      end
+
+      # Listener for to *users.registration* event.
+      # @param user [ROM::Struct::User] the user object
+      def on_users_registration(user)
+        logger("New registered user: #{user.to_h}")
+      end
+
+      # Listener for to *users.authentication* event.
+      # @param attributes [Hash] Authentication attributes
+      # @option user_id [Integer] User ID
+      # @option time [DateTime] Authentication time
+      def on_users_authentication(attributes)
+        logger("User #{attributes[:user_id]} authenticated on: #{attributes[:time].iso8601}")
+      end
+
+      # Listener for to *users.confirmation* event.
+      # @param attributes [Hash] Confirmation attributes
+      # @option user_id [Integer] User ID
+      # @option time [DateTime] Authentication time
+      def on_users_confirmation(attributes)
+        logger("User #{attributes[:user_id]} confirmed at: #{attributes[:time].iso8601}")
+      end
+
+      private
+
+      # Append message to system log.
+      # @param message [String] the message
+      def logger(message)
+        Application[:logger].info(message)
+      end
+    end
+  end
+end

data/lib/auction_fun_core/operations/auction_context/create_operation.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    module AuctionContext
+      ##
+      # Operation class for creating auctions.
+      #
+      class CreateOperation < AuctionFunCore::Operations::Base
+        include Import["repos.auction_context.auction_repository"]
+        include Import["contracts.auction_context.create_contract"]
+        include Import["workers.operations.auction_context.processor.start_operation_job"]
+
+        # @todo Add custom doc
+        def self.call(attributes, &block)
+          operation = new.call(attributes)
+
+          return operation unless block
+
+          Dry::Matcher::ResultMatcher.call(operation, &block)
+        end
+
+        def call(attributes)
+          values = yield validate(attributes)
+
+          auction_repository.transaction do |_t|
+            @auction = yield persist(values)
+            yield scheduled_start_auction(@auction)
+            yield publish_auctions_created(@auction)
+          end
+
+          Success(@auction)
+        end
+
+        private
+
+        # Calls the auction creation contract class to perform the validation
+        # of the informed attributes.
+        # @param attrs [Hash] auction attributes
+        # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+        def validate(attrs)
+          contract = create_contract.call(attrs)
+
+          return Failure(contract.errors.to_h) if contract.failure?
+
+          Success(contract.to_h)
+        end
+
+        # Calls the auction repository class to persist the attributes in the database.
+        # @param result [Hash] Auction validated attributes
+        # @return [ROM::Struct::Auction]
+        def persist(result)
+          Success(auction_repository.create(result))
+        end
+
+        # Triggers the publication of event *auctions.created*.
+        # @param auction [Hash] Auction persisted attributes
+        # @return [Dry::Monads::Result::Success]
+        def publish_auctions_created(auction)
+          Application[:event].publish("auctions.created", auction.to_h)
+
+          Success()
+        end
+
+        # Calls the background job class that will schedule the start of the auction.
+        # Added a small delay to perform operations (such as sending broadcasts and/or other operations).
+        # @param auction [ROM::Struct::Auction]
+        # @return [String] sidekiq jid
+        def scheduled_start_auction(auction)
+          perform_at = auction.started_at
+
+          Success(start_operation_job.class.perform_at(perform_at, auction.id))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    module AuctionContext
+      module Processor
+        ##
+        # Operation class for dispatch finish auction.
+        # By default, this change auction status from 'running' to 'finished'.
+        #
+        class FinishOperation < AuctionFunCore::Operations::Base
+          include Import["repos.auction_context.auction_repository"]
+          include Import["contracts.auction_context.processor.finish_contract"]
+
+          # @todo Add custom doc
+          def self.call(auction_id, &block)
+            operation = new.call(auction_id)
+
+            return operation unless block
+
+            Dry::Matcher::ResultMatcher.call(operation, &block)
+          end
+
+          # It only performs the basic processing of completing an auction.
+          # It just changes the status at the database level and triggers the finished event.
+          # @param auction_id [Integer] Auction ID
+          # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+          def call(auction_id)
+            yield validate(auction_id: auction_id)
+
+            auction_repository.transaction do |_t|
+              @auction, _ = auction_repository.update(auction_id, status: "finished")
+
+              publish_auction_finish_event(@auction)
+            end
+
+            Success(@auction)
+          end
+
+          private
+
+          # Calls the finish contract class to perform the validation
+          # of the informed attributes.
+          # @param attributes [Hash] auction attributes
+          # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+          def validate(attributes)
+            contract = finish_contract.call(attributes)
+
+            return Failure(contract.errors.to_h) if contract.failure?
+
+            Success(contract.to_h)
+          end
+
+          def publish_auction_finish_event(auction)
+            Application[:event].publish("auctions.finished", auction.to_h)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    module AuctionContext
+      module Processor
+        ##
+        # Operation class for dispatch pause auction.
+        # By default, this change auction status from 'running' to 'paused'.
+        #
+        class PauseOperation < AuctionFunCore::Operations::Base
+          include Import["repos.auction_context.auction_repository"]
+          include Import["contracts.auction_context.processor.pause_contract"]
+
+          # @todo Add custom doc
+          def self.call(attributes, &block)
+            operation = new.call(attributes)
+
+            return operation unless block
+
+            Dry::Matcher::ResultMatcher.call(operation, &block)
+          end
+
+          def call(attributes)
+            attrs = yield validate(attributes)
+
+            auction_repository.transaction do |_t|
+              @auction, _ = auction_repository.update(attrs[:auction_id], status: "paused")
+
+              publish_auction_pause_event(@auction)
+            end
+
+            Success(attrs[:auction_id])
+          end
+
+          private
+
+          # Calls the finish contract class to perform the validation
+          # of the informed attributes.
+          # @param attrs [Hash] auction attributes
+          # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+          def validate(attributes)
+            contract = pause_contract.call(attributes)
+
+            return Failure(contract.errors.to_h) if contract.failure?
+
+            Success(contract.to_h)
+          end
+
+          def publish_auction_pause_event(auction)
+            Application[:event].publish("auctions.paused", auction.to_h)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    module AuctionContext
+      module Processor
+        ##
+        # Operation class for dispatch start auction.
+        # By default, this change auction status from 'scheduled' to 'running'
+        # and schedule a job to execute the auction finalization when auction is not penny.
+        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"]
+
+          # @todo Add custom doc
+          def self.call(attributes, &block)
+            operation = new.call(attributes)
+
+            return operation unless block
+
+            Dry::Matcher::ResultMatcher.call(operation, &block)
+          end
+
+          # @param [Hash] attributes needed to start a auction
+          # @option opts [String] :auction_id auction id
+          # @option opts [String] :auction_kind auction kind
+          # @option opts [Integer] :stopwatch auction stopwatch
+          # @return [ROM::Struct::Auction] auction object
+          def call(attributes)
+            attrs = yield validate(attributes)
+
+            auction_repository.transaction do |_t|
+              @auction, _ = auction_repository.update(attrs[:auction_id], update_params(attrs))
+
+              yield publish_auction_start_event(@auction)
+              yield scheduled_finished_auction(@auction)
+            end
+
+            Success(@auction)
+          end
+
+          private
+
+          # Calls the start contract class to perform the validation
+          # of the informed attributes.
+          # @param attributes [Hash] auction attributes
+          # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+          def validate(attributes)
+            contract = start_contract.call(attributes)
+
+            return Failure(contract.errors.to_h) if contract.failure?
+
+            Success(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"
+
+            {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
+
+          # 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).
+          # @param auction [ROM::Struct::Auction]
+          # @return [String] sidekiq jid
+          def scheduled_finished_auction(auction)
+            return Success() if auction.kind == "penny"
+
+            Success(finish_operation_job.class.perform_at(auction.finished_at, auction.id))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    module AuctionContext
+      module Processor
+        ##
+        # Operation class for dispatch unpause auction.
+        # By default, this change auction status from 'paused' to 'running'.
+        #
+        class UnpauseOperation < AuctionFunCore::Operations::Base
+          include Import["repos.auction_context.auction_repository"]
+          include Import["contracts.auction_context.processor.unpause_contract"]
+
+          # @todo Add custom doc
+          def self.call(attributes, &block)
+            operation = new.call(attributes)
+
+            return operation unless block
+
+            Dry::Matcher::ResultMatcher.call(operation, &block)
+          end
+
+          def call(attributes)
+            attrs = yield validate(attributes)
+
+            auction_repository.transaction do |_t|
+              @auction, _ = auction_repository.update(attrs[:auction_id], status: "running")
+
+              publish_auction_unpause_event(@auction)
+            end
+
+            Success(attrs[:auction_id])
+          end
+
+          private
+
+          # Calls the unpause contract class to perform the validation
+          # of the informed attributes.
+          # @param attrs [Hash] auction attributes
+          # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+          def validate(attributes)
+            contract = unpause_contract.call(attributes)
+
+            return Failure(contract.errors.to_h) if contract.failure?
+
+            Success(contract.to_h)
+          end
+
+          def publish_auction_unpause_event(auction)
+            Application[:event].publish("auctions.unpaused", auction.to_h)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/operations/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    # Abstract base class for operations.
+    # @abstract
+    class Base
+      include Dry::Monads[:do, :maybe, :result, :try]
+    end
+  end
+end