auctify 1.0.0

data/app/services/auctify/bids_appender.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module Auctify
+  class BidsAppender < ServiceBase
+    attr_reader :auction, :bid
+
+    def initialize(auction:, bid: nil)
+      super()
+
+      @auction = auction
+      @bid = bid
+    end
+
+    def build_result
+      self.current_price = auction.current_price
+      @updated_win_bid = nil
+
+      if bid
+        set_price_for_limit_bid
+
+        if approved_bid?
+          solve_winner(winning_bid, bid)
+          append_bids!
+          update_auction! unless failed?
+        else
+          fail!
+        end
+      end
+
+      @result = result_struct
+    end
+
+    private
+      attr_accessor :current_price
+
+      def result_struct
+        OpenStruct.new(
+          current_price: current_price,
+          current_minimal_bid: new_current_minimal_bid,
+          winning_bid: winning_bid,
+          winner: winner,
+          won_price: (overcame_reserve_price? ? current_price : nil)
+        )
+      end
+
+      def set_price_for_limit_bid
+        return unless bid.price.blank? && bid.with_limit?
+
+        if changing_own_limit?
+          bid.price = winning_bid.price
+        elsif bid.max_price <= new_current_minimal_bid
+          bid.price = bid.max_price
+        else
+          bid.price = new_current_minimal_bid
+        end
+      end
+
+      def approved_bid?
+        @approved_bid ||= begin
+          check_bidder
+          changing_own_limit? ? check_max_price_increasing : check_price_minimum
+          check_same_bidder
+          check_auction_state
+
+          errors.add_from_hash(bid.errors.to_hash)
+
+          errors.empty?
+        end
+      end
+
+      def append_bids!
+        fail! unless bid.save
+
+        # saving last, so it will still be winning, even if both have same price
+        if @updated_win_bid.present?
+          fail! unless @updated_win_bid.save
+        end
+      end
+
+      def update_auction!
+        @winning_bid = nil
+        @bids = bids.reload
+
+
+        fail! unless auction.succesfull_bid!(price: new_current_price,
+                                             winner: winner,
+                                             time: bid.reload.created_at)
+        self.current_price = auction.current_price
+      end
+
+      def new_current_price
+        winning_bid.price
+      end
+
+      def new_current_minimal_bid
+        return current_price if first_bid?
+
+        increase_price(current_price)
+      end
+
+      def winning_bid
+        @winning_bid ||= bids.first
+      end
+
+      def winner
+        (overcame_reserve_price? ? winning_bid.bidder : nil)
+      end
+
+      def overcame_reserve_price?
+        return false if winning_bid.blank?
+        return false if auction.reserve_price.present? && auction.current_price < auction.reserve_price
+
+        true
+      end
+
+      def first_bid?
+        bids.empty?
+      end
+
+      def bids
+        @bids ||= auction.ordered_applied_bids
+      end
+
+      def check_bidder
+        unless bid.registration&.auction == auction
+          bid.errors.add(:auction, :bidder_is_not_registered_for_this_auction)
+        end
+        unless auction.bidding_allowed_for?(bid.bidder)
+          bid.errors.add(:bidder, :you_are_not_allowed_to_bid)
+        end
+      end
+
+      def check_max_price_increasing
+        bid.errors.add(:bidder, :you_can_only_increase_your_max_price) if bid.max_price.present? && (bid.max_price.to_i <= winning_bid.max_price.to_i)
+      end
+
+      def check_price_minimum
+        if bid.price < new_current_minimal_bid
+          att = bid.with_limit? ? :max_price : :price
+          bid.errors.add(att,
+                         :price_is_bellow_minimal_bid,
+                         minimal_bid: ActionController::Base.helpers.number_to_currency(new_current_minimal_bid, precision: 0))
+        end
+      end
+
+      def check_same_bidder
+        return if overbidding_yourself_allowed? || changing_own_limit?
+
+        if winning_bid.present? && same_bidder?(winning_bid, bid)
+          bid.errors.add(:bidder, :you_cannot_overbid_yourself)
+        end
+      end
+
+      def check_auction_state
+        # comparing time with seconds precision, use `.to_i`
+        return if auction.in_sale? && bid.created_at.to_i <= auction.currently_ends_at.to_i
+
+        bid.errors.add(:auction, :auction_is_not_accepting_bids_now)
+      end
+
+      def solve_winner(winning_bid, new_bid)
+        return if winning_bid.blank? || changing_own_limit?
+
+        solve_limits_fight(winning_bid, new_bid)          if  new_bid.with_limit? &&  winning_bid.with_limit?
+        increase_bid_price(winning_bid, new_bid)          if  new_bid.with_limit? && !winning_bid.with_limit?
+        duplicate_increased_win_bid(winning_bid, new_bid) if !new_bid.with_limit? &&  winning_bid.with_limit?
+        # do nothing, all is solved already               if !bid.with_limit? && !winning_bid.with_limit?
+      end
+
+      def solve_limits_fight(winning_bid, new_bid)
+        if winning_bid.max_price < new_bid.max_price
+          update_winning_bid_to(winning_bid.max_price)
+          new_bid.price = [new_bid.price, increase_price_to(overcome: winning_bid.max_price, ceil: new_bid.max_price)].max
+        else
+          new_bid.price = new_bid.max_price
+          update_winning_bid_to(increase_price_to(overcome: new_bid.max_price, ceil: winning_bid.max_price))
+        end
+      end
+
+      def increase_bid_price(winning_bid, new_bid)
+        if winning_bid.price < new_bid.max_price
+          new_bid.price = [new_bid.price, increase_price_to(overcome: winning_bid.price, ceil: new_bid.max_price)].max
+        else
+          new_bid.price = new_bid.max_price
+        end
+      end
+
+      def duplicate_increased_win_bid(winning_bid, new_bid)
+        if winning_bid.max_price < new_bid.price
+          update_winning_bid_to(winning_bid.max_price)
+        elsif overbidding_yourself_allowed? && same_bidder?(winning_bid, new_bid)
+          update_winning_bid_to(new_bid.price, force_if_equal: true)
+        else
+          update_winning_bid_to(increase_price_to(overcome: new_bid.price, ceil: winning_bid.max_price))
+        end
+      end
+
+      def update_winning_bid_to(price, force_if_equal: false)
+        return if price < winning_bid.price
+        return if price == winning_bid.price && !force_if_equal
+
+        @updated_win_bid = winning_bid.dup
+        @updated_win_bid.price = [price, winning_bid.max_price].min
+      end
+
+      def increase_price(price)
+        return price + 1 if bid_steps_ladder.blank?
+
+        _range, increase_step = bid_steps_ladder.detect { |range, step| range.cover?(price) }
+        price + increase_step
+      end
+
+      def increase_price_to(overcome:, ceil:)
+        return ceil if overcome == ceil
+        raise ":ceil is lower than :overcome" if ceil < overcome
+
+        running_price = current_price
+        while running_price <= overcome
+          running_price = increase_price(running_price)
+        end
+
+        [running_price, ceil].min
+      end
+
+      def bid_steps_ladder
+        @bid_steps_ladder ||= auction.bid_steps_ladder
+      end
+
+      def changing_own_limit?
+        bid.with_limit? && winning_bid.present? && (winning_bid.bidder == bid.bidder)
+      end
+
+      def overbidding_yourself_allowed?
+        Auctify.configuration.restrict_overbidding_yourself_to_max_price_increasing == false
+      end
+
+      def same_bidder?(winning_bid, new_bid)
+        winning_bid.bidder == new_bid.bidder
+      end
+  end
+end

data/app/services/auctify/service_base.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Base (surprise!) for Auctify services.
+# Ascendants shoudl implement own methods `initialize` and `build_result`(which assigns to `@result`).
+# In succesfull flow, call `srv = SomeService.call(*args)`
+#   will return itself with result accessible by `srv.result`, errors by`srv.errors` and `srv.success? => true`
+# In failed call (calling `fail!` when building result),
+#   there can be still some result, even errors and `srv.success? => false` (or `srv.failed? => true`)
+# Failing and errors are independent!
+# Errors are like ActiveRecord errors, use `errors.add(:key, "message)`
+# You can pass some information through `srv.flashes` hash
+
+module Auctify
+  class ServiceErrors < Hash
+    def add(key, value, _opts = {})
+      self[key] ||= []
+      self[key] << value
+      self[key].uniq!
+    end
+
+    def add_from_hash(errors_hash)
+      errors_hash.each do |key, values|
+        values.each { |value| add key, value }
+      end
+    end
+
+    def full_messages
+      f_msgs = []
+      each_one { |field, message| f_msgs << "#{field}: #{message}" }
+      f_msgs
+    end
+
+    def each_one
+      each_pair do |field, messages|
+        messages.each { |message| yield field, message }
+      end
+    end
+  end
+
+  class ServiceBase
+    attr_reader :result, :errors, :flashes
+
+    def self.call(*args, **keyword_args)
+      if args.blank?
+        new(**keyword_args).call
+      elsif keyword_args.blank?
+        new(*args).call
+      else
+        new(*args, **keyword_args).call
+      end
+    end
+
+    def call
+      build_result
+      self # always returnning service itself, to get to `errors`, `result`
+    end
+
+    def initialize
+      @result = nil
+      @failed = false
+      @flashes = {}
+      @errors = ServiceErrors.new
+    end
+
+    def fail!
+      @failed = true
+    end
+
+    def success?
+      !failure?
+    end
+
+    def failure?
+      @failed
+    end
+    alias failed? failure?
+  end
+end

data/app/types/auctify/minimal_bids_ladder_type.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Auctify
+  # in ruby/rails we expecting default format as hash with ranges { (0...1_000) => 200, (1_000..) => 500 }
+  # but acceppting (in setter) also hash with numbers or strings
+  # in DB we store JSON with minimal prices casted to nice strings : { "0" => 200, "1_000" => 500 }
+  class MinimalBidsLadderType < ActiveRecord::Type::Value
+    def type
+      :jsonb
+    end
+
+    def cast(value) # setter
+      # hash is expected as value
+      value = JSON.parse(value) if value.is_a?(String)
+      if value.blank?
+        {}
+      else
+        case value.keys.first
+        when Range  # { (0...1_000) => 200, (1_000..) => 500 }
+          cast_from_ranges(value)
+        when String # { "0" => 200, "1_000" => 500 }
+          cast_from_min_strings(value)
+        when Numeric # { 0 => 200, 1000 => 500 }
+          cast_from_min_numbers(value)
+        else
+          raise "Uncovered ladder key type `#{value.keys.first}`"
+        end
+      end
+    end
+
+    def deserialize(db_value) # getter, from db data to ruby raw object
+      return {} if db_value.blank?
+
+      cast(ActiveSupport::JSON.decode(db_value))
+    end
+
+    def serialize(value) # modifier to store in db
+      return nil if value.nil? # so You are able to do `KLASS.where(bid_steps_ladder: nil)`
+
+      # value should be Hash with ranges as keys
+      result = {}
+
+      value.each_pair do |k_range, v|
+        min_price_string = ActiveSupport::NumberHelper.number_to_delimited(k_range.first, delimiter: "_")
+        result[min_price_string] = v
+      end
+
+      ActiveSupport::JSON.encode(result)
+    end
+
+    private
+      def cast_from_ranges(hash)
+        hash # desired format
+      end
+
+      def cast_from_min_strings(hash)
+        result = {}
+        hash.each_pair { |k, v| result[k.to_i] = v }
+
+        cast_from_min_numbers(result)
+      end
+
+      def  cast_from_min_numbers(hash)
+        previous_step = nil
+
+        result = hash.to_a.sort.each_with_object({}) do |step, rslt|
+          unless previous_step.nil?
+            rslt[Range.new(previous_step.first, step.first, true)] = previous_step.last
+          end
+          previous_step = step
+        end
+        result[Range.new(previous_step.first, nil, false)] = previous_step.last
+
+        result
+      end
+  end
+end

data/app/views/auctify/api/v1/console/bids/index.html.erb

@@ -0,0 +1 @@
+<p>Bids.count: <%= @bids.count %> </p>

data/app/views/auctify/api/v1/console/bids/show.html.erb

@@ -0,0 +1 @@
+<p>BID: <%= @bid.to_json %></p>

data/app/views/auctify/bidder_registrations/_form.html.erb

@@ -0,0 +1,27 @@
+<%= form_with(model: bidder_registration, local: true) do |form| %>
+  <% if bidder_registration.errors.any? %>
+    <div id="error_explanation">
+      <h2><%= pluralize(bidder_registration.errors.count, "error") %> prohibited this bidder_registration from being saved:</h2>
+
+      <ul>
+        <% bidder_registration.errors.full_messages.each do |message| %>
+          <li><%= message %></li>
+        <% end %>
+      </ul>
+    </div>
+  <% end %>
+
+  <div class="field">
+    <%= form.label :bidder_id %>
+    <%= form.text_field :bidder_id %>
+  </div>
+
+  <div class="field">
+    <%= form.label :auction_id %>
+    <%= form.text_field :auction_id %>
+  </div>
+
+  <div class="actions">
+    <%= form.submit %>
+  </div>
+<% end %>

data/app/views/auctify/bidder_registrations/edit.html.erb

@@ -0,0 +1,6 @@
+<h1>Editing Bidder Registration</h1>
+
+<%= render 'form', bidder_registration: @bidder_registration %>
+
+<%= link_to 'Show', @bidder_registration %> |
+<%= link_to 'Back', auctify_bidder_registrations_path %>

data/app/views/auctify/bidder_registrations/index.html.erb

@@ -0,0 +1,33 @@
+<p id="notice"><%= notice %></p>
+
+<h1>Bidder Registrations</h1>
+
+<table>
+  <thead>
+    <tr>
+      <th>Bidder</th>
+      <th>Auction</th>
+      <th>Aasm state</th>
+      <th>Handled at</th>
+      <th colspan="3"></th>
+    </tr>
+  </thead>
+
+  <tbody>
+    <% @bidder_registrations.each do |bidder_registration| %>
+      <tr>
+        <td><%= bidder_registration.bidder_id %></td>
+        <td><%= bidder_registration.auction_id %></td>
+        <td><%= bidder_registration.aasm_state %></td>
+        <td><%= bidder_registration.handled_at %></td>
+        <td><%= link_to 'Show', bidder_registration %></td>
+        <td><%= link_to 'Edit', edit_auctify_bidder_registration_path(bidder_registration) %></td>
+        <td><%= link_to 'Destroy', bidder_registration, method: :delete, data: { confirm: 'Are you sure?' } %></td>
+      </tr>
+    <% end %>
+  </tbody>
+</table>
+
+<br>
+
+<%= link_to 'New Bidder Registration', new_auctify_bidder_registration_path %>