spina-shop 0.1.0

data/app/models/spina/shop/discount_action.rb

@@ -0,0 +1,16 @@
+module Spina::Shop
+  class DiscountAction < ApplicationRecord
+    include Preferable
+
+    belongs_to :discount
+
+    def compute(order_item)
+      true
+    end
+  end
+end
+
+# Necessary for STI and the descendants method
+Dir[Spina::Shop::Engine.root.join *%w(app models spina discounts actions *) ].each do |file|
+  require_dependency file
+end

data/app/models/spina/shop/discount_rule.rb

@@ -0,0 +1,17 @@
+module Spina::Shop
+  class DiscountRule < ApplicationRecord
+    include Preferable
+    
+    belongs_to :discount
+
+    def eligible?(order_item)
+      true
+    end
+
+  end
+end
+
+# Necessary for STI and the descendants method
+Dir[Spina::Shop::Engine.root.join *%w(app models spina discounts rules *) ].each do |file|
+  require_dependency file
+end

data/app/models/spina/shop/discounts/actions/percent_off.rb

@@ -0,0 +1,17 @@
+module Spina::Shop
+  module Discounts
+    module Actions
+      class PercentOff < DiscountAction
+        
+        preferences :percent_off
+
+        validates :percent_off, presence: true, numericality: {only_integer: true, greater_than_or_equal_to: 0, less_than_or_equal_to: 100}
+
+        def compute(order_item)
+          (order_item.total_without_discount * percent_off.to_i / 100).round(2)
+        end
+
+      end
+    end
+  end
+end

data/app/models/spina/shop/discounts/rules/all_orders.rb

@@ -0,0 +1,13 @@
+module Spina::Shop
+  module Discounts
+    module Rules
+      class AllOrders < DiscountRule
+
+        def eligible?(order_item)
+          true
+        end
+
+      end
+    end
+  end
+end

data/app/models/spina/shop/discounts/rules/collection.rb

@@ -0,0 +1,14 @@
+module Spina::Shop
+  module Discounts
+    module Rules
+      class Collection < DiscountRule
+        preferences :collection_id
+
+        def eligible?(order_item)
+          true
+        end
+
+      end
+    end
+  end
+end

data/app/models/spina/shop/discounts/rules/order_total.rb

@@ -0,0 +1,17 @@
+module Spina::Shop
+  module Discounts
+    module Rules
+      class OrderTotal < DiscountRule
+        preferences :total
+
+        validates :total, presence: true, numericality: true
+
+        def eligible?(order_item)
+          # order_item.order.order_total >= total
+          true
+        end
+
+      end
+    end
+  end
+end

data/app/models/spina/shop/discounts_order.rb

@@ -0,0 +1,6 @@
+module Spina::Shop
+  class DiscountsOrder < ApplicationRecord
+    belongs_to :discount
+    belongs_to :order
+  end
+end

data/app/models/spina/shop/favorite.rb

@@ -0,0 +1,8 @@
+module Spina::Shop
+  class Favorite < ApplicationRecord
+    belongs_to :customer
+    belongs_to :product
+
+    validates :customer_id, uniqueness: {scope: :product_id}
+  end
+end

data/app/models/spina/shop/gift_card.rb

@@ -0,0 +1,53 @@
+module Spina::Shop
+  class GiftCard < ApplicationRecord
+    before_create :generate_unique_code
+    before_create :set_remaining_balance
+
+    scope :available, -> { where('remaining_balance > ?', BigDecimal(0)).where('expires_at > ?', Date.today) }
+
+    has_many :gift_cards_orders
+    has_many :orders, through: :gift_cards_orders, dependent: :restrict_with_exception
+
+    validates :expires_at, :value, :remaining_balance, presence: true
+    validates :value, numericality: {greater_than: 0}
+
+    def amount_for_order(order)
+      [remaining_balance, order.total].min
+    end
+
+    def readable_code
+      code.insert(4, ' - ')
+    end
+
+    def expired?
+      expires_at < Date.today
+    end
+
+    def status
+      if remaining_balance == BigDecimal(0)
+        'used'
+      elsif expired?
+        'expired'
+      elsif remaining_balance == value
+        'unused'
+      else
+        'partially_used'
+      end
+    end
+
+    private
+
+      # Generate a pretty and readable code with distinct characters
+      def generate_unique_code(size: 8)
+        begin
+          charset = %w{2 3 4 6 7 9 A C D E F G H J K M N P Q R T V W X Y Z}
+          self['code'] = (0...size).map{charset.to_a[SecureRandom.random_number(charset.size)]}.join
+        end while GiftCard.exists?(code: self['code'])
+      end
+
+      def set_remaining_balance
+        self.remaining_balance = value
+      end
+
+  end
+end

data/app/models/spina/shop/gift_cards_order.rb

@@ -0,0 +1,6 @@
+module Spina::Shop
+  class GiftCardsOrder < ApplicationRecord
+    belongs_to :gift_card
+    belongs_to :order
+  end
+end

data/app/models/spina/shop/in_stock_reminder.rb

@@ -0,0 +1,7 @@
+module Spina::Shop
+  class InStockReminder < ApplicationRecord
+    belongs_to :orderable, polymorphic: true
+
+    validates :email, email: true, presence: true, uniqueness: {scope: [:orderable_id, :orderable_type]}
+  end
+end

data/app/models/spina/shop/invoice.rb

@@ -0,0 +1,49 @@
+module Spina::Shop
+  class Invoice < ApplicationRecord
+    belongs_to :order
+    belongs_to :customer
+    belongs_to :country
+
+    has_many :invoice_lines, dependent: :destroy
+
+    def filename
+      "inv_#{invoice_number}.pdf"
+    end
+
+    def sub_total
+      if prices_include_tax
+        invoice_lines.inject(BigDecimal(0)) { |t, i| t + (i.total / i.tax_modifier).round(2) }
+      else
+        invoice_lines.inject(BigDecimal(0)) { |t, i| t + i.total }
+      end
+    end
+
+    def tax_amount
+      tax_amount_by_rates.inject(BigDecimal(0)) { |t, r| t + r[1][:tax_amount] }
+    end
+
+    def total
+      sub_total + tax_amount
+    end
+
+    def tax_amount_by_rates
+      if prices_include_tax
+        rates = invoice_lines.inject({}) do |h, line|
+          rate = h[line.tax_rate] ||= { tax_amount: BigDecimal(0), total: BigDecimal(0) }
+          rate[:total] += (line.total / line.tax_modifier).round(2)
+          rate[:tax_amount] += line.total - (line.total / line.tax_modifier).round(2)
+          h
+        end
+      else
+        rates = invoice_lines.inject({}) do |h, line|
+          rate = h[line.tax_rate] ||= { tax_amount: BigDecimal(0), total: BigDecimal(0) }
+          rate[:total] += line.total
+          rate[:tax_amount] += (line.total * (BigDecimal(line.tax_rate) / BigDecimal(100))).round(2)
+          h
+        end
+      end
+
+      rates.sort{|x, y| y[0] <=> x[0]}.to_h
+    end
+  end
+end

data/app/models/spina/shop/invoice_line.rb

@@ -0,0 +1,13 @@
+module Spina::Shop
+  class InvoiceLine < ApplicationRecord
+    belongs_to :invoice
+
+    def total
+      quantity * unit_price
+    end
+
+    def tax_modifier
+      (tax_rate + BigDecimal(100)) / BigDecimal(100)
+    end
+  end
+end

data/app/models/spina/shop/number_sequence.rb

@@ -0,0 +1,19 @@
+module Spina::Shop
+  class NumberSequence < ApplicationRecord
+    validates :name, :next_number, presence: true
+    validates :next_number, uniqueness: {scope: :name}
+
+    def self.by_name(name)
+      NumberSequence.where(name: name).first_or_create!
+    end
+
+    def increment!
+      with_lock do
+        number = next_number
+        self.next_number = number + 1
+        save!
+        number
+      end
+    end
+  end
+end

data/app/models/spina/shop/order.rb

@@ -0,0 +1,222 @@
+module Spina::Shop
+  class Error < StandardError; end
+end
+
+module Spina::Shop
+  class Order < ApplicationRecord
+    require_dependency 'spina/shop/order/state_machine_transitions'
+    require_dependency 'spina/shop/order/billing'
+
+    has_secure_token
+
+    attr_accessor :validate_details, :validate_stock, :validate_delivery, :validate_payment, :password
+
+    belongs_to :customer, optional: true
+    belongs_to :billing_country, class_name: "Spina::Shop::Country"
+    belongs_to :delivery_country, class_name: "Spina::Shop::Country", optional: true
+    belongs_to :delivery_option, optional: true
+    belongs_to :duplicate, class_name: "Spina::Shop::Order", optional: true
+
+    has_many :order_transitions, autosave: false, dependent: :destroy
+    has_many :order_items, dependent: :destroy # Destroy order items if the order is destroyed as well
+    has_many :invoices, dependent: :restrict_with_exception
+    has_many :order_attachments, dependent: :destroy
+    has_one :shop_review, dependent: :destroy
+
+    has_one :discounts_order, class_name: "Spina::Shop::DiscountsOrder"
+    has_one :discount, through: :discounts_order, class_name: "Spina::Shop::Discount"
+    has_one :gift_cards_order, class_name: "Spina::Shop::GiftCardsOrder"
+    has_one :gift_card, through: :gift_cards_order, class_name: "Spina::Shop::GiftCard"
+
+    scope :sorted, -> { order(order_number: :desc, id: :desc) }
+    scope :received, -> { where.not(received_at: nil) }
+    scope :prepared, -> { where.not(order_prepared_at: nil) }
+    scope :confirmed, -> { where.not(confirming_at: nil) }
+    scope :paid, -> { where.not(paid_at: nil) }
+    scope :building, -> { in_state(:building) }
+
+    # Always validate
+    validates :password, confirmation: true
+    validates :password, length: {minimum: 6, maximum: 40}, allow_blank: true
+
+    # Validate when after checkout phase
+    validates :order_number, presence: true, uniqueness: true, unless: -> { in_state?(:building) }
+
+    # Validate details
+    validates :first_name, :last_name, :email, :billing_street1, :billing_city, :billing_postal_code, :billing_house_number, :billing_country_id, presence: true, if: -> { validate_details }
+    validates :delivery_name, :delivery_street1, :delivery_city, :delivery_postal_code, :delivery_house_number, presence: true, if: -> { validate_details && separate_delivery_address? }
+    validates :email, email: true, if: -> { validate_details }
+    validate :must_be_of_age_to_buy_products, if: -> { validate_details }
+
+    # Validate delivery
+    validates :delivery_option, presence: true, if: -> { validate_delivery }
+
+    # Validate payment
+    validates :payment_method, presence: true, if: -> { validate_payment }
+
+    # Validate Stock
+    validate :items_must_be_in_stock, if: -> { validate_stock }
+    validate :must_have_at_least_one_item, if: -> { validate_stock }
+
+    accepts_nested_attributes_for :order_items
+
+    # Override addresses if necessary
+    [:delivery_name, :delivery_street1, :delivery_postal_code, :delivery_city, :delivery_house_number, :delivery_house_number_addition, :delivery_country].each do |f|
+      define_method(f) do
+        separate_delivery_address? ? super() : send(f.to_s.gsub('delivery_', 'billing_'))
+      end
+    end
+
+    def billing_address
+      "#{billing_street1} #{billing_house_number}#{billing_house_number_addition}".strip
+    end
+
+    def delivery_address
+      "#{delivery_street1} #{delivery_house_number}#{delivery_house_number_addition}".strip
+    end
+
+    def assign_address(address, address_type:)
+      [:street1, :postal_code, :city, :house_number, :house_number_addition, :country].each do |f|
+        send("#{address_type}_#{f}=", address.send(f))
+      end
+    end
+
+    def delivery_options
+      DeliveryOption.all
+    end
+
+    def soonest_delivery_date
+      delivery_option.try(:soonest_delivery_date_for_order, self)
+    end
+
+    def empty?
+      order_items.none?
+    end
+
+    def requires_shipping?
+      delivery_option.try(:requires_shipping)
+    end
+
+    def products
+      order_items.map do |order_item|
+        if order_item.is_product_bundle?
+          order_item.orderable.products
+        else
+          order_item.orderable
+        end
+      end.flatten.uniq
+    end
+
+    # By default this method returns false, but you can override it and add your own logic
+    def vat_reverse_charge?
+      false
+    end
+
+    # If VAT is reverse charged, all prices must be excluding VAT
+    def prices_include_tax
+      vat_reverse_charge? ? false : read_attribute(:prices_include_tax)
+    end
+
+    # Order number with zeroes
+    def number
+      order_number ? order_number.to_s.rjust(8, '0') : nil
+    end
+
+    def billing_name
+      full_name = "#{first_name} #{last_name}".strip
+      company.present? ? "#{company} (#{full_name})" : full_name
+    end
+
+    def total_items
+      order_items.sum(:quantity)
+    end
+
+    def total_weight
+      order_items.inject(BigDecimal(0)) { |t, i| t + i.total_weight }
+    end
+
+    def total_weight_in_ounces
+      Measurement.parse("#{total_weight} gr").convert_to(:oz).quantity
+    end
+
+    def merge!(order)
+      raise Error if confirmed? || order.confirmed?
+
+      transaction do
+        order.order_items.where(orderable: order_items.map(&:orderable)).each do |duplicate|
+          current_order_item = order_items.find_by(orderable: duplicate.orderable)
+          current_order_item.increment(:quantity, duplicate.quantity)
+          current_order_item.save
+        end
+
+        order.order_items.where(orderable: order_items.map(&:orderable)).destroy_all
+        order.order_items.update_all(order_id: id)
+      end
+    end
+
+    def age
+      now = Time.zone.now
+      if date_of_birth
+        now.year - date_of_birth.year - ((now.month > date_of_birth.month || (now.month == date_of_birth.month && now.day >= date_of_birth.day)) ? 0 : 1)
+      end
+    end
+
+    def of_age?
+      age >= 18 if age
+    end
+
+    def apply_gift_card!
+      transaction do
+        update_attributes!(gift_card_amount: gift_card_amount)
+        gift_card.update_attributes!(remaining_balance: gift_card.remaining_balance - gift_card_amount)
+      end
+    end
+
+    def remove_gift_card!
+      transaction do
+        gift_card.update_attributes!(remaining_balance: gift_card.remaining_balance + gift_card_amount)
+        update_attributes!(gift_card_amount: nil)
+      end
+    end
+
+    def duplicate!
+      # Duplicate order
+      transaction do
+        shopping_cart = Order.create!(attributes.reject{|key, value| key.in? %w(id delivery_price delivery_tax_rate status received_at shipped_at paid_at delivered_at order_prepared_at payment_id payment_url failed_at cancelled_at delivery_tracking_ids picked_up_at order_number confirming_at created_at updated_at)})
+        shopping_cart.discount = discount
+        shopping_cart.gift_card = gift_card
+        order_items.each do |order_item|
+          OrderItem.create!(order_item.attributes.reject{|key, value| key.in? %w(id created_at updated_at unit_price unit_cost_price discount_amount weight tax_rate order_id)}.merge(order_id: shopping_cart.id))
+        end
+        update_attributes!(duplicate: shopping_cart)
+      end
+    end
+
+    def everything_valid?
+      self.validate_details = true
+      self.validate_stock = true
+      self.validate_payment = true
+      self.validate_delivery = true
+      valid?
+    end
+
+    private
+
+      def items_must_be_in_stock
+        errors.add(:stock_level, "not sufficient") unless order_items.all?(&:in_stock?)
+      end
+
+      def must_have_at_least_one_item
+        if order_items.none?
+          errors.add(:shopping_cart, "empty")
+        end
+      end
+
+      def must_be_of_age_to_buy_products
+        if order_items.any?{|item| item.orderable.must_be_of_age_to_buy?}
+          errors.add(:date_of_birth, :not_of_age) unless of_age?
+        end
+      end
+
+  end
+end