auction_fun_core 0.8.5

data/lib/auction_fun_core/contracts/auction_context/create_contract.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Contracts
+    module AuctionContext
+      # Contract class to create new auctions.
+      class CreateContract < Contracts::ApplicationContract
+        include AuctionFunCore::Business::Configuration
+
+        REQUIRED_FINISHED_AT = AUCTION_KINDS - ["penny"]
+
+        option :staff_repo, default: proc { Repos::StaffContext::StaffRepository.new }
+
+        # @param [Hash] opts Sets an allowed list of parameters, as well as some initial validations.
+        params do
+          required(:staff_id).filled(:integer)
+          required(:title).filled(:string, size?: (AUCTION_MIN_TITLE_LENGTH..AUCTION_MAX_TITLE_LENGTH))
+          required(:kind).value(included_in?: AUCTION_KINDS)
+          required(:started_at).filled(:time)
+          optional(:description)
+          optional(:finished_at).filled(:time)
+          optional(:initial_bid_cents).filled(:integer)
+          optional(:stopwatch).filled(:integer)
+
+          # Keys with a blank value are discarded.
+          before(:value_coercer) do |result|
+            result.to_h.compact
+          end
+
+          # By default, the minimum bid cents is initially equal to initial_bid_cents.
+          after(:value_coercer) do |result|
+            result.update(minimal_bid_cents: result[:initial_bid_cents]) if result[:initial_bid_cents]
+          end
+        end
+
+        # Validation for staff.
+        # Validate whether the given staff is valid at the database level.
+        rule(:staff_id) do |context:|
+          context[:staff] ||= staff_repo.by_id(value)
+          key.failure(I18n.t("contracts.errors.custom.default.not_found")) unless context[:staff]
+        end
+
+        # Validation for started_at.
+        # Validates if the entered date is greater than or equal to the current time.
+        rule(:started_at) do
+          key.failure(I18n.t("contracts.errors.custom.default.future")) if key? && value <= Time.current
+        end
+
+        # Specific validation when the auction type is informed and it is not penny,
+        # it must be mandatory to inform the auction closing date/time
+        rule(:finished_at, :kind) do
+          if key?(:kind) && !key?(:finished_at) && REQUIRED_FINISHED_AT.include?(values[:kind])
+            key.failure(I18n.t("contracts.errors.filled?"))
+          end
+        end
+
+        # Basic specific validation to check if the auction end time
+        # is less than or equal to the start time.
+        rule(:finished_at, :started_at) do
+          if key?(:finished_at) && (values[:finished_at] <= values[:started_at])
+            key.failure(I18n.t("contracts.errors.custom.auction_context.create.finished_at"))
+          end
+        end
+
+        # Validation for initial bid amount.
+        #
+        rule(:initial_bid_cents) do
+          # Must be filled if auction kind is not type penny.
+          key.failure(I18n.t("contracts.errors.filled?")) if !key? && REQUIRED_FINISHED_AT.include?(values[:kind])
+
+          # Must be greater than zero if action kind is not type penny.
+          if key? && REQUIRED_FINISHED_AT.include?(values[:kind]) && values[:initial_bid_cents] <= 0
+            key.failure(I18n.t("contracts.errors.gt?", num: 0))
+          end
+
+          # Must be equal to zero if auction kind is type penny.
+          if key? && values[:kind] == "penny" && !values[:initial_bid_cents].zero?
+            key.failure(I18n.t("contracts.errors.eql?", left: 0))
+          end
+        end
+
+        # Validation for stopwatch.
+        #
+        rule(:stopwatch) do
+          # Must be filled if auction kind is type penny.
+          key.failure(I18n.t("contracts.errors.filled?")) if !key? && values[:kind] == "penny"
+
+          # Must be an integer between 15 and 60.
+          if key? && values[:kind] == "penny" && !value.between?(AUCTION_STOPWATCH_MIN_VALUE, AUCTION_STOPWATCH_MAX_VALUE)
+            key.failure(
+              I18n.t(
+                "contracts.errors.included_in?.arg.range",
+                list_left: AUCTION_STOPWATCH_MIN_VALUE, list_right: AUCTION_STOPWATCH_MAX_VALUE
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/contracts/auction_context/processor/finish_contract.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Contracts
+    module AuctionContext
+      module Processor
+        ##
+        # Contract class for finish auctions.
+        #
+        class FinishContract < Contracts::ApplicationContract
+          option :auction_repo, default: proc { Repos::AuctionContext::AuctionRepository.new }
+
+          params do
+            required(:auction_id).filled(:integer)
+          end
+
+          # Validation for auction.
+          # Validates if the auction exists in the database.
+          rule(:auction_id) do |context:|
+            context[:auction] ||= auction_repo.by_id(value)
+            key.failure(I18n.t("contracts.errors.custom.not_found")) unless context[:auction]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/contracts/auction_context/processor/pause_contract.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Contracts
+    module AuctionContext
+      module Processor
+        ##
+        # Contract class for pause auction.
+        #
+        class PauseContract < Contracts::ApplicationContract
+          option :auction_repository, default: proc { Repos::AuctionContext::AuctionRepository.new }
+
+          params do
+            required(:auction_id).filled(:integer)
+          end
+
+          # Validation for auction.
+          # Validates if the auction exists in the database and check if  only auctions
+          # with a "running" status can be paused.
+          rule(:auction_id) do |context:|
+            context[:auction] ||= auction_repository.by_id(value)
+            key.failure(I18n.t("contracts.errors.custom.not_found")) unless context[:auction]
+
+            unless %w[running].include?(context[:auction].status)
+              key.failure(
+                I18n.t("contracts.errors.custom.bids.invalid_status", status: context[:auction].status)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/contracts/auction_context/processor/start_contract.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Contracts
+    module AuctionContext
+      module Processor
+        ##
+        # Contract class for start auctions.
+        #
+        class StartContract < Contracts::ApplicationContract
+          include AuctionFunCore::Business::Configuration
+
+          option :auction_repo, default: proc { Repos::AuctionContext::AuctionRepository.new }
+
+          params do
+            required(:auction_id).filled(:integer)
+            required(:kind).value(included_in?: AUCTION_KINDS)
+            optional(:stopwatch).filled(:integer)
+          end
+
+          # Validation for auction.
+          # Validates if the auction exists in the database.
+          rule(:auction_id) do |context:|
+            context[:auction] ||= auction_repo.by_id(value)
+            key.failure(I18n.t("contracts.errors.custom.not_found")) unless context[:auction]
+          end
+
+          # Validation for stopwatch.
+          #
+          rule(:stopwatch) do
+            # Must be filled if auction kind is type penny.
+            key.failure(I18n.t("contracts.errors.filled?")) if !key? && values[:kind] == "penny"
+
+            # Must be an integer between 15 and 60.
+            if key? && values[:kind] == "penny" && !value.between?(AUCTION_STOPWATCH_MIN_VALUE, AUCTION_STOPWATCH_MAX_VALUE)
+              key.failure(
+                I18n.t("contracts.errors.included_in?.arg.range",
+                  list_left: AUCTION_STOPWATCH_MIN_VALUE, list_right: AUCTION_STOPWATCH_MAX_VALUE)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/contracts/auction_context/processor/unpause_contract.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Contracts
+    module AuctionContext
+      module Processor
+        ##
+        # Contract class for unpause auction.
+        #
+        class UnpauseContract < Contracts::ApplicationContract
+          option :auction_repository, default: proc { Repos::AuctionContext::AuctionRepository.new }
+
+          params do
+            required(:auction_id).filled(:integer)
+          end
+
+          # Validation for auction.
+          # Validates if the auction exists in the database and and checks if the
+          # auction has a paused status.
+          rule(:auction_id) do |context:|
+            context[:auction] ||= auction_repository.by_id(value)
+            key.failure(I18n.t("contracts.errors.custom.not_found")) unless context[:auction]
+
+            unless %w[paused].include?(context[:auction].status)
+              key.failure(
+                I18n.t("contracts.errors.custom.bids.invalid_status", status: context[:auction].status)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/contracts/bid_context/create_bid_closed_contract.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Contracts
+    module BidContext
+      # Contract class to create new bids.
+      class CreateBidClosedContract < Contracts::ApplicationContract
+        option :user_repository, default: proc { Repos::UserContext::UserRepository.new }
+        option :auction_repository, default: proc { Repos::AuctionContext::AuctionRepository.new }
+        option :bid_repository, default: proc { Repos::BidContext::BidRepository.new }
+
+        # @param [Hash] opts Sets an allowed list of parameters, as well as some initial validations.
+        params do
+          required(:auction_id).filled(:integer)
+          required(:user_id).filled(:integer)
+          required(:value_cents).filled(:integer)
+
+          # Keys with a blank value are discarded.
+          before(:value_coercer) do |result|
+            result.to_h.compact
+          end
+        end
+
+        # Validation for auction.
+        # validate whether the given auction is valid at the database level.
+        # validate if the auction is open to receive bids
+        rule(:auction_id) do |context:|
+          context[:auction] ||= auction_repository.by_id(value)
+
+          if context[:auction]
+            if context[:auction].kind != "closed"
+              key.failure(I18n.t("contracts.errors.custom.bids.invalid_kind", kind: "closed"))
+            end
+
+            unless %w[scheduled running].include?(context[:auction].status)
+              key.failure(
+                I18n.t("contracts.errors.custom.bids.invalid_status", status: context[:auction].status)
+              )
+            end
+          else
+            key.failure(I18n.t("contracts.errors.custom.not_found"))
+          end
+        end
+
+        # Validation for user.
+        # Validate whether the given user is valid at the database level.
+        # Validates if user has already placed a bid
+        rule(:user_id) do |context:|
+          context[:user] ||= user_repository.by_id(value)
+
+          if context[:user]
+            if bid_repository.exists?(auction_id: values[:auction_id], user_id: value)
+              key.failure(I18n.t("contracts.errors.custom.bids.already_bidded"))
+            end
+          else
+            key.failure(I18n.t("contracts.errors.custom.not_found"))
+          end
+        end
+
+        # Validation for value bid.
+        # The bid amount must be greater than or equal to the starting bid.
+        rule(:value_cents) do |context:|
+          unless rule_error?(:user_id)
+            closed_auction_bid_value_is_gteq_initial_bid?(key, value, context[:auction].initial_bid_cents)
+          end
+        end
+
+        private
+
+        # Checks if bid amount must be greater than or equal to the starting bid.
+        def closed_auction_bid_value_is_gteq_initial_bid?(key, value_cents, minimal_bid_cents)
+          return unless value_cents < minimal_bid_cents
+
+          key.failure(I18n.t("contracts.errors.gteq?", num: Money.new(minimal_bid_cents).to_f))
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/contracts/bid_context/create_bid_penny_contract.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Contracts
+    module BidContext
+      # Contract class to create new bids.
+      class CreateBidPennyContract < Contracts::ApplicationContract
+        option :user_repo, default: proc { Repos::UserContext::UserRepository.new }
+        option :auction_repo, default: proc { Repos::AuctionContext::AuctionRepository.new }
+
+        # @param [Hash] opts Sets an allowed list of parameters, as well as some initial validations.
+        params do
+          required(:auction_id).filled(:integer)
+          required(:user_id).filled(:integer)
+
+          # Keys with a blank value are discarded.
+          before(:value_coercer) do |result|
+            result.to_h.compact
+          end
+        end
+
+        # Validation for auction.
+        # validate whether the given auction is valid at the database level.
+        # validate if the auction is open to receive bids
+        rule(:auction_id) do |context:|
+          context[:auction] ||= auction_repo.by_id(value)
+
+          if context[:auction]
+            if context[:auction].kind != "penny"
+              key.failure(I18n.t("contracts.errors.custom.bids.invalid_kind", kind: "penny"))
+            end
+
+            unless %w[scheduled running].include?(context[:auction].status)
+              key.failure(
+                I18n.t("contracts.errors.custom.bids.invalid_status", status: context[:auction].status)
+              )
+            end
+          else
+            key.failure(I18n.t("contracts.errors.custom.not_found"))
+          end
+        end
+
+        # Validation for user.
+        # Validate whether the given user is valid at the database level.
+        # Validates if user has enough balance to bid.
+        rule(:user_id) do |context:|
+          context[:user] ||= user_repo.by_id(value)
+
+          if context[:user]
+            unless rule_error?(:auction_id)
+              penny_auction_check_user_has_balance?(
+                key, context[:auction].initial_bid_cents, context[:user].balance_cents
+              )
+            end
+          else
+            key.failure(I18n.t("contracts.errors.custom.not_found"))
+          end
+        end
+
+        private
+
+        # Checks if user has enough balance to bid.
+        def penny_auction_check_user_has_balance?(key, auction_bid_cents, balance_cents)
+          key.failure(I18n.t("contracts.errors.custom.bids.insufficient_balance")) if balance_cents < auction_bid_cents
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/contracts/bid_context/create_bid_standard_contract.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Contracts
+    module BidContext
+      # Contract class to create new bids.
+      class CreateBidStandardContract < Contracts::ApplicationContract
+        option :user_repo, default: proc { Repos::UserContext::UserRepository.new }
+        option :auction_repo, default: proc { Repos::AuctionContext::AuctionRepository.new }
+
+        # @param [Hash] opts Sets an allowed list of parameters, as well as some initial validations.
+        params do
+          required(:auction_id).filled(:integer)
+          required(:user_id).filled(:integer)
+          required(:value_cents).filled(:integer)
+
+          # Keys with a blank value are discarded.
+          before(:value_coercer) do |result|
+            result.to_h.compact
+          end
+        end
+
+        # Validation for auction.
+        # validate whether the given auction is valid at the database level.
+        # validate if the auction is open to receive bids
+        rule(:auction_id) do |context:|
+          context[:auction] ||= auction_repo.by_id(value)
+
+          if context[:auction]
+            if context[:auction].kind != "standard"
+              key.failure(I18n.t("contracts.errors.custom.bids.invalid_kind", kind: "standard"))
+            end
+
+            unless %w[scheduled running].include?(context[:auction].status)
+              key.failure(
+                I18n.t("contracts.errors.custom.bids.invalid_status", status: context[:auction].status)
+              )
+            end
+          else
+            key.failure(I18n.t("contracts.errors.custom.not_found"))
+          end
+        end
+
+        # Validation for user.
+        # Validate whether the given user is valid at the database level.
+        rule(:user_id) do |context:|
+          context[:user] ||= user_repo.by_id(value)
+          key.failure(I18n.t("contracts.errors.custom.not_found")) unless context[:user]
+        end
+
+        # Validation for value bid.
+        # must be greater than or equal to the auction's minimal bid.
+        rule(:value_cents) do |context:|
+          standard_auction_valid_bid?(key, value, context[:auction].minimal_bid_cents)
+        end
+
+        private
+
+        # Checks if the bid amount is greather than or equal to minimum bid.
+        def standard_auction_valid_bid?(key, value_cents, minimal_bid_cents)
+          return if value_cents >= minimal_bid_cents
+
+          key.failure(I18n.t("contracts.errors.gteq?", num: Money.new(minimal_bid_cents).to_f))
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/contracts/staff_context/authentication_contract.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Contracts
+    module StaffContext
+      # Contract class to authenticate staff.
+      class AuthenticationContract < ApplicationContract
+        I18N_SCOPE = "contracts.errors.custom.default"
+
+        option :staff_repository, default: proc { Repos::StaffContext::StaffRepository.new }
+
+        params do
+          required(:login)
+          required(:password)
+
+          before(:value_coercer) do |result|
+            result.to_h.compact
+          end
+        end
+
+        rule(:login).validate(:login_format)
+        rule(:password).validate(:password_format)
+
+        # Validation for login.
+        # Searches for the staff in the database from the login, and, if found,
+        # compares the entered password.
+        rule do |context:|
+          next if (rule_error?(:login) || schema_error?(:login)) || (rule_error?(:password) || schema_error?(:password))
+
+          context[:staff] ||= staff_repository.by_login(values[:login])
+
+          next if context[:staff].present? && context[:staff].active? && (BCrypt::Password.new(context[:staff].password_digest) == values[:password])
+
+          if context[:staff].blank? || (BCrypt::Password.new(context[:staff].password_digest) != values[:password])
+            key(:base).failure(I18n.t("login_not_found", scope: I18N_SCOPE))
+          end
+
+          if context[:staff].present? && context[:staff].inactive?
+            key(:base).failure(I18n.t("inactive_account", scope: I18N_SCOPE))
+          end
+
+          key(:base).failure(I18n.t("login_not_found", scope: I18N_SCOPE))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Contracts
+    module StaffContext
+      # Contract class to create new staff.
+      class RegistrationContract < ApplicationContract
+        I18N_SCOPE = "contracts.errors.custom.default"
+
+        option :staff_repository, default: proc { Repos::StaffContext::StaffRepository.new }
+
+        # @param [Hash] opts Sets an allowed list of parameters, as well as some initial validations.
+        params do
+          required(:name)
+          required(:email)
+          required(:phone)
+
+          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) && staff_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) && staff_repository.exists?(phone: value)
+            key.failure(I18n.t(:taken, scope: I18N_SCOPE))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Contracts
+    module UserContext
+      # Contract class to authenticate users.
+      class AuthenticationContract < ApplicationContract
+        I18N_SCOPE = "contracts.errors.custom.default"
+
+        option :user_repository, default: proc { Repos::UserContext::UserRepository.new }
+
+        params do
+          required(:login)
+          required(:password)
+
+          before(:value_coercer) do |result|
+            result.to_h.compact
+          end
+        end
+
+        rule(:login).validate(:login_format)
+        rule(:password).validate(:password_format)
+
+        # Validation for login.
+        # Searches for the user in the database from the login, and, if found,
+        # compares the entered password.
+        rule do |context:|
+          next if (rule_error?(:login) || schema_error?(:login)) || (rule_error?(:password) || schema_error?(:password))
+
+          context[:user] ||= user_repository.by_login(values[:login])
+
+          next if context[:user].present? && context[:user].active? && (BCrypt::Password.new(context[:user].password_digest) == values[:password])
+
+          if context[:user].blank? || (BCrypt::Password.new(context[:user].password_digest) != values[:password])
+            key(:base).failure(I18n.t("login_not_found", scope: I18N_SCOPE))
+          end
+
+          if context[:user].present? && context[:user].inactive?
+            key(:base).failure(I18n.t("inactive_account", scope: I18N_SCOPE))
+          end
+
+          key(:base).failure(I18n.t("login_not_found", scope: I18N_SCOPE))
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/contracts/user_context/email_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 email.
+      class EmailConfirmationContract < ApplicationContract
+        I18N_SCOPE = "contracts.errors.custom.default"
+
+        option :user_repository, default: proc { Repos::UserContext::UserRepository.new }
+
+        params do
+          required(:email_confirmation_token)
+
+          before(:value_coercer) do |result|
+            result.to_h.compact
+          end
+        end
+
+        # Validation for email_confirmation_token.
+        # Searches for the user in the database from the email_confirmation_token
+        rule do |context:|
+          next if schema_error?(:email_confirmation_token)
+
+          context[:user] ||= user_repository.by_email_confirmation_token(values[:email_confirmation_token])
+
+          next if context[:user].present?
+
+          key(:email_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