stall 0.1.1 → 0.1.2

data/app/models/shipping_method.rb

@@ -0,0 +1,3 @@
+class ShippingMethod < ActiveRecord::Base
+  include Stall::Models::ShippingMethod
+end

data/app/models/stall/models.rb

@@ -0,0 +1,4 @@
+module Stall
+  module Models
+  end
+end

data/app/models/stall/models/address.rb

@@ -0,0 +1,45 @@
+module Stall
+  module Models
+    module Address
+      extend ActiveSupport::Concern
+
+      included do
+        self.table_name = 'stall_addresses'
+
+        has_one :address_ownership, dependent: :destroy
+
+        enum civility: { :m => 1, :mme => 2 }
+
+        def self.civility_enum
+          civilities.each_with_object({}) do |(key, value), hash|
+            hash[I18n.t("stall.addresses.civilities.#{ key }")] = key
+          end
+        end
+
+        def civility_name
+          I18n.t("stall.addresses.civilities.#{ civility }")
+        end
+
+        def country_name
+          if iso_country
+            iso_country.translations[I18n.locale.to_s] || iso_country.name
+          end
+        end
+
+        def state_name
+          iso_state['name'] if iso_state
+        end
+
+        private
+
+        def iso_country
+          @iso_country ||= country && ISO3166::Country[country]
+        end
+
+        def iso_state
+          @iso_state ||= iso_country.subdivisions[state] if iso_country && state
+        end
+      end
+    end
+  end
+end

data/app/models/stall/models/address_ownership.rb

@@ -0,0 +1,26 @@
+module Stall
+  module Models
+    module AddressOwnership
+      extend ActiveSupport::Concern
+
+      included do
+        self.table_name = 'stall_address_ownerships'
+
+        belongs_to :address, inverse_of: :address_ownership
+        accepts_nested_attributes_for :address
+
+        belongs_to :addressable, polymorphic: true
+      end
+
+      [:shipping, :billing].each do |type|
+        define_method(:"mark_as_#{ type }") do
+          if (ownership = addressable.address_ownership_for(type)) && ownership != self
+            ownership.send(:"#{ type }=", false)
+          end
+
+          send(:"#{ type }=", true)
+        end
+      end
+    end
+  end
+end

data/app/models/stall/models/adjustment.rb

@@ -0,0 +1,49 @@
+module Stall
+  module Models
+    module Adjustment
+      extend ActiveSupport::Concern
+
+      included do
+        self.table_name = 'stall_adjustments'
+
+        monetize :eot_price_cents, :price_cents,
+                 with_model_currency: :currency, allow_nil: true
+
+        belongs_to :cart
+
+        delegate :currency, to: :cart, allow_nil: true
+
+        validates :name, :price, :eot_price, :vat_rate, :cart, presence: true
+
+        before_validation :fill_eot_price_and_vat_rate
+
+        define_method(:eot_price) do
+          if (eot_price = read_attribute(:eot_price)) && eot_price.to_f != 0
+            eot_price
+          else
+            default_eot_price
+          end
+        end
+      end
+
+      def vat_rate
+        read_attribute(:vat_rate) || Stall.config.vat_rate
+      end
+
+      def vat
+        price - eot_price
+      end
+
+      private
+
+      def fill_eot_price_and_vat_rate
+        self.vat_rate = vat_rate
+        self.eot_price = eot_price
+      end
+
+      def default_eot_price
+        (price / (1.0 + (vat_rate / 100.0))) if price && vat_rate
+      end
+    end
+  end
+end

data/app/models/stall/models/cart.rb

@@ -0,0 +1,37 @@
+module Stall
+  module Models
+    module Cart
+      extend ActiveSupport::Concern
+
+      included do
+        include Stall::Addressable
+        include Stall::Payable
+
+        has_one :shipment, dependent: :destroy, inverse_of: :cart
+        accepts_nested_attributes_for :shipment
+
+        has_many :adjustments, dependent: :destroy, inverse_of: :cart
+        accepts_nested_attributes_for :adjustments
+      end
+
+      def total_weight
+        line_items.reduce(0) do |total, line_item|
+          total + (line_item.weight || Stall.config.default_product_weight)
+        end
+      end
+
+      def active?
+        !paid?
+      end
+
+      private
+
+      def items
+        items = line_items.to_a
+        items << shipment if shipment
+        items += adjustments.to_a
+        items
+      end
+    end
+  end
+end

data/app/models/stall/models/customer.rb

@@ -0,0 +1,18 @@
+module Stall
+  module Models
+    module Customer
+      extend ActiveSupport::Concern
+
+      included do
+        self.table_name = 'stall_customers'
+
+        include Stall::Addressable
+
+        belongs_to :user, polymorphic: true, inverse_of: :customer
+        accepts_nested_attributes_for :user
+
+        has_many :product_lists, dependent: :destroy
+      end
+    end
+  end
+end

data/app/models/stall/models/line_item.rb

@@ -0,0 +1,57 @@
+module Stall
+  module Models
+    module LineItem
+      extend ActiveSupport::Concern
+
+      included do
+        self.table_name = 'stall_line_items'
+
+        include Stall::Priceable
+
+        store_accessor :data, :weight
+
+        monetize :unit_eot_price_cents, :unit_price_cents,
+                 :eot_price_cents, :price_cents,
+                 with_model_currency: :currency, allow_nil: true
+
+        belongs_to :sellable, polymorphic: true
+        belongs_to :product_list
+
+        validates :name, :unit_price, :unit_eot_price, :vat_rate, :price, :quantity,
+                  :eot_price, :sellable, presence: true
+
+        validates :unit_price, :unit_eot_price, :vat_rate, :price, :eot_price,
+                  numericality: true
+
+        validates :quantity, numericality: { greater_than: 0 }
+
+        validate  :stock_availability
+
+        before_validation :refresh_total_prices
+
+        scope :ordered, -> { order(created_at: :asc) }
+      end
+
+      def like?(other)
+        [:sellable_id, :sellable_type].all? do |property|
+          public_send(property) == other.public_send(property)
+        end
+      end
+
+      def currency
+        product_list.try(:currency) || Money.default_currency
+      end
+
+      private
+
+      # TODO : Stocks availibility handling
+      def stock_availability
+      end
+
+      def refresh_total_prices
+        self.eot_price = unit_eot_price * quantity if unit_eot_price && quantity
+        self.price     = unit_price     * quantity if unit_price     && quantity
+      end
+    end
+  end
+end

data/app/models/stall/models/payment.rb

@@ -0,0 +1,33 @@
+module Stall
+  module Models
+    module Payment
+      extend ActiveSupport::Concern
+
+      included do
+        self.table_name = 'stall_payments'
+
+        store_accessor :data, :transaction_id
+
+        belongs_to :payment_method
+        belongs_to :cart
+
+        validates :cart, :payment_method, presence: true
+
+        scope :pending, -> { where(paid_at: nil) }
+        scope :paid, -> { where.not(paid_at: nil) }
+      end
+
+      def pay!
+        update_attributes!(paid_at: Time.now)
+      end
+
+      def paid?
+        paid_at != nil
+      end
+
+      def state
+        paid? ? :paid : :pending
+      end
+    end
+  end
+end

data/app/models/stall/models/payment_method.rb

@@ -0,0 +1,18 @@
+module Stall
+  module Models
+    module PaymentMethod
+      extend ActiveSupport::Concern
+
+      included do
+        self.table_name = 'stall_payment_methods'
+
+        has_many :payments, dependent: :nullify
+
+        validates :name, :identifier, presence: true
+
+        scope :ordered, -> { order('stall_payment_methods.name ASC') }
+        scope :active, -> { where(active: true) }
+      end
+    end
+  end
+end

data/app/models/stall/models/product_list.rb

@@ -0,0 +1,147 @@
+module Stall
+  module Models
+    module ProductList
+      extend ActiveSupport::Concern
+
+      included do
+        self.table_name = 'stall_product_lists'
+
+        store_accessor :data, :reference
+
+        has_secure_token
+
+        has_many :line_items, -> { ordered }, dependent: :destroy
+        accepts_nested_attributes_for :line_items, allow_destroy: true
+
+        belongs_to :customer
+        accepts_nested_attributes_for :customer
+
+        validates :type, presence: true
+
+        after_initialize :ensure_currency
+        after_initialize :ensure_state
+
+        after_save :ensure_reference, on: :create
+
+        scope :empty, -> {
+          joins(
+            'LEFT JOIN stall_line_items ' \
+            'ON stall_product_lists.id = stall_line_items.product_list_id'
+          ).where(stall_line_items: { id: nil })
+        }
+
+        scope :filled, -> { joins(:line_items) }
+
+        scope :older_than, ->(date) {
+          where('stall_product_lists.updated_at < ?', date)
+        }
+      end
+
+      def state
+        read_attribute(:state).try(:to_sym)
+      end
+
+      def reset_state!
+        update_column(:state, wizard.steps.first)
+      end
+
+      def to_param
+        persisted? ? token : 'empty-cart'
+      end
+
+      def subtotal
+        price = line_items.map(&:price).sum
+        price = Money.new(price, currency) unless Money === price
+        price
+      end
+
+      def eot_subtotal
+        line_items.map(&:eot_price).sum
+      end
+
+      def total_price
+        price = items.map(&:price).sum
+        price = Money.new(price, currency) unless Money === price
+        price
+      end
+
+      def total_eot_price
+        items.map(&:eot_price).sum
+      end
+
+      def total_vat
+        items.map(&:vat).sum
+      end
+
+      def total_quantity
+        line_items.map(&:quantity).sum
+      end
+
+      def wizard
+        @wizard ||= self.class.wizard
+      end
+
+      def checkoutable?
+        line_items.length > 0
+      end
+
+      def active?
+        true
+      end
+
+      private
+
+      def ensure_currency
+        self.currency ||= Money.default_currency
+      end
+
+      def ensure_state
+        self.state ||= (wizard.try(:steps).try(:first) || 'pending')
+      end
+
+      def items
+        line_items.to_a
+      end
+
+      def ensure_reference
+        unless reference.present?
+          reference = [Time.now.strftime('%Y%m%d'), ('%05d' % id)].join('-')
+          self.reference = reference
+          save(validate: false)
+        end
+      end
+
+      module ClassMethods
+        def find_by_reference(reference)
+          where("data->>'reference' = ?", reference).first
+        end
+
+        # The .aborted and .finalized scopes cannot be declared as actual rails
+        # scopes since subclasses that override the .wizard method wouldn't
+        # be taken into account, scopes being executed in the context of the
+        # declaring class
+        #
+        def aborted(options = {})
+          where.not(state: wizard.steps.last)
+            .older_than(options.fetch(:before, 1.day.ago))
+        end
+
+        def finalized
+          where(state: wizard.steps.last)
+        end
+
+        def wizard
+          wizard_name = Stall.config.default_checkout_wizard
+
+          if (wizard = Stall::Utils.try_load_constant(wizard_name))
+            wizard
+          else
+            raise Stall::Checkout::WizardNotFoundError.new,
+              "The checkout wizard #{ wizard_name } was not found. You must generate it " +
+              "with `rails g stall:wizard #{ wizard_name.underscore.gsub('_checkout_wizard', '') }`"
+          end
+        end
+      end
+    end
+  end
+end