auction_fun_core 0.8.5

data/lib/auction_fun_core/operations/bid_context/create_bid_closed_operation.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    module BidContext
+      ##
+      # Operation class for create new bids for closed auctions.
+      #
+      class CreateBidClosedOperation < AuctionFunCore::Operations::Base
+        include Import["contracts.bid_context.create_bid_closed_contract"]
+        include Import["repos.bid_context.bid_repository"]
+
+        # @todo Add custom doc
+        def self.call(attributes, &block)
+          operation = new.call(attributes)
+
+          return operation unless block
+
+          Dry::Matcher::ResultMatcher.call(operation, &block)
+        end
+
+        # @todo Add custom doc
+        def call(attributes)
+          values = yield validate(attributes)
+
+          bid_repository.transaction do |_t|
+            @bid = yield persist(values)
+            yield publish_bid_created(@bid)
+          end
+
+          Success(@bid)
+        end
+
+        # Calls the bid creation contract class to perform the validation
+        # of the informed attributes.
+        # @param attrs [Hash] bid attributes
+        # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+        def validate(attrs)
+          contract = create_bid_closed_contract.call(attrs)
+
+          return Failure(contract.errors.to_h) if contract.failure?
+
+          Success(contract.to_h)
+        end
+
+        # Calls the bid repository class to persist the attributes in the database.
+        # @param result [Hash] Bid validated attributes
+        # @return [ROM::Struct::Bid]
+        def persist(result)
+          Success(bid_repository.create(result))
+        end
+
+        # Triggers the publication of event *bids.created*.
+        # @param bid [ROM::Struct::Bid] Bid object
+        # @return [Dry::Monads::Result::Success]
+        def publish_bid_created(bid)
+          Application[:event].publish("bids.created", bid.to_h)
+
+          Success()
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/operations/bid_context/create_bid_penny_operation.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    module BidContext
+      ##
+      # Operation class for create new bids for penny auctions.
+      #
+      class CreateBidPennyOperation < AuctionFunCore::Operations::Base
+        include Import["contracts.bid_context.create_bid_penny_contract"]
+        include Import["repos.bid_context.bid_repository"]
+
+        # @todo Add custom doc
+        def self.call(attributes, &block)
+          operation = new.call(attributes)
+
+          return operation unless block
+
+          Dry::Matcher::ResultMatcher.call(operation, &block)
+        end
+
+        # @todo Add custom doc
+        def call(attributes)
+          values = yield validate(attributes)
+
+          bid_repository.transaction do |_t|
+            @bid = yield persist(values)
+            yield publish_bid_created(@bid)
+          end
+
+          Success(@bid)
+        end
+
+        # Calls the bid creation contract class to perform the validation
+        # of the informed attributes.
+        # @param attrs [Hash] bid attributes
+        # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+        def validate(attrs)
+          contract = create_bid_penny_contract.call(attrs)
+
+          return Failure(contract.errors.to_h) if contract.failure?
+
+          Success(contract.to_h)
+        end
+
+        # Calls the bid repository class to persist the attributes in the database.
+        # @param result [Hash] Bid validated attributes
+        # @return [ROM::Struct::Bid]
+        def persist(result)
+          Success(bid_repository.create(result))
+        end
+
+        # Triggers the publication of event *bids.created*.
+        # @param bid [ROM::Struct::Bid] Bid Object
+        # @return [Dry::Monads::Result::Success]
+        def publish_bid_created(bid)
+          Application[:event].publish("bids.created", bid.to_h)
+
+          Success()
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/operations/bid_context/create_bid_standard_operation.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    module BidContext
+      ##
+      # Operation class for create new bids for standard auctions.
+      #
+      class CreateBidStandardOperation < AuctionFunCore::Operations::Base
+        INCREASE = 0.1
+        include Import["contracts.bid_context.create_bid_standard_contract"]
+        include Import["repos.auction_context.auction_repository"]
+        include Import["repos.bid_context.bid_repository"]
+
+        # @todo Add custom doc
+        def self.call(attributes, &block)
+          operation = new.call(attributes)
+
+          return operation unless block
+
+          Dry::Matcher::ResultMatcher.call(operation, &block)
+        end
+
+        # @todo Add custom doc
+        def call(attributes)
+          values = yield validate(attributes)
+
+          bid_repository.transaction do |_t|
+            @bid = yield persist(values)
+            yield calculate_standard_auction_new_minimal_bid_value(@bid.auction_id, @bid.value_cents)
+            yield publish_bid_created(@bid)
+          end
+
+          Success(@bid)
+        end
+
+        # Calls the bid creation contract class to perform the validation
+        # of the informed attributes.
+        # @param attrs [Hash] bid attributes
+        # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+        def validate(attrs)
+          contract = create_bid_standard_contract.call(attrs)
+
+          return Failure(contract.errors.to_h) if contract.failure?
+
+          Success(contract.to_h)
+        end
+
+        # Calculates the new minimum next bid amount.
+        def calculate_standard_auction_new_minimal_bid_value(auction_id, bid_cents)
+          minimal_bid_cents = (bid_cents + (bid_cents * INCREASE))
+
+          Success(auction_repository.update(auction_id, minimal_bid_cents: minimal_bid_cents))
+        end
+
+        # Calls the bid repository class to persist the attributes in the database.
+        # @param result [Hash] Bid validated attributes
+        # @return [ROM::Struct::Bid]
+        def persist(result)
+          Success(bid_repository.create(result))
+        end
+
+        # Triggers the publication of event *bids.created*.
+        # @param bid [ROM::Struct::Bid] Bid Object
+        # @return [Dry::Monads::Result::Success]
+        def publish_bid_created(bid)
+          Application[:event].publish("bids.created", bid.to_h)
+
+          Success()
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/operations/staff_context/authentication_operation.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    module StaffContext
+      ##
+      # Operation class for authenticate staff members.
+      #
+      class AuthenticationOperation < AuctionFunCore::Operations::Base
+        include Import["contracts.staff_context.authentication_contract"]
+
+        def self.call(attributes, &block)
+          operation = new.call(attributes)
+
+          return operation unless block
+
+          Dry::Matcher::ResultMatcher.call(operation, &block)
+        end
+
+        # @todo Add custom doc
+        def call(attributes)
+          staff = yield validate_contract(attributes)
+
+          yield publish_staff_authentication(staff.id)
+
+          Success(staff)
+        end
+
+        # Calls the authentication contract class to perform the validation
+        # and authentication of the informed attributes.
+        # @param attrs [Hash] Staff attributes
+        # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+        def validate_contract(attrs)
+          contract = authentication_contract.call(attrs)
+
+          return Failure(contract.errors.to_h) if contract.failure?
+
+          Success(contract.context[:staff])
+        end
+
+        # Triggers the publication of event *staffs.registration*.
+        # @param staff_id [Integer] Staff ID
+        # @return [Dry::Monads::Result::Success]
+        def publish_staff_authentication(staff_id, time = Time.current)
+          Success(
+            Application[:event].publish("staffs.authentication", {staff_id: staff_id, time: time})
+          )
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/operations/staff_context/registration_operation.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    module StaffContext
+      ##
+      # Operation class for create new staff member.
+      #
+      class RegistrationOperation < AuctionFunCore::Operations::Base
+        include Import["contracts.staff_context.registration_contract"]
+        include Import["repos.staff_context.staff_repository"]
+
+        def self.call(attributes, &block)
+          operation = new.call(attributes)
+
+          return operation unless block
+
+          Dry::Matcher::ResultMatcher.call(operation, &block)
+        end
+
+        # @todo Add custom doc
+        def call(attributes)
+          values = yield validate_contract(attributes)
+          values_with_encrypt_password = yield encrypt_password(values)
+
+          staff_repository.transaction do |_t|
+            @staff = yield persist(values_with_encrypt_password)
+
+            yield publish_staff_registration(@staff.id)
+          end
+
+          Success(@staff)
+        end
+
+        # Calls registration contract class to perform the validation
+        # of the informed attributes.
+        # @param attrs [Hash] staff attributes
+        # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+        def validate_contract(attrs)
+          contract = registration_contract.call(attrs)
+
+          return Failure(contract.errors.to_h) if contract.failure?
+
+          Success(contract.to_h)
+        end
+
+        # Transforms the password attribute, encrypting it to be saved in the database.
+        # @param result [Hash] Staff valid contract attributes
+        # @return [Hash] Valid staff database
+        def encrypt_password(attrs)
+          attributes = attrs.to_h.except(:password)
+
+          Success(
+            {**attributes, password_digest: BCrypt::Password.create(attrs[:password])}
+          )
+        end
+
+        # Calls the staff repository class to persist the attributes in the database.
+        # @param result [Hash] Staff validated attributes
+        # @return [ROM::Struct::Staff]
+        def persist(result)
+          Success(staff_repository.create(result))
+        end
+
+        # Triggers the publication of event *staffs.registration*.
+        # @param staff_id [Integer] Staff ID
+        # @return [Dry::Monads::Result::Success]
+        def publish_staff_registration(staff_id)
+          staff = staff_repository.by_id!(staff_id)
+
+          Success(Application[:event].publish("staffs.registration", staff.info))
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/operations/user_context/authentication_operation.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    module UserContext
+      ##
+      # Operation class for authenticate users.
+      #
+      class AuthenticationOperation < AuctionFunCore::Operations::Base
+        include Import["contracts.user_context.authentication_contract"]
+
+        def self.call(attributes, &block)
+          operation = new.call(attributes)
+
+          return operation unless block
+
+          Dry::Matcher::ResultMatcher.call(operation, &block)
+        end
+
+        # @todo Add custom doc
+        def call(attributes)
+          user = yield validate_contract(attributes)
+
+          yield publish_user_authentication(user.id)
+
+          Success(user)
+        end
+
+        # Calls the authentication contract class to perform the validation
+        # and authentication of the informed attributes.
+        # @param attrs [Hash] user attributes
+        # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+        def validate_contract(attrs)
+          contract = authentication_contract.call(attrs)
+
+          return Failure(contract.errors.to_h) if contract.failure?
+
+          Success(contract.context[:user])
+        end
+
+        # Triggers the publication of event *users.registration*.
+        # @param user_id [Integer] User ID
+        # @return [Dry::Monads::Result::Success]
+        def publish_user_authentication(user_id, time = Time.current)
+          Success(
+            Application[:event].publish("users.authentication", {user_id: user_id, time: time})
+          )
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/operations/user_context/email_confirmation_operation.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    module UserContext
+      ##
+      # Operation class for confirm users by token via email.
+      #
+      class EmailConfirmationOperation < AuctionFunCore::Operations::Base
+        include Import["repos.user_context.user_repository"]
+        include Import["contracts.user_context.email_confirmation_contract"]
+
+        def self.call(attributes, &block)
+          operation = new.call(attributes)
+
+          return operation unless block
+
+          Dry::Matcher::ResultMatcher.call(operation, &block)
+        end
+
+        # @todo Add custom doc
+        def call(attributes)
+          user = yield validate_contract(attributes)
+
+          user_repository.transaction do |_t|
+            user = yield persist(user.id)
+
+            yield publish_user_confirmation(user.id, user.confirmed_at)
+          end
+
+          Success(user)
+        end
+
+        # Calls the authentication contract class to perform the validation
+        # and authentication of the informed attributes.
+        # @param attrs [Hash] user attributes
+        # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+        def validate_contract(attrs)
+          contract = email_confirmation_contract.call(attrs)
+
+          return Failure(contract.errors.to_h) if contract.failure?
+
+          Success(contract.context[:user])
+        end
+
+        # Calls the user repository class to update database fields.
+        # @param user_id [Integer] User ID
+        # @param time [Time] Confirmation time
+        # @return [ROM::Struct::User]
+        def persist(user_id, time = Time.current)
+          result = {email_confirmation_token: nil, email_confirmed_at: time, confirmed_at: time}
+
+          Success(user_repository.update(user_id, result))
+        end
+
+        # Triggers the publication of event *users.registration*.
+        # @param user_id [Integer] User ID
+        # @return [Dry::Monads::Result::Success]
+        def publish_user_confirmation(user_id, time = Time.current)
+          Success(
+            Application[:event].publish("users.confirmation", {user_id: user_id, time: time})
+          )
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/operations/user_context/phone_confirmation_operation.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    module UserContext
+      ##
+      # Operation class for confirm users by token via phone.
+      #
+      class PhoneConfirmationOperation < AuctionFunCore::Operations::Base
+        include Import["repos.user_context.user_repository"]
+        include Import["contracts.user_context.phone_confirmation_contract"]
+
+        def self.call(attributes, &block)
+          operation = new.call(attributes)
+
+          return operation unless block
+
+          Dry::Matcher::ResultMatcher.call(operation, &block)
+        end
+
+        # @todo Add custom doc
+        def call(attributes)
+          user = yield validate_contract(attributes)
+
+          user_repository.transaction do |_t|
+            user = yield persist(user.id)
+
+            yield publish_user_confirmation(user.id, user.confirmed_at)
+          end
+
+          Success(user)
+        end
+
+        # Calls the authentication contract class to perform the validation
+        # and authentication of the informed attributes.
+        # @param attrs [Hash] user attributes
+        # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+        def validate_contract(attrs)
+          contract = phone_confirmation_contract.call(attrs)
+
+          return Failure(contract.errors.to_h) if contract.failure?
+
+          Success(contract.context[:user])
+        end
+
+        # Calls the user repository class to update database fields.
+        # @param user_id [Integer] User ID
+        # @param time [Time] Confirmation time
+        # @return [ROM::Struct::User]
+        def persist(user_id, time = Time.current)
+          result = {phone_confirmation_token: nil, phone_confirmed_at: time, confirmed_at: time}
+
+          Success(user_repository.update(user_id, result))
+        end
+
+        # Triggers the publication of event *users.registration*.
+        # @param user_id [Integer] User ID
+        # @return [Dry::Monads::Result::Success]
+        def publish_user_confirmation(user_id, time = Time.current)
+          Success(
+            Application[:event].publish("users.confirmation", {user_id: user_id, time: time})
+          )
+        end
+      end
+    end
+  end
+end

data/lib/auction_fun_core/operations/user_context/registration_operation.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module AuctionFunCore
+  module Operations
+    module UserContext
+      ##
+      # Operation class for create new users.
+      #
+      class RegistrationOperation < AuctionFunCore::Operations::Base
+        include Import["repos.user_context.user_repository"]
+        include Import["contracts.user_context.registration_contract"]
+
+        def self.call(attributes, &block)
+          operation = new.call(attributes)
+
+          return operation unless block
+
+          Dry::Matcher::ResultMatcher.call(operation, &block)
+        end
+
+        # @todo Add custom doc
+        def call(attributes)
+          values = yield validate_contract(attributes)
+          values_with_encrypt_password = yield encrypt_password(values)
+          values_with_confirmation_attributes = yield confirmation_attributes(values_with_encrypt_password)
+
+          user_repository.transaction do |_t|
+            @user = yield persist(values_with_confirmation_attributes)
+
+            yield publish_user_registration(@user.id)
+            yield send_welcome_email(@user.id)
+          end
+
+          Success(@user)
+        end
+
+        # Calls registration contract class to perform the validation
+        # of the informed attributes.
+        # @param attrs [Hash] user attributes
+        # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+        def validate_contract(attrs)
+          contract = registration_contract.call(attrs)
+
+          return Failure(contract.errors.to_h) if contract.failure?
+
+          Success(contract.to_h)
+        end
+
+        # Transforms the password attribute, encrypting it to be saved in the database.
+        # @param result [Hash] User valid contract attributes
+        # @return [Hash] Valid user database
+        def encrypt_password(attrs)
+          attributes = attrs.to_h.except(:password, :password_confirmation)
+
+          Success(
+            {**attributes, password_digest: BCrypt::Password.create(attrs[:password])}
+          )
+        end
+
+        # Adds confirmation parameters to the given attributes.
+        # @param result [Hash] User valid contract attributes with password
+        # @return [Hash] Valid user database
+        def confirmation_attributes(attrs)
+          Success({**attrs, email_confirmation_token: generate_email_token})
+        end
+
+        # Calls the user repository class to persist the attributes in the database.
+        # @param result [Hash] User validated attributes
+        # @return [ROM::Struct::User]
+        def persist(result)
+          Success(user_repository.create(result))
+        end
+
+        # Triggers the publication of event *users.registration*.
+        # @param user_id [Integer] User ID
+        # @return [Dry::Monads::Result::Success]
+        def publish_user_registration(user_id)
+          user = user_repository.by_id!(user_id)
+
+          Success(Application[:event].publish("users.registration", user.info))
+        end
+
+        # Schedule the asynchronous sending of a welcome email.
+        # @param user_id [Integer] User ID
+        # @return [Dry::Monads::Result::Success]
+        def send_welcome_email(user_id)
+          Success(registration_mailer_job.perform_async(user_id))
+        end
+
+        # Since the shipping code structure does not follow project conventions,
+        # making the default injection dependency would be more complicated.
+        # Therefore, here I directly explain the class to be called.
+        private
+
+        def registration_mailer_job
+          AuctionFunCore::Workers::Services::Mail::UserContext::RegistrationMailerJob
+        end
+
+        def generate_email_token
+          ::AuctionFunCore::Business::TokenGenerator.generate_email_token
+        end
+      end
+    end
+  end
+end