auctify 1.0.0

data/app/concerns/auctify/behavior/buyer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Auctify
+  module Behavior
+    module Buyer
+      extend ActiveSupport::Concern
+
+      include Auctify::Behavior::Base
+
+      included do
+        has_many :purchases, as: :buyer, class_name: "Auctify::Sale::Base"
+        has_many :bidder_registrations, as: :bidder, class_name: "Auctify::BidderRegistration"
+      end
+    end
+  end
+end

data/app/concerns/auctify/behavior/item.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Auctify
+  module Behavior
+    module Item
+      extend ActiveSupport::Concern
+
+      include Auctify::Behavior::Base
+
+      included do
+        has_many :sales, class_name: "Auctify::Sale::Base", foreign_key: :item_id, inverse_of: :item
+        has_many :auction_sales, class_name: "Auctify::Sale::Auction", foreign_key: :item_id, inverse_of: :item
+        has_many :retail_sales, class_name: "Auctify::Sale::Retail", foreign_key: :item_id, inverse_of: :item
+
+        c_name = self.name
+        Auctify::Sale::Base.class_eval do
+          belongs_to :item, class_name: c_name, counter_cache: :sales_count
+        end
+
+        has_one :last_published_sale, -> { merge(Auctify::Sale::Base.latest_published_by_item) },
+                class_name: "Auctify::Sale::Base",
+                foreign_key: :item_id,
+                inverse_of: :item
+      end
+    end
+  end
+end

data/app/concerns/auctify/behavior/seller.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Auctify
+  module Behavior
+    module Seller
+      extend ActiveSupport::Concern
+
+      include Auctify::Behavior::Base
+
+      included do
+        has_many :sales, as: :seller, class_name: "Auctify::Sale::Base"
+        has_many :auction_sales, as: :seller, class_name: "Auctify::Sale::Auction"
+        has_many :retail_sales, as: :seller, class_name: "Auctify::Sale::Retail"
+
+        def offer_to_sale!(item, options = {})
+          assoc = options[:in] == :auction ? auction_sales : retail_sales
+
+          if item.class.included_modules.include?(Auctify::Behavior::Item)
+            assoc.create!(item: item,
+                          seller: self,
+                          buyer: nil,
+                          offered_price: options[:price],
+                          # FIXME @foton - this method will not be used in AA
+                          ends_at: options[:in] == :auction ? 1.day.from_now : nil)
+          else
+            sale = assoc.build(seller: self,
+                               buyer: nil,
+                               offered_price: options[:price])
+            sale.errors.add(:item, :not_auctified)
+            raise ActiveRecord::RecordInvalid.new(sale)
+          end
+        end
+      end
+    end
+  end
+end

data/app/concerns/auctify/sale/auction_callbacks.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Auctify
+  module Sale
+    module AuctionCallbacks
+      extend ActiveSupport::Concern
+
+      included do
+        CALLBACKS_WITHOUT_ARGS = %i[after_start_sale
+                                    before_bidding_is_close_to_end
+                                    after_close_bidding
+                                    after_sold_in_auction
+                                    after_not_sold_in_auction]
+        CALLBACKS_WITH_ARGS = %i[after_bid_appended
+                                 after_bid_not_appended ]
+
+
+        CALLBACKS_WITHOUT_ARGS.each do |cb|
+          define_method cb do
+            # override me, if You want
+            callback_runs[cb] += 1
+          end
+        end
+
+        def after_bid_appended(bid_appender)
+          # override me, if You want
+          # see bid_appender.result
+          # to get previous_winning bid, call `previous_winning_bid(bid_appender.bid)`
+          callback_runs[:after_bid_appended] += 1
+        end
+
+        def after_bid_not_appended(bid_appender)
+          # override me, if You want
+          # see bid_appender.errors
+          callback_runs[:after_bid_not_appended] += 1
+        end
+
+        def callback_runs
+          @callback_runs ||= (CALLBACKS_WITH_ARGS + CALLBACKS_WITHOUT_ARGS).index_with { |cb|  0 }
+        end
+      end
+    end
+  end
+end

data/app/controllers/auctify/api/v1/auctions_controller.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Auctify
+  module Api
+    module V1
+      class AuctionsController < Auctify::Api::V1::BaseController
+        before_action :find_auction, except: [:index]
+
+        def show
+          render_record @auction
+        end
+
+        def bids
+          if params[:confirmation] == "1"
+            if @auction.bid!(new_bid)
+              if params[:dont_confirm_bids] == "1"
+                # use SQL update in case of some obscure invalid attributes
+                current_user.bidder_registrations
+                            .where(auction: @auction)
+                            .update_all(dont_confirm_bids: true)
+              end
+
+              render_record @auction.reload, success: true
+            else
+              render_record @auction, bid: new_bid, status: 400
+            end
+          else
+            new_bid.errors.add(:base, :not_confirmed)
+            render_record @auction, bid: new_bid, status: 400
+          end
+        end
+
+        private
+          def find_auction
+            @auction = Auctify::Sale::Auction.find(params[:id])
+          end
+
+          def bid_params
+            params.require(:bid).permit(:max_price, :price)
+          end
+
+          def new_bid
+            @new_bid ||= Auctify::Bid.new(bid_params.merge(registration_params))
+          end
+
+          def registration_params
+            bidder_registration = @auction.bidder_registrations.find_by(bidder: current_user)
+            return  { registration: bidder_registration } if bidder_registration.present?
+
+            { bidder: current_user }
+          end
+
+          def render_record(auction, bid: nil, status: 200, success: nil)
+            render json: {
+              data: cell("#{global_namespace_path}/auctify/auctions/form", auction, bid: bid, success: success).show
+            }, status: status
+          end
+      end
+    end
+  end
+end

data/app/controllers/auctify/api/v1/base_controller.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Auctify
+  module Api
+    module V1
+      class BaseController < ApplicationController
+        include Folio::ApiControllerBase
+
+        # TODO handle authorization here if needed
+
+        private
+          def global_namespace_path
+            @global_namespace_path ||= global_namespace.underscore
+          end
+
+          def global_namespace
+            @global_namespace ||= Rails.application.class.name.deconstantize
+          end
+      end
+    end
+  end
+end

data/app/controllers/auctify/api/v1/console/bids_controller.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Auctify
+  module Api
+    module V1
+      module Console
+        class BidsController < Auctify::Api::V1::BaseController # Folio::Console::Api::BaseController
+          before_action :api_authenticate_account!
+          before_action :find_bid, except: [:index]
+
+          def destroy
+            auction = @bid.auction
+
+            if @bid.cancel!
+              render_list(auction.reload)
+            else
+              render_invalid(@bid)
+            end
+          end
+
+          private
+            def find_bid
+              @bid = Auctify::Bid.find(params[:id])
+            end
+
+            def api_authenticate_account!
+              fail CanCan::AccessDenied if current_account.blank?
+            end
+
+            def render_list(auction)
+              render json: { data: cell("folio/console/auctify/auctions/bid_list", auction).show }
+            end
+        end
+      end
+    end
+  end
+end

data/app/controllers/auctify/application_controller.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Auctify
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+    include Auctify::ApplicationHelper
+  end
+end

data/app/controllers/auctify/bidder_registrations_controller.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_dependency "auctify/application_controller"
+
+module Auctify
+  class BidderRegistrationsController < ApplicationController
+    before_action :set_bidder_registration, only: [:show, :edit, :update, :destroy]
+
+    # GET /bidder_registrations
+    def index
+      @bidder_registrations = BidderRegistration.all
+    end
+
+    # GET /bidder_registrations/1
+    def show
+    end
+
+    # GET /bidder_registrations/new
+    def new
+      @bidder_registration = BidderRegistration.new
+    end
+
+    # GET /bidder_registrations/1/edit
+    def edit
+    end
+
+    # POST /bidder_registrations
+    def create
+      @bidder_registration = BidderRegistration.new(bidder_registration_params)
+
+      if @bidder_registration.save
+        redirect_to @bidder_registration, notice: "Bidder registration was successfully created."
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /bidder_registrations/1
+    def update
+      if @bidder_registration.update(bidder_registration_params)
+        redirect_to @bidder_registration, notice: "Bidder registration was successfully updated."
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /bidder_registrations/1
+    def destroy
+      @bidder_registration.destroy
+      redirect_to auctify_bidder_registrations_url, notice: "Bidder registration was successfully destroyed."
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_bidder_registration
+        @bidder_registration = BidderRegistration.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def bidder_registration_params
+        params.require(:bidder_registration).permit(:bidder_id, :bidder_type, :auction_id, :aasm_state, :submitted_at,
+:handled_at)
+      end
+  end
+end

data/app/controllers/auctify/bids_controller.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_dependency "auctify/application_controller"
+
+module Auctify
+  class BidsController < ApplicationController
+    before_action :set_bid, only: [:show, :edit, :update, :destroy]
+
+    # GET /bids
+    def index
+      @bids = Bid.all
+    end
+
+    # GET /bids/1
+    def show
+    end
+
+    # GET /bids/new
+    def new
+      @bid = Bid.new
+    end
+
+    # GET /bids/1/edit
+    def edit
+    end
+
+    # POST /bids
+    def create
+      @bid = Bid.new(bid_params)
+
+      if @bid.save
+        redirect_to @bid, notice: "Bid was successfully created."
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /bids/1
+    def update
+      if @bid.update(bid_params)
+        redirect_to @bid, notice: "Bid was successfully updated."
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /bids/1
+    def destroy
+      @bid.destroy
+      redirect_to auctify_bids_url, notice: "Bid was successfully destroyed."
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_bid
+        @bid = Bid.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def bid_params
+        params.require(:bid).permit(:registration_id, :price, :max_price)
+      end
+  end
+end

data/app/controllers/auctify/sales_controller.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_dependency "auctify/application_controller"
+
+module Auctify
+  class SalesController < ApplicationController
+    before_action :set_sale, only: [:show, :edit, :update, :destroy]
+
+    # GET /sales
+    def index
+      @sales = scoped_sales.all
+    end
+
+    # GET /sales/1
+    def show
+    end
+
+    # GET /sales/new
+    def new
+      @sale = sale_class.new
+    end
+
+    # GET /sales/1/edit
+    def edit
+    end
+
+    # POST /sales
+    def create
+      @sale = sale_class.new(sale_params)
+
+      if @sale.save
+        redirect_to auctify_sale_path(@sale), notice: "Sale was successfully created."
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /sales/1
+    def update
+      if @sale.update(sale_params)
+        redirect_to auctify_sale_path(@sale), notice: "Sale was successfully updated."
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /sales/1
+    def destroy
+      @sale.destroy
+      redirect_to auctify_sales_url, notice: "Sale was successfully destroyed."
+    end
+
+    private
+      def sale_class
+        Sale::Base
+      end
+
+      # Use callbacks to share common setup or constraints between actions.
+      def set_sale
+        @sale = scoped_sales.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def sale_params
+        params.require(:sale).permit(:seller_auctify_id, :buyer_auctify_id, :item_auctify_id, :published)
+      end
+
+      def scoped_sales
+        scope = sale_class
+        return scope if params[:list_all].to_s == "1"
+
+        scope.published.not_sold
+      end
+  end
+end