auctify 1.0.0

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

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module Auctify
+  module Sale
+    class Base < ApplicationRecord
+      include Folio::FriendlyId
+      include Folio::Positionable
+      include Folio::Featurable::Basic
+      include Folio::Publishable::Basic
+
+      self.table_name = "auctify_sales"
+
+      attribute :bid_steps_ladder, MinimalBidsLadderType.new
+
+      include Auctify::Behavior::Base
+
+      belongs_to :seller, polymorphic: true, optional: true
+      belongs_to :buyer, polymorphic: true, optional: true
+      # added on usage of `auctify_as :item` =>     belongs_to :item, class_name: ???
+      belongs_to :pack, class_name: "Auctify::SalesPack", inverse_of: :sales, optional: true, counter_cache: :sales_count
+
+      validate :valid_seller
+      validate :valid_item
+      validate :valid_buyer
+
+      validates :offered_price,
+                :current_price,
+                :sold_price,
+                :reserve_price,
+                numericality: { greater_than_or_equal_to: 0 },
+                allow_nil: true
+
+      validate :validate_offered_price_when_published
+
+      scope :not_sold, -> { where(sold_price: nil) }
+
+      # need auction scopes here because of has_many :sales, class_name: "Auctify::Sale::Base"
+      scope :auctions_open_for_bids, -> do
+        where(aasm_state: "in_sale").where("currently_ends_at > ?", Time.current)
+      end
+
+      scope :auctions_finished, -> do
+        where.not(aasm_state: %w[offered accepted refused]).where("currently_ends_at < ?", Time.current)
+      end
+
+      scope :latest_published_by_item, -> { joins(latest_published_sales_by_item_subtable.join_sources) }
+
+      delegate :to_label,
+               to: :item
+
+      def self.latest_published_sales_by_item_subtable
+        # see https://www.salsify.com/blog/engineering/most-recent-by-group-in-rails
+        sales_table = self.arel_table
+
+        latest_sales_query = sales_table.project(sales_table[:item_id],
+                                                 sales_table[:id].maximum.as("latest_sale_id"))
+                                        .where(sales_table[:published].eq(true))
+                                        .group(sales_table[:item_id])
+
+        latest_sales_table = Arel::Table.new(latest_sales_query).alias(:latest_sales)  # need to perform join
+
+        sales_table.join(latest_sales_query.as(latest_sales_table.name.to_s), Arel::Nodes::InnerJoin)
+                   .on(sales_table[:id].eq(latest_sales_table[:latest_sale_id]))
+      end
+
+      def initialize(*args)
+        super
+
+        self.bid_steps_ladder = configuration.default_bid_steps_ladder if bid_steps_ladder.blank?
+      end
+
+      # need to cover wrong class of item before assigning
+      def item=(item)
+        @item = item
+        valid_item
+
+        super if errors.blank?
+      end
+
+      [:seller, :buyer, :item].each do |behavior|
+        define_method("#{behavior}_auctify_id=") do |auctify_id|
+          self.send("#{behavior}=", object_from_auctify_id(auctify_id))
+        end
+
+        define_method("#{behavior}_auctify_id") do
+          self.send("#{behavior}")&.auctify_id
+        end
+      end
+
+      def publish!
+        self.published = true
+        save
+      end
+
+      def auctioneer_commission
+        return nil if sold_price.nil?
+
+        percent = commission_in_percent \
+                  || (pack&.commission_in_percent) \
+                  || Auctify.configuration.auctioneer_commission_in_percent
+
+        sold_price * percent * 0.01
+      end
+
+      private
+        def valid_seller
+          return true if seller_id.blank?
+
+          db_seller = db_presence_of(seller)
+
+          errors.add(:seller, :required) unless db_seller.present?
+        end
+
+        def valid_item
+          item = @item || self.item
+          errors.delete(:item)
+
+          db_item = db_presence_of(item)
+          if db_item.present?
+            errors.add(:item, :already_on_sale_in_sales_pack, sale_pack_title: pack.title) if pack && pack.sales
+                                                                                                          .where(item: db_item)
+                                                                                                          .where.not(id: self.id)
+                                                                                                          .exists?
+          else
+            # Rails will add "required" on item.nil? automagically (and after this validation) but not for non-persisted item
+            # we do not allow creating sale along with item, so this trying to cover that
+            errors.add(:item, :required) unless item.blank? || errors.details[:item].include?({ error: :blank })
+          end
+        end
+
+        def valid_buyer
+          db_buyer = db_presence_of(buyer)
+          errors.add(:buyer, :required) if buyer.present? && db_buyer.blank?
+        end
+
+        def db_presence_of(record)
+          return nil if record.blank?
+
+          record.reload
+        rescue ActiveRecord::RecordNotFound
+          nil
+        end
+
+        def configuration
+          Auctify.configuration
+        end
+
+        def validate_offered_price_when_published
+          if published? && offered_price.blank?
+            errors.add(:offered_price, :required_for_published)
+          end
+        end
+
+        def slug_candidates
+          base = try(:item).try(:title).presence || self.class.model_name.human
+          year = Time.zone.now.year
+          [base, "#{base}-#{year}"] + 9.times.map { |i| "#{base}-#{year}-#{i + 2}" }
+        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)
+#

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Auctify
+  module Sale
+    class Retail < Auctify::Sale::Base
+      include AASM
+
+      aasm do
+        state :offered, initial: true, color: "red"
+        state :accepted, color: "red"
+        state :refused, color: "dark"
+        state :in_sale, color: "yellow"
+        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
+          transitions from: :accepted, to: :in_sale
+        end
+
+        event :sell do
+          transitions from: :in_sale, to: :sold
+          after do |*args| # TODO: sold_at
+            params = args.first # expecting keys :buyer, :price
+            self.buyer = params[:buyer]
+            self.sold_price = params[:price]
+          end
+        end
+
+        event :end_sale do
+          transitions from: :in_sale, to: :not_sold
+        end
+
+        event :cancel do
+          transitions from: [:offered, :accepted], to: :cancelled
+        end
+      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)
+#

data/app/models/auctify/sales_pack.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Auctify
+  class SalesPack < ApplicationRecord
+    include Folio::FriendlyId
+    include Folio::HasAttachments
+    include Folio::Positionable
+    include Folio::Publishable::Basic
+    include Folio::Sitemap::Base
+
+    has_many :sales, class_name: "Auctify::Sale::Base", foreign_key: :pack_id, inverse_of: :pack, dependent: :restrict_with_error
+    has_many :items, through: :sales
+
+    validates :title,
+              presence: true,
+              uniqueness: true
+
+    validates :start_date,
+              :end_date,
+              presence: true
+
+    validates :sales_interval,
+              numericality: { greater_than: 0, less_than: 240 }
+
+    validates :sales_beginning_hour,
+              numericality: { greater_than_or_equal: 0, less_than: 24 }
+
+    validates :sales_beginning_minutes,
+              numericality: { greater_than_or_equal: 0, less_than: 60 }
+
+    validate :validate_start_and_end_dates
+
+    scope :ordered, -> { order(start_date: :desc, id: :desc) }
+
+    pg_search_scope :by_query,
+                    against: %i[title],
+                    ignoring: :accents,
+                    using: { tsearch: { prefix: true } }
+
+    after_initialize :set_commission
+
+    def to_label
+      title
+    end
+
+    def dates_to_label
+      if start_date && end_date
+        if start_date.year == end_date.year
+          if start_date.month == end_date.month
+            "#{start_date.strftime('%-d.')}–#{end_date.strftime('%-d. %-m. %y')}"
+          else
+            "#{start_date.strftime('%-d. %-m.')} – #{end_date.strftime('%-d. %-m. %y')}"
+          end
+        else
+          "#{start_date.strftime('%-d. %-m. %y')} – #{end_date.strftime('%-d. %-m. %y')}"
+        end
+      end
+    end
+
+    private
+      def validate_start_and_end_dates
+        if start_date.present? && end_date.present? && start_date > end_date
+          errors.add(:end_date, :smaller_than_start_date)
+        end
+      end
+
+      def set_commission
+        return if self.commission_in_percent.present?
+
+        self.commission_in_percent = Auctify.configuration.auctioneer_commission_in_percent
+      end
+  end
+end
+
+# == Schema Information
+#
+# Table name: auctify_sales_packs
+#
+#  id                      :bigint(8)        not null, primary key
+#  title                   :string
+#  description             :text
+#  position                :integer          default(0)
+#  slug                    :string
+#  place                   :string
+#  published               :boolean          default(FALSE)
+#  created_at              :datetime         not null
+#  updated_at              :datetime         not null
+#  sales_count             :integer          default(0)
+#  start_date              :date
+#  end_date                :date
+#  sales_interval          :integer          default(3)
+#  sales_beginning_hour    :integer          default(20)
+#  sales_beginning_minutes :integer          default(0)
+#  commission_in_percent   :integer
+#
+# Indexes
+#
+#  index_auctify_sales_packs_on_position   (position)
+#  index_auctify_sales_packs_on_published  (published)
+#  index_auctify_sales_packs_on_slug       (slug) UNIQUE
+#

data/app/serializers/auctify/sale/auction_serializer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Auctify::Sale::AuctionSerializer
+  include FastJsonapi::ObjectSerializer
+
+  attributes :id,
+             :current_price,
+             :current_minimal_bid,
+             :currently_ends_at,
+             :ends_at,
+             :open_for_bids?
+
+  attribute :current_winner do |auction|
+    winner = auction.current_winner
+    {
+      id: winner.id,
+      auctify_id: winner.auctify_id,
+      to_label: winner.to_label
+    }
+  end
+
+
+
+
+
+  # assert_equal auction.current_winner.id, json_attributes["current_winner"]["id"]
+  # assert_equal auction.current_winner.auctify_id, json_attributes["current_winner"]["auctify_id"]
+  # assert_equal auction.current_winner.to_label, json_attributes["current_winner"]["to_label"]
+  # assert_equal auction.current_price, json_attributes["current_price"]
+  # assert_equal auction.current_minimal_bid, json_attributes["current_minimal_bid"]
+  # assert_equal auction.ends_at, json_attributes["ends_at"]
+  # assert_equal auction.currently_ends_at, json_attributes["currently_ends_at"]
+  # assert_equal auction.open_for_bids?, json_attributes["open_for_bids?"]
+
+
+  # attributes :name, :year
+  # has_many :actors
+  # belongs_to :owner, record_type: :user
+  # belongs_to :movie_ty
+  # # link :url do |object|
+  # #   Rails.application
+  # #        .routes
+  # #        .url_helpers
+  # #        .url_for([object, only_path: true])
+  # # end
+end