solidus_auction 0.0.1

data/app/controllers/spree/admin/bids_controller.rb

@@ -0,0 +1,2 @@
+class Spree::Admin::BidsController < Spree::Admin::ResourceController
+end

data/app/controllers/spree/admin/resource_controller_decorator.rb

@@ -0,0 +1,9 @@
+Spree::Admin::ResourceController.class_eval do
+  around_action :set_time_zone, if: :spree_current_user
+
+  private
+
+  def set_time_zone(&block)
+    Time.use_zone(spree_current_user.time_zone, &block)
+  end
+end

data/app/controllers/spree/auctions_controller.rb

@@ -0,0 +1,52 @@
+class Spree::AuctionsController < Spree::StoreController
+  helper Spree::BaseHelper
+  helper Spree::Helpers::LocalTimeHelper
+  helper_method :config
+
+  def index
+    @auctions = Spree::Auction.in_progress.incomplete.current_end_datetime_ascending
+  end
+
+  def starting_soon
+    @auctions = Spree::Auction.incomplete.starting_soon.starting_datetime_ascending
+    render :index
+  end
+
+  def ending_soon
+    @auctions = Spree::Auction.incomplete.ending_soon
+    render :index
+  end
+
+  def recently_completed
+    @auctions = Spree::Auction.recently_completed
+    render :index
+  end
+
+  def show
+    @auction = Spree::Auction.find(params[:id])
+    @product = @auction.product
+    @product_properties = @product.product_properties.includes(:property)
+  end
+
+  def vote_count
+    auction = Spree::Auction.find_by(id: params[:auction_id])
+    votes = auction.cached_votes_up
+    render json: { votes: votes }
+  end
+
+  def vote_up
+    auction = Spree::Auction.find_by(id: params[:auction_id])
+    user = Spree::User.find_by(id: params[:user_id])
+    auction.liked_by user
+    votes = auction.cached_votes_up
+    render json: { votes: votes, voted_for: 1 }
+  end
+
+  def vote_down
+    auction = Spree::Auction.find_by(id: params[:auction_id])
+    user = Spree::User.find_by(id: params[:user_id])
+    auction.downvote_from user
+    votes = auction.cached_votes_up
+    render json: { votes: votes, voted_for: 0 }
+  end
+end

data/app/controllers/spree/bids_controller.rb

@@ -0,0 +1,48 @@
+class Spree::BidsController < Spree::StoreController
+  def index
+    @auction = Spree::Auction.find(params[:auction_id])
+    @bids = @auction.visible_bids_in_chron_order
+  end
+
+  def new
+    @auction = Spree::Auction.find(params[:auction_id])
+    if spree_current_user
+      @bid = Spree::Bid.new(auction: @auction)
+    else
+      flash[:error] = Spree.t("must_be_signed_in_to_bid")
+      redirect_to auction_path @auction
+    end
+  end
+
+  def create
+    @auction = Spree::Auction.find(params[:auction_id])
+    if spree_current_user
+      @bid = Spree::Bid.create(auction: @auction, bidder: spree_current_user, amount: params[:amount])
+      @recorded_bid, message = @auction.receive_bid(@bid)
+      if @recorded_bid
+        flash[:success] = message
+      else
+        flash[:error] = message
+      end
+    else
+      flash[:error] = Spree.t("must_be_signed_in_to_bid")
+    end
+    redirect_to auction_path @auction
+  end
+
+  private
+
+  def flash_message_for(object, event_sym)
+    resource_desc  = object.class.model_name.human
+    resource_desc += " \"#{object.name}\"" if object.respond_to?(:name) && object.name.present?
+    t(event_sym, resource: resource_desc, scope: 'spree')
+  end
+
+  def permitted_bid_attributes
+    %i{auction_id amount}
+  end
+
+  def bid_params
+    params.require(:bid).permit(permitted_bid_attributes)
+  end
+end

data/app/controllers/spree/helpers/local_time_helper.rb

@@ -0,0 +1,77 @@
+module Spree::Helpers::LocalTimeHelper
+  module LocalTime
+    mattr_accessor(:default_time_format) { "%A, %B %e %Y %l:%M%p" }
+    mattr_accessor(:default_date_format) { "%B %e, %Y" }
+
+    class Engine < ::Rails::Engine
+    end
+  end
+  def local_time(time, options = nil)
+    time = utc_time(time)
+
+    options, format = extract_options_and_value(options, :format)
+    format = find_time_format(format)
+
+    options[:data] ||= {}
+    options[:data].merge! local: :time, format: format
+
+    time_tag time, time.strftime(format), options
+  end
+
+  def local_date(time, options = nil)
+    options, format = extract_options_and_value(options, :format)
+    options[:format] = format || LocalTime.default_date_format
+    local_time time, options
+  end
+
+  def local_relative_time(time, options = nil)
+    time = utc_time(time)
+    options, type = extract_options_and_value(options, :type)
+
+    options[:data] ||= {}
+    options[:data].merge! local: type
+
+    time_tag time, time.strftime(LocalTime.default_time_format), options
+  end
+
+  def local_time_ago(time, options = nil)
+    options, * = extract_options_and_value(options, :type)
+    options[:type] = 'time-ago'
+    local_relative_time time, options
+  end
+
+  def utc_time(time_or_date)
+    if time_or_date.respond_to?(:in_time_zone)
+      time_or_date.in_time_zone.utc
+    else
+      time_or_date.to_time.utc
+    end
+  end
+
+  private
+    def find_time_format(format)
+      if format.is_a?(Symbol)
+        if (i18n_format = I18n.t("time.formats.#{format}", default: [:"date.formats.#{format}", ''])).present?
+          i18n_format
+        elsif (date_format = Time::DATE_FORMATS[format] || Date::DATE_FORMATS[format])
+          date_format.is_a?(Proc) ? LocalTime.default_time_format : date_format
+        else
+          LocalTime.default_time_format
+        end
+      else
+        format.presence || LocalTime.default_time_format
+      end
+    end
+
+    def extract_options_and_value(options, value_key = nil)
+      case options
+      when Hash
+        value = options.delete(value_key)
+        [ options, value ]
+      when NilClass
+        [ {} ]
+      else
+        [ {}, options ]
+      end
+    end
+end

data/app/controllers/spree/users_controller_decorator.rb

@@ -0,0 +1,5 @@
+if !Rails.env.test?
+  Spree::UsersController.class_eval do
+    helper Spree::Helpers::LocalTimeHelper
+  end
+end

data/app/controllers/spree/votes_controller.rb

@@ -0,0 +1,5 @@
+class Spree::VotesController < Spree::StoreController
+  def index
+    @auctions = spree_current_user.find_up_voted_items
+  end
+end

data/app/helpers/spree/strong_params_decorator.rb

@@ -0,0 +1,8 @@
+Spree::Core::ControllerHelpers::StrongParameters.class_eval do
+  def permitted_user_attributes
+    permitted_attributes.user_attributes + [
+      bill_address_attributes: permitted_address_attributes,
+      ship_address_attributes: permitted_address_attributes
+    ] + %i{time_zone username}
+  end
+end

data/app/models/spree/auction.rb

@@ -0,0 +1,291 @@
+class Spree::Auction < Spree::Base
+  belongs_to :product, class_name: 'Spree::Product'
+  belongs_to :creator, class_name: 'Spree::User'
+  belongs_to :variant, class_name: 'Spree::Variant'
+  belongs_to :highest_bidder, class_name: 'Spree::User'
+  has_many :bids, class_name: 'Spree::Bid'
+
+  before_save :init_current_price, if: :new_record?
+  before_save :set_current_end_datetime
+  after_find :set_complete
+
+  validates :title, presence: true
+  validates :description, presence: true
+  validates :starting_datetime, presence: true, in_future: true, if: :new_record?
+  validates :planned_end_datetime, presence: true, in_future: true, if: :new_record?
+  validates :product_id, presence: true
+  validates :creator_id, presence: true
+  validates :starting_price, presence: true, numericality: { greater_than_or_equal_to: 0 }
+  validates :reserve_price, numericality: { greater_than_or_equal_to: 0 }
+  validates :bid_increment, numericality: { greater_than_or_equal_to: 0 }
+  validates :time_increment, numericality: { greater_than_or_equal_to: 0 }
+  validates :countdown, numericality: { greater_than_or_equal_to: 0 }
+
+  scope :current_end_datetime_descending, -> { order("current_end_datetime DESC") }
+  scope :current_end_datetime_ascending, -> { order(:current_end_datetime) }
+  scope :starting_datetime_descending, -> { order("starting_datetime DESC") }
+  scope :starting_datetime_ascending, -> { order("starting_datetime") }
+  scope :in_progress, -> { where("starting_datetime <= ?", Time.now) }
+  scope :incomplete, -> { where(complete: false) }
+  scope :complete, -> { where(complete: true) }
+
+  config = Spree::AuctionSettings::Config
+
+  scope :starting_soon, -> { where(starting_datetime: Time.now..(Time.now + config.starting_soon_hours.hours)) }
+  scope :ending_soon, -> { where(current_end_datetime: Time.now..(Time.now + config.ending_soon_hours.hours)) }
+  scope :recently_completed, -> { where(current_end_datetime: (Time.now - config.recently_completed_hours.hours)..Time.now).complete }
+
+  acts_as_votable
+
+  def init_current_price
+    self.current_price = starting_price
+  end
+
+  def set_current_end_datetime
+    if planned_end_datetime != planned_end_datetime_was
+      self.current_end_datetime = planned_end_datetime
+    end
+  end
+
+  def reserve_met?
+    current_price >= reserve_price
+  end
+
+  def won?
+    complete && reserve_met? && highest_bidder
+  end
+
+  def started?
+    if starting_datetime
+      Time.now >= starting_datetime
+    end
+  end
+
+  def order
+    variant.orders.first
+  end
+
+  def in_progress?
+    started? && !complete
+  end
+
+  def visible_bids
+    bids.where(visible: true)
+  end
+
+  def visible_bids_in_chron_order
+    visible_bids.order("updated_at DESC")
+  end
+
+  def visible_bids_in_id_order
+    visible_bids.order("id")
+  end
+
+  def current_end_datetime_as_float
+    current_end_datetime.to_f * 1000
+  end
+
+  def starting_datetime_as_float
+    starting_datetime.to_f * 1000
+  end
+
+  def accepted_bids
+    bids.where(accepted: true)
+  end
+
+  def accepted_bids_in_order
+    accepted_bids.order("amount DESC")
+  end
+
+  def highest_bid
+    accepted_bids_in_order.first
+  end
+
+  def second_highest_bid
+    accepted_bids_in_order.second
+  end
+
+  def top_bids_tied
+    if second_highest_bid
+      highest_bid.amount == second_highest_bid.amount
+    end
+  end
+
+  def ending_soon?
+    current_end_datetime - Time.now <= 1.hour
+  end
+
+  def in_countdown?
+    current_end_datetime - Time.now <= countdown.seconds
+  end
+
+  extend Spree::DisplayMoney
+  money_methods :reserve_price, :current_price, :starting_price, :bid_increment
+
+  def reserve_price_as_usd
+    as_usd reserve_price
+  end
+
+  def current_price_as_usd
+    as_usd current_price
+  end
+
+  def as_usd(price_in_dollars)
+    Money.new(price_in_dollars)
+  end
+
+  def deleted?
+    deleted
+  end
+
+  def set_complete
+    if !complete && current_end_datetime <= Time.now
+      self.complete = true
+      save
+      if won?
+        add_winning_item_to_highest_bidder_cart
+      end
+    end
+  end
+
+  def add_winning_item_to_highest_bidder_cart
+    user = highest_bidder
+    cart = get_user_cart(user)
+    new_variant = product.variants.create(price: current_price, track_inventory: false)
+    cart.contents.add(new_variant)
+    self.variant = new_variant
+    save
+  end
+
+  def get_user_cart(user)
+    last_user_order = user.last_incomplete_spree_order
+
+    if last_user_order
+      last_user_order
+    else
+      user.orders.create
+    end
+  end
+
+  def set_current_price_and_highest_bidder(price, id)
+    self.current_price = price
+    self.highest_bidder_id = id
+  end
+
+  def receive_bid(bid)
+    bid_amount = bid.amount
+    current_price_with_increment = current_price + bid_increment
+    bid_undercuts_current_price = bid_amount < current_price_with_increment
+    if complete
+      bid = nil
+      message = Spree.t("auction_is_complete")
+    elsif bid_undercuts_current_price
+      bid = nil
+      message = Spree.t("bid_not_high_enough")
+    else
+      max_bid = highest_bid
+      if max_bid
+        max_bid_amount = max_bid.amount
+        if max_bid.bidder_id == bid.bidder_id
+          if bid_amount > max_bid_amount
+            if reserve_met? && top_bids_tied
+              amount = current_price_with_increment
+              new_bid = bids.create(bidder_id: max_bid.bidder_id, amount: amount, visible: true, accepted: true)
+              bid.update(visible: false, accepted: true)
+              message = "#{Spree.t(:autobid_up_to)} #{bid.display_amount}. #{Spree.t(:you_successfully_bid)} #{new_bid.display_amount}."
+              set_current_price_and_highest_bidder(amount, bid.bidder_id)
+            elsif !reserve_met? && bid_amount >= reserve_price
+              amount = reserve_price
+              set_current_price_and_highest_bidder(amount, max_bid.bidder_id)
+              new_bid = bids.create(bidder_id: max_bid.bidder_id, amount: amount, visible: true, accepted: true)
+              bid.update(visible: false, accepted: true)
+              message = "#{Spree.t(:autobid_up_to)} #{bid.display_amount}. #{Spree.t(:you_successfully_bid)} #{new_bid.display_amount}. #{Spree.t(:met_reserve_price)}."
+            elsif !reserve_met? && bid_amount < reserve_price
+              bid.update(visible: false, accepted: true)
+              message = "#{Spree.t(:autobid_up_to)} #{bid.display_amount}."
+            elsif reserve_met? && bid_amount > current_price_with_increment && max_bid.is_autobid?
+              bid.update(visible: false, accepted: true)
+              max_bid.update(visible: false, accepted: true)
+              message = "#{Spree.t(:autobid_up_to)} #{bid.display_amount}."
+            elsif reserve_met? && bid_amount > current_price_with_increment && !max_bid.is_autobid?
+              bid.update(visible: false, accepted: true)
+              message = "#{Spree.t(:autobid_up_to)} #{bid.display_amount}."
+            else
+              amount = bid_amount
+              max_bid.update(visible: false, accepted: false)
+              bid.update(visible: false, accepted: true)
+              set_current_price_and_highest_bidder(amount, bid.bidder_id)
+              message = "#{Spree.t(:autobid_up_to)} #{bid.display_amount}."
+            end
+          else
+            bid = nil
+            message = Spree.t(:less_than_original_autobid)
+          end
+        else
+          max_bid_is_higher = max_bid_amount > bid_amount
+          max_bid_is_lower = max_bid_amount < bid_amount
+          max_bid_with_increment = max_bid.amount + bid_increment
+          if max_bid_is_higher
+            bid_amount_with_increment = bid_amount + bid_increment
+            if bid_amount_with_increment > max_bid_amount
+              amount = max_bid_amount
+            else
+              amount = bid_amount_with_increment
+            end
+            bid.update(visible: true, accepted: true)
+            bids.create(bidder_id: max_bid.bidder_id, amount: amount, visible: true, accepted: true)
+            set_current_price_and_highest_bidder(amount, max_bid.bidder_id)
+            bid = nil
+            message = Spree.t(:you_were_outbid)
+          elsif max_bid_is_lower
+            if !reserve_met? && bid_amount >= reserve_price
+              amount = reserve_price
+            elsif max_bid_with_increment > bid_amount
+              amount = bid_amount
+            else
+              amount = max_bid_with_increment
+            end
+
+            max_bid.update(visible: true, accepted: true)
+            if max_bid_with_increment == bid_amount
+              bid.update(visible: true, accepted: true)
+              message = "#{Spree.t(:you_successfully_bid)} #{bid.display_amount}."
+            else
+              new_bid = bids.create(bidder_id: bid.bidder_id, amount: amount, visible: true, accepted: true)
+              bid.update(visible: false, accepted: true)
+              message = "#{Spree.t(:autobid_up_to)} #{bid.display_amount}. #{Spree.t(:you_successfully_bid)} #{new_bid.display_amount}."
+            end
+            set_current_price_and_highest_bidder(amount, bid.bidder_id)
+          else
+            amount = max_bid.amount
+            bid.update(visible: true, accepted: true)
+            max_bid.update(visible: true, accepted: true)
+            set_current_price_and_highest_bidder(amount, max_bid.bidder_id)
+            bid = nil
+            message = Spree.t(:there_was_a_tie_autobid_wins)
+          end
+        end
+      elsif bid_amount > current_price_with_increment
+        if !reserve_met? && bid_amount >= reserve_price
+          amount = reserve_price
+        else
+          amount = current_price_with_increment
+        end
+        set_current_price_and_highest_bidder(amount, bid.bidder_id)
+        bid.update(visible: false, accepted: true)
+        new_bid = bids.create(bidder_id: bid.bidder_id, amount: amount, visible: true, accepted: true)
+        message = "#{Spree.t(:autobid_up_to)} #{bid.display_amount}. #{Spree.t(:you_successfully_bid)} #{new_bid.display_amount}."
+      else
+        bid.update(visible: true, accepted: true)
+        amount = current_price_with_increment
+        set_current_price_and_highest_bidder(amount, bid.bidder_id)
+        message = "#{Spree.t(:you_successfully_bid)} #{bid.display_amount}."
+      end
+      if in_countdown?
+        self.current_end_datetime += time_increment.seconds
+      end
+      save
+    end
+    [bid, message]
+  end
+end