auctify 1.0.0

data/app/controllers/auctify/sales_packs_controller.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_dependency "auctify/application_controller"
+
+module Auctify
+  class SalesPacksController < ApplicationController
+    before_action :set_sales_pack, only: [:show, :edit, :update, :destroy]
+
+    # GET /sales_packs
+    def index
+      @sales_packs = SalesPack.all
+    end
+
+    # GET /sales_packs/1
+    def show
+    end
+
+    # GET /sales_packs/new
+    def new
+      @sales_pack = SalesPack.new
+    end
+
+    # GET /sales_packs/1/edit
+    def edit
+    end
+
+    # POST /sales_packs
+    def create
+      @sales_pack = SalesPack.new(sales_pack_params)
+
+      if @sales_pack.save
+        redirect_to @sales_pack, notice: "Sales pack was successfully created."
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /sales_packs/1
+    def update
+      if @sales_pack.update(sales_pack_params)
+        redirect_to @sales_pack, notice: "Sales pack was successfully updated."
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /sales_packs/1
+    def destroy
+      @sales_pack.destroy
+      redirect_to auctify_sales_packs_url, notice: "Sales pack was successfully destroyed."
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_sales_pack
+        @sales_pack = SalesPack.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def sales_pack_params
+        params.require(:sales_pack)
+              .permit(:title,
+                      :description,
+                      :position,
+                      :slug,
+                      :place,
+                      :published,
+                      :sales_interval,
+                      :sales_beginning_hour,
+                      :sales_beginning_minutes,
+                      :start_date,
+                      :end_date)
+      end
+  end
+end

data/app/helpers/auctify/application_helper.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Auctify
+  module ApplicationHelper
+    include Auctify::Engine.routes.url_helpers
+    # line above somehow breaks url generation in forms from main_app
+    # so we nedd to ensure main_app supremacy
+    include Rails.application.routes.url_helpers
+  end
+end

data/app/helpers/auctify/bidder_registrations_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Auctify
+  module BidderRegistrationsHelper
+  end
+end

data/app/helpers/auctify/bids_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Auctify
+  module BidsHelper
+  end
+end

data/app/helpers/auctify/sales_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Auctify
+  module SalesHelper
+    def auctify_id_options_for_select(type)
+      opts = []
+
+      Auctify::Behaviors.registered_classes_as(type).each do |klass|
+        opts += klass.all.collect { |obj| [obj.name, obj.auctify_id] }
+      end
+
+      opts
+    end
+  end
+end

data/app/helpers/auctify/sales_packs_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Auctify
+  module SalesPacksHelper
+  end
+end

data/app/jobs/auctify/application_job.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Auctify
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/auctify/bidding_closer_job.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Auctify
+  class BiddingCloserJob < Auctify::ApplicationJob
+    queue_as :default
+
+    def perform(auction_id:)
+      return if auction_id.blank?
+      begin
+        auction = Auctify::Sale::Auction.find(auction_id)
+      rescue ActiveRecord::RecordNotFound
+        return
+      end
+
+      if auction.currently_ends_at <= Time.current
+        auction.close_bidding! if auction.in_sale?
+      else
+        self.class.set(wait_until: auction.currently_ends_at)
+                  .perform_later(auction_id: auction.id)
+      end
+    end
+  end
+end

data/app/jobs/auctify/bidding_is_close_to_end_notifier_job.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Auctify
+  class BiddingIsCloseToEndNotifierJob < Auctify::ApplicationJob
+    queue_as :default
+
+    def perform(auction_id:)
+      return if auction_id.blank?
+      return if Auctify.configuration.when_to_notify_bidders_before_end_of_bidding.nil?
+
+      begin
+        auction = Auctify::Sale::Auction.find(auction_id)
+      rescue ActiveRecord::RecordNotFound
+        return
+      end
+
+      notify_time = auction.ends_at - Auctify.configuration.when_to_notify_bidders_before_end_of_bidding
+
+      return unless auction.open_for_bids?
+
+      if notify_time <= Time.current
+        auction.before_bidding_is_close_to_end
+      else
+        self.class.set(wait_until: notify_time)
+                  .perform_later(auction_id: auction.id)
+      end
+    end
+  end
+end

data/app/mailers/auctify/application_mailer.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Auctify
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/auctify/application_record.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Auctify
+  class ApplicationRecord < ActiveRecord::Base
+    include Folio::Filterable
+    include Folio::NillifyBlanks
+    include Folio::RecursiveSubclasses
+    include Folio::Sortable
+    include Folio::ToLabel
+
+    self.abstract_class = true
+    self.table_name_prefix = "auctify_"
+  end
+end

data/app/models/auctify/behaviors.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Auctify
+  module Behaviors
+    @@auctified_classes = {}
+    # I borrowed this from Devise
+
+    # Include the chosen auctify behaviors in your model:
+    #
+    #   auctify_as :seller, :buyer
+    #
+    def auctify_as(*behaviors)
+      selected_behaviors = behaviors.map(&:to_sym).uniq
+
+      selected_behaviors.each do |bhv|
+        behavior = Auctify::Behavior::const_get(bhv.to_s.classify) # rubocop:disable Style/ColonMethodCall
+        include behavior
+        Rails.logger.info("Auctifiyng #{self} as #{bhv}: #{@@auctified_classes}")
+        @@auctified_classes[bhv] = ((@@auctified_classes[bhv] || []) + [self]).sort_by { |c| c.name }
+      end
+    end
+
+    def self.registered_classes_as(behavior)
+      @@auctified_classes[behavior] || []
+    end
+  end
+end

data/app/models/auctify/bid.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Auctify
+  class Bid < ApplicationRecord
+    belongs_to :registration, class_name: "Auctify::BidderRegistration", inverse_of: :bids
+
+    scope :ordered, -> { order(price: :desc, id: :desc) }
+    scope :applied, -> { where(cancelled: false) }
+    scope :canceled, -> { where(cancelled: true) }
+    scope :with_limit, -> { where.not(max_price: nil) }
+
+    validate :price_is_not_bigger_then_max_price
+
+    def cancel!
+      update!(cancelled: true)
+
+      auction.recalculate_bidding!
+    end
+
+    def with_limit?
+      max_price.present?
+    end
+
+    def bade_at
+      created_at
+    end
+
+    def price_is_not_bigger_then_max_price
+      errors.add(:price, :must_be_lower_or_equal_max_price) if max_price && max_price < price
+    end
+
+    def bidder=(auctified_model)
+      errors.add(:bidder, :not_auctified) unless auctified_model.class.included_modules.include?(Auctify::Behavior::Buyer)
+      raise "There is already registration for this bid!"  if registration.present?
+      @bidder = auctified_model
+    end
+
+    def bidder
+      @bidder ||= registration&.bidder
+    end
+
+    def auction
+      registration&.auction
+    end
+
+    def configuration
+      Auctify.configuration
+    end
+  end
+end
+
+# == Schema Information
+#
+# Table name: auctify_bids
+#
+#  id              :bigint(8)        not null, primary key
+#  registration_id :integer          not null
+#  price           :decimal(12, 2)   not null
+#  max_price       :decimal(12, 2)
+#  created_at      :datetime         not null
+#  updated_at      :datetime         not null
+#  cancelled       :boolean          default(FALSE)
+#
+# Indexes
+#
+#  index_auctify_bids_on_cancelled        (cancelled)
+#  index_auctify_bids_on_registration_id  (registration_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (registration_id => auctify_bidder_registrations.id)
+#

data/app/models/auctify/bidder_registration.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Auctify
+  class BidderRegistration < ApplicationRecord
+    include AASM
+
+    belongs_to :bidder, polymorphic: true
+    belongs_to :auction, class_name: "Auctify::Sale::Auction", inverse_of: :bidder_registrations
+    has_many :bids, class_name: "Auctify::Bid",
+                    foreign_key: "registration_id",
+                    inverse_of: :registration,
+                    dependent: :restrict_with_error # destroy them manually first
+
+    has_many :ordered_applied_bids, -> { applied.ordered },
+                                    class_name: "Auctify::Bid",
+                                    foreign_key: "registration_id",
+                                    inverse_of: :registration,
+                                    dependent: :restrict_with_error # destroy them manually first
+
+    aasm do
+      state :pending, initial: true, color: "gray"
+      state :approved, color: "green"
+      state :rejected, color: "black"
+
+      event :approve do
+        transitions from: :pending, to: :approved
+
+        before do
+          self.handled_at = Time.current
+        end
+      end
+
+      event :unapprove do
+        transitions from: :approved, to: :pending
+
+        before do
+          self.handled_at = nil
+        end
+      end
+
+      event :reject do
+        transitions from: :pending, to: :rejected
+
+        before do
+          self.handled_at = Time.current
+        end
+      end
+    end
+
+    validate :auction_is_in_allowed_state, on: :create
+
+    private
+      def auction_is_in_allowed_state
+        unless auction && auction.allows_new_bidder_registrations?
+          errors.add(:auction, :auction_do_not_allow_new_registrations)
+        end
+      end
+  end
+end
+
+# == Schema Information
+#
+# Table name: auctify_bidder_registrations
+#
+#  id                :bigint(8)        not null, primary key
+#  bidder_type       :string           not null
+#  bidder_id         :integer          not null
+#  auction_id        :integer          not null
+#  aasm_state        :string           default("pending"), not null
+#  handled_at        :datetime
+#  created_at        :datetime         not null
+#  updated_at        :datetime         not null
+#  dont_confirm_bids :boolean          default(FALSE)
+#
+# Indexes
+#
+#  index_auctify_bidder_registrations_on_aasm_state  (aasm_state)
+#  index_auctify_bidder_registrations_on_auction_id  (auction_id)
+#  index_auctify_bidder_registrations_on_bidder      (bidder_type,bidder_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (auction_id => auctify_sales.id)
+#

data/app/models/auctify/sale/auction.rb

@@ -0,0 +1,404 @@
+# frozen_string_literal: true
+
+module Auctify
+  module Sale
+    class Auction < Auctify::Sale::Base
+      include AASM
+      include Auctify::Sale::AuctionCallbacks
+
+      ATTRIBUTES_UNMUTABLE_AT_SOME_STATE = %i[ends_at offered_price]
+      DEPENDENT_ATTRIBUTES = {
+        ends_at: %i[currently_ends_at],
+        offered_price: %i[current_price]
+      }
+
+      attr_accessor :winning_bid
+
+      has_many :bidder_registrations, dependent: :destroy
+      has_many :bids, through: :bidder_registrations, dependent: :restrict_with_error # destroy them manually first
+      has_many :ordered_applied_bids,  -> { applied.ordered },
+                                       through: :bidder_registrations,
+                                       source: :bids,
+                                       dependent: :restrict_with_error # destroy them manually first
+
+      belongs_to :winner, polymorphic: true, optional: true
+      belongs_to :current_winner, polymorphic: true, optional: true
+
+      validates :ends_at,
+                presence: true
+
+      scope :where_current_winner_is, ->(bidder) { where(current_winner: bidder) }
+
+      aasm do
+        state :offered, initial: true, color: "red"
+        state :accepted, color: "red"
+        state :refused, color: "dark"
+        state :in_sale, color: "yellow"
+        state :bidding_ended, color: "yellow"
+        state :auctioned_successfully, color: "green"
+        state :auctioned_unsuccessfully, color: "red"
+        state :sold, color: "green"
+        state :not_sold, color: "dark"
+        state :cancelled, color: "red"
+
+        event :accept_offer do
+          transitions from: :offered, to: :accepted
+        end
+
+        event :refuse_offer do
+          transitions from: :offered, to: :refused
+        end
+
+        event :start_sale do
+          before do
+            self.current_price = self.offered_price
+            self.currently_ends_at = self.ends_at
+            self.current_winner = nil
+            self.buyer = nil
+          end
+
+          transitions from: :accepted, to: :in_sale
+
+          after do
+            set_bidding_closer_job
+            set_bidding_is_close_to_end_job
+            after_start_sale
+          end
+        end
+
+        event :close_bidding do
+          transitions from: :in_sale, to: :bidding_ended
+
+          after do
+            self.winner = current_winner
+            now = Time.current
+            self.currently_ends_at = now if now < currently_ends_at
+
+            after_close_bidding
+            process_bidding_result! if configuration.autofinish_auction_after_bidding == true
+          end
+        end
+
+        event :sold_in_auction do
+          before do |*args|
+            params = args.first # expecting keys :buyer, :price
+            self.buyer = params[:buyer]
+            self.sold_price = params[:price]
+            self.sold_at = params[:sold_at] || currently_ends_at
+          end
+
+          transitions from: :bidding_ended, to: :auctioned_successfully, if: :valid?
+
+          after do
+            after_sold_in_auction
+          end
+        end
+
+        event :not_sold_in_auction do
+          transitions from: :bidding_ended, to: :auctioned_unsuccessfully, if: :no_winner?
+
+          after do
+            after_not_sold_in_auction
+          end
+        end
+
+        event :sell do
+          transitions from: :auctioned_successfully, to: :sold
+        end
+
+        event :end_sale do
+          transitions from: :auctioned_unsuccessfully, to: :not_sold
+        end
+
+        event :cancel do
+          transitions from: [:offered, :accepted], to: :cancelled
+        end
+      end
+
+      validate :buyer_vs_bidding_consistence
+      validate :forbidden_changes
+
+      after_create :autoregister_bidders
+      before_destroy :forbid_destroy_if_there_are_bids, prepend: true
+
+      def bidders
+        @bidders ||= bidder_registrations.collect { |br| br.bidder }.sort_by(&:name)
+      end
+
+      def published=(value)
+        super
+
+        if published?
+          accept_offer if offered?
+          start_sale if accepted?
+        end
+      end
+
+      def ends_at=(value)
+        super
+
+        self.currently_ends_at = value if currently_ends_at.present?
+      end
+
+      def offered_price=(value)
+        super
+
+        self.current_price = value if current_price.present?
+      end
+
+      def success?
+        return nil if offered? || accepted? || refused? || cancelled? || in_sale? # or raise error?
+        return true if auctioned_successfully? || sold?
+        return false if auctioned_unsuccessfully? || not_sold?
+
+        applied_bids_count.positive? && ((reserve_price || 0) <= current_price)
+      end
+
+      def bid!(bid)
+        ensure_registration(bid)
+
+        ActiveRecord::Base.transaction do
+          bid.created_at ||= Time.current
+
+          bap = Auctify::BidsAppender.call(auction: self, bid: bid)
+
+          bap.success? ? after_bid_appended(bap) : after_bid_not_appended(bap)
+          bap.success?
+        end
+      end
+
+      # callback from bid_appender
+      def succesfull_bid!(price:, winner:, time:)
+        return false if price < current_price || time.blank?
+
+        self.current_price = price
+        self.current_winner = winner
+        self.applied_bids_count = ordered_applied_bids.size
+        extend_end_time(time)
+
+        save!
+      end
+
+      def recalculate_bidding!
+        self.applied_bids_count = ordered_applied_bids.size
+
+        if applied_bids_count.zero?
+          self.current_price = offered_price
+        else
+          winning_price = bidding_result.winning_bid.price
+          self.current_price = winning_price if current_price > winning_price
+        end
+
+        save!
+      end
+
+      delegate :winning_bid, to: :bidding_result
+      def bidding_result
+        Auctify::BidsAppender.call(auction: self, bid: nil).result
+      end
+
+      def current_winner
+        bidding_result.winner
+      end
+
+      def current_winning_bid
+        bidding_result.winning_bid
+      end
+
+      def previous_winning_bid(relative_to_bid = nil)
+        return nil if bids.empty?
+
+        relative_to_bid ||= current_winning_bid
+        considered_bids = bids.ordered.drop_while { |b| b != relative_to_bid }
+        considered_bids.second
+      end
+
+      def current_minimal_bid
+        bidding_result.current_minimal_bid
+      end
+
+      def current_max_price_for(bidder)
+        last_bidder_mx_bid = ordered_applied_bids.with_limit
+                                                 .detect { |bid| bid.bidder == bidder }
+        last_bidder_mx_bid.blank? ? 0 : last_bidder_mx_bid.max_price
+      end
+
+      def open_for_bids?
+        in_sale? && Time.current <= currently_ends_at
+      end
+
+      def opening_price
+        offered_price
+      end
+
+      def allows_new_bidder_registrations?
+        @allows_new_bidder_registrations ||= (in_sale? || accepted?)
+      end
+
+      def bidding_allowed_for?(bidder)
+        babm = bidding_allowed_by_method_for?(bidder)
+        babm.nil? ? true : babm # if no method defined => allow
+      end
+
+      def locked_for_modifications?
+        applied_bids_count.positive?
+      end
+
+      def set_bidding_closer_job
+        Auctify::BiddingCloserJob.set(wait_until: currently_ends_at)
+                                 .perform_later(auction_id: id)
+      end
+
+      private
+        def buyer_vs_bidding_consistence
+          return true if buyer.blank? && sold_price.blank?
+
+          unless buyer == winner
+            errors.add(:buyer,
+                       :buyer_is_not_the_winner,
+                       buyer: buyer.to_label,
+                       winner: winner.to_label)
+          end
+
+          unless sold_price == bidding_result.won_price
+            errors.add(:sold_price,
+                       :sold_price_is_not_from_bidding,
+                       sold_price: sold_price,
+                       won_price: bidding_result.won_price)
+          end
+        end
+
+        def no_winner?
+          return true if winner.blank?
+          errors.add(:buyer,
+            :there_is_a_buyer_for_not_sold_auction,
+             winner: winner.to_label)
+          false
+        end
+
+        def autoregister_bidders
+          class_names = configuration.autoregister_as_bidders_all_instances_of_classes.to_a
+          return if class_names.blank?
+
+          @allows_new_bidder_registrations = true
+
+          class_names.each do |class_name|
+            class_name.constantize.find_each { |bidder| create_registration(bidder) }
+          end
+
+          @allows_new_bidder_registrations = false
+        end
+
+        def ensure_registration(bid)
+          bid.registration = create_registration(bid.bidder) if autocreate_registration?(bid)
+        end
+
+        def autocreate_registration?(bid)
+          return false  if bid.registration.present?
+          return true if configuration.autoregistering_for?(bid.bidder)
+
+          babm = bidding_allowed_by_method_for?(bid.bidder)
+          babm.nil? ? false : babm # if no method defined, do not create
+        end
+
+        def create_registration(bidder)
+          self.bidder_registrations.approved.create!(bidder: bidder, handled_at: Time.current)
+        end
+
+        def bidding_allowed_by_method_for?(bidder)
+          return false if bidder.blank?
+          bidder.try(:bidding_allowed?)
+        end
+
+        def extend_end_time(bid_time)
+          new_end_time = bid_time + Auctify.configuration.auction_prolonging_limit
+          self.currently_ends_at = [currently_ends_at, new_end_time].max
+        end
+
+        def process_bidding_result!
+          case success?
+          when true
+            sold_in_auction!(buyer: current_winner, price: current_price, sold_at: currently_ends_at)
+          when false
+            not_sold_in_auction!
+          else
+            # => nil
+          end
+        end
+
+        def set_bidding_is_close_to_end_job
+          configured_period = Auctify.configuration.when_to_notify_bidders_before_end_of_bidding
+          return if configured_period.blank?
+          notify_time = ends_at - configured_period
+          Auctify::BiddingIsCloseToEndNotifierJob.set(wait_until: notify_time)
+                                                 .perform_later(auction_id: id)
+        end
+
+        def forbidden_changes
+          ATTRIBUTES_UNMUTABLE_AT_SOME_STATE.each do |att|
+            if changes[att].present? && locked_for_modifications?
+              errors.add(att, :no_modification_allowed_now)
+              write_attribute(att, changes[att].first)
+              DEPENDENT_ATTRIBUTES[att].each do |datt|
+                write_attribute(datt, changes[datt].first) if changes[datt].present?
+              end
+            end
+          end
+        end
+
+        def forbid_destroy_if_there_are_bids
+          errors.add(:base, :you_cannot_delete_auction_with_bids) if bids.any?
+        end
+    end
+  end
+end
+
+# == Schema Information
+#
+# Table name: auctify_sales
+#
+#  id                    :bigint(8)        not null, primary key
+#  seller_type           :string
+#  seller_id             :integer
+#  buyer_type            :string
+#  buyer_id              :integer
+#  item_id               :integer          not null
+#  created_at            :datetime         not null
+#  updated_at            :datetime         not null
+#  type                  :string           default("Auctify::Sale::Base")
+#  aasm_state            :string           default("offered"), not null
+#  offered_price         :decimal(, )
+#  current_price         :decimal(, )
+#  sold_price            :decimal(, )
+#  bid_steps_ladder      :json
+#  reserve_price         :decimal(, )
+#  pack_id               :bigint(8)
+#  ends_at               :datetime
+#  position              :integer
+#  number                :string
+#  currently_ends_at     :datetime
+#  published             :boolean          default(FALSE)
+#  featured              :boolean          default(FALSE)
+#  slug                  :string
+#  contract_number       :string
+#  commission_in_percent :integer
+#  winner_type           :string
+#  winner_id             :bigint(8)
+#  applied_bids_count    :integer          default(0)
+#  sold_at               :datetime
+#  current_winner_type   :string
+#  current_winner_id     :bigint(8)
+
+#
+# Indexes
+#
+#  index_auctify_sales_on_buyer_type_and_buyer_id    (buyer_type,buyer_id)
+#  index_auctify_sales_on_currently_ends_at          (currently_ends_at)
+#  index_auctify_sales_on_featured                   (featured)
+#  index_auctify_sales_on_pack_id                    (pack_id)
+#  index_auctify_sales_on_position                   (position)
+#  index_auctify_sales_on_published                  (published)
+#  index_auctify_sales_on_seller_type_and_seller_id  (seller_type,seller_id)
+#  index_auctify_sales_on_slug                       (slug) UNIQUE
+#  index_auctify_sales_on_winner_type_and_winner_id  (winner_type,winner_id)
+#