spina-shop 0.1.0

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

@@ -0,0 +1,85 @@
+module Spina::Shop
+  class Order < ApplicationRecord
+
+    def order_total
+      order_items.inject(BigDecimal(0)) { |t, i| t + i.total }
+    end
+
+    def delivery_price
+      read_attribute(:delivery_price) || delivery_option.try(:price_for_order, self) || BigDecimal(0)
+    end
+
+    def delivery_tax_rate
+      read_attribute(:delivery_tax_rate) || delivery_option.try(:tax_group).try(:tax_rate_for_order, self) || BigDecimal(0)
+    end
+
+    def delivery_tax_modifier
+      (delivery_tax_rate + BigDecimal(100)) / BigDecimal(100)
+    end
+
+    def gift_card_amount
+      read_attribute(:gift_card_amount) || gift_card.try(:amount_for_order, self) || BigDecimal(0)
+    end
+
+    def billing_first_name
+      first_name
+    end
+
+    def billing_last_name
+      last_name
+    end
+
+    # Total of the order
+    def total
+      order_total + delivery_price + (prices_include_tax ? 0 : tax_amount)
+    end
+
+    def total_excluding_tax
+      total - tax_amount
+    end
+
+    def to_be_paid
+      total - gift_card_amount
+    end
+
+    # Mandatory rounding to 0.05 for cash payments in a store
+    def to_be_paid_round
+      (to_be_paid * 2).round(1, :half_up) / 2
+    end
+
+    def to_be_paid_rounding_difference
+      to_be_paid_round - to_be_paid
+    end
+
+    def nothing_owed?
+      paid? || to_be_paid == BigDecimal(0)
+    end
+
+    def tax_amount
+      tax_amount_by_rates.inject(BigDecimal.new(0)) { |t, r| t + r[1][:tax_amount] }
+    end
+
+    def tax_amount_by_rates
+      if vat_reverse_charge?
+        rates = {"0": {tax_amount: BigDecimal.new(0), total: BigDecimal.new(0)}}
+      else
+        items = [order_items]
+        items << OpenStruct.new(tax_rate: delivery_tax_rate, tax_modifier: delivery_tax_modifier, total: delivery_price) if delivery_option.present?
+        rates = items.flatten.inject({}) do |h, item|
+          rate = h[item.tax_rate] ||= { tax_amount: BigDecimal(0), total: BigDecimal(0) }
+          if prices_include_tax
+            rate[:total] += (item.total / item.tax_modifier).round(2)
+            rate[:tax_amount] += item.total - (item.total / item.tax_modifier).round(2)
+          else
+            rate[:total] += item.total
+            rate[:tax_amount] += (item.total * (BigDecimal(item.tax_rate) / BigDecimal(100))).round(2)
+          end
+          h
+        end
+      end
+
+      rates.sort{|x, y| y[0] <=> x[0]}.to_h
+    end
+
+  end
+end

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

@@ -0,0 +1,106 @@
+module Spina::Shop
+  class Order < ApplicationRecord
+    include Statesman::Adapters::ActiveRecordQueries
+
+    delegate :can_transition_to?, :allowed_transitions, :history, :in_state?, :last_transition, :transition_to!, :transition_to, :current_state, to: :state_machine
+
+    def received?
+      received_at.present?
+    end
+
+    def failed?
+      failed_at.present?
+    end
+
+    def cancelled?
+      cancelled_at.present?
+    end
+
+    def confirmed?
+      confirming_at.present?
+    end
+
+    def paid?
+      paid_at.present?
+    end
+
+    def order_prepared?
+      order_prepared_at.present?
+    end
+
+    def shipped?
+      shipped_at.present?
+    end
+
+    def delivered?
+      delivered_at.present?
+    end
+
+    def picked_up?
+      picked_up_at.present?
+    end
+
+    def building?
+      current_state == 'building'
+    end
+
+    def confirming?
+      current_state == 'confirming'
+    end
+
+    def status_progress
+      if delivered? || picked_up?
+        100
+      elsif shipped?
+        80
+      elsif order_prepared?
+        60
+      elsif paid?
+        40
+      elsif received?
+        20
+      else
+        0
+      end
+    end
+
+    def status_css_class
+      case current_state
+      when 'preparing'
+        'primary'
+      when 'paid'
+        'primary'
+      when 'shipped'
+        'success'
+      when 'delivered'
+        'success'
+      when 'picked_up'
+        'success'
+      when 'failed'
+        'danger'
+      when 'cancelled'
+        'danger'
+      else
+        ''
+      end
+    end
+
+    def state_machine
+      @state_machine ||= OrderStateMachine.new(self, transition_class: OrderTransition, association_name: :order_transitions)
+    end
+
+    def self.transition_name
+      :order_transitions
+    end
+
+    def self.transition_class
+      OrderTransition
+    end
+    private_class_method :transition_class
+
+    def self.initial_state
+      :building
+    end
+    private_class_method :initial_state
+  end
+end

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

@@ -0,0 +1,9 @@
+module Spina::Shop
+  class OrderAttachment < ApplicationRecord
+    belongs_to :order
+
+    attachment :attachment
+
+    validates :name, presence: true
+  end
+end

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

@@ -0,0 +1,101 @@
+module Spina::Shop
+  class OrderItem < ApplicationRecord
+    attr_accessor :validate_stock
+
+    belongs_to :order
+    belongs_to :orderable, polymorphic: true
+
+    has_many :stock_level_adjustments, dependent: :nullify # Don't destroy the stock level adjustments automatically if an order is destroyed
+
+    validates :unit_price, :unit_cost_price, :tax_rate, :weight, presence: true, if: -> { order.try(:received?) }
+    validate :item_must_be_in_stock, if: -> { validate_stock }
+    validates :order_id, uniqueness: {scope: [:orderable_id, :orderable_type]}
+
+    scope :ordered, -> { order(:created_at) }
+
+    def unit_price
+      read_attribute(:unit_price) || orderable.price_for_order(order) || BigDecimal(0)
+    end
+
+    def unit_cost_price
+      read_attribute(:unit_cost_price) || orderable.cost_price || BigDecimal(0)
+    end
+
+    def tax_rate
+      read_attribute(:tax_rate) || orderable.tax_group.tax_rate_for_order(order) || BigDecimal(0)
+    end
+
+    # Discount as amount
+    def discount_amount
+      read_attribute(:discount_amount) || order.discount.try(:discount_for_order_item, self) || BigDecimal(0)
+    end
+
+    def weight
+      read_attribute(:weight) || orderable.weight || BigDecimal(0)
+    end
+
+    def description
+      orderable.name
+    end
+
+    def total_without_discount
+      unit_price * quantity
+    end
+
+    def total
+      total_without_discount - discount_amount
+    end
+
+    def tax_modifier
+      (tax_rate + BigDecimal(100)) / BigDecimal(100)
+    end
+
+    def total_weight
+      quantity * weight
+    end
+
+    def in_stock?
+      if is_product_bundle?
+        orderable.bundled_products.all?{|p| product_in_stock?(p.product_id)}
+      else
+        product_in_stock?(orderable_id)
+      end
+    end
+
+    def is_product_bundle?
+      orderable_type == "Spina::Shop::ProductBundle"
+    end
+
+    def allocated_stock(product_id)
+      -stock_level_adjustments.where(product_id: product_id).sum(:adjustment)
+    end
+
+    def unallocated_stock(product_id)
+      multiplier = if is_product_bundle? 
+        orderable.bundled_products.find_by(product_id: product_id).try(:quantity).to_i 
+      else
+        orderable_id == product_id ? 1 : 0
+      end
+      quantity * multiplier - allocated_stock(product_id)
+    end
+
+    private
+
+      def product_in_stock?(product_id)
+        # Add itself to an array of order items 
+        # If the record isn't persisted yet it won't show up in order.order_items
+        order_items = order.order_items.to_a | [self]
+        product = Product.find(product_id)
+        return true unless product.stock_enabled
+        product.stock_level >= order_items.inject(BigDecimal(0)) do |total, order_item|
+          order_item.quantity = quantity if order_item == self
+          total + order_item.unallocated_stock(product_id)
+        end
+      end
+
+      def item_must_be_in_stock
+        errors.add(:stock_level, "not sufficient") unless in_stock?
+      end
+
+  end
+end

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

@@ -0,0 +1,5 @@
+module Spina::Shop
+  class OrderTransition < ApplicationRecord
+    belongs_to :order, inverse_of: :order_transitions
+  end
+end

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

@@ -0,0 +1,227 @@
+module Spina::Shop
+  class Product < ApplicationRecord
+    # Stores the old path when generating a new materialized_path
+    attr_accessor :old_path
+
+    belongs_to :tax_group
+    belongs_to :sales_category
+    belongs_to :product_category, optional: true
+
+    has_many :product_images, dependent: :destroy
+    has_many :product_reviews, dependent: :destroy
+    has_many :product_relations, dependent: :destroy
+    has_many :related_products, through: :product_relations
+    has_many :favorites, dependent: :destroy
+    has_many :collectables, dependent: :destroy
+    has_many :product_collections, through: :collectables
+
+    has_many :order_items, as: :orderable, dependent: :restrict_with_exception
+    has_many :stock_level_adjustments, dependent: :destroy
+    has_many :in_stock_reminders, as: :orderable, dependent: :destroy
+
+    has_many :bundled_products, dependent: :restrict_with_exception
+
+    accepts_nested_attributes_for :product_images, allow_destroy: true
+    accepts_attachments_for :product_images, append: true
+
+    # Generate materialized path
+    before_validation :set_materialized_path
+
+    # Create a 301 redirect if materialized_path changed
+    after_save :rewrite_rule
+
+    validates :name, :base_price, presence: true
+    validates :sku, uniqueness: true, allow_blank: true
+
+    # Globalize translates
+    # Virtual attributes need to be defined because of Rails 5.1 Attributes API
+    [:name, :description, :seo_title, :seo_description, :materialized_path].each do |attr|
+      attribute attr
+      translates attr, fallbacks_for_empty_translations: true
+    end
+
+    # Active product
+    scope :active, -> { where(active: true, archived: false) }
+
+    # Postgres-specific queries for the jsonb column
+    scope :where_any_tags, -> (key, value) do
+      value = [value] unless value.kind_of?(Array)
+      where("spina_shop_products.properties->'#{key}' ?| array['#{value.join('\',\'')}']")
+    end
+
+    scope :where_all_tags, -> (key, value) do
+      value = [value] unless value.kind_of?(Array)
+      where("spina_shop_products.properties->'#{key}' ?& array['#{value.join('\',\'')}']")
+    end
+
+    scope :where_in_range, -> (key, min, max) { where("CAST(coalesce(NULLIF(REPLACE(spina_shop_products.properties->>'#{key}', ',', '.'), ''), '0') AS numeric) BETWEEN ? AND ?", min, max) }
+
+    def to_s
+      name
+    end
+
+    def seo_title
+      read_attribute(:seo_title).presence || name
+    end
+
+    def seo_description
+      read_attribute(:seo_description).presence || description
+    end
+
+    def promotion?
+      promotional_price.present?
+    end
+
+    def price
+      promotional_price.presence || base_price
+    end
+
+    def price_for_order(order)
+      # Return the default price if we don't know anything about the order
+      return price if order.nil? 
+
+      # If no conversion is needed, simply return price
+      price = price_for_customer(order.customer)
+      price_includes_tax = price_includes_tax_for_customer(order.customer)
+      return price if price_includes_tax == order.prices_include_tax
+
+      # Price modifier for unit price
+      price_modifier = tax_group.price_modifier_for_order(order)
+
+      # Calculate unit price based on price modifier
+      unit_price = price_includes_tax ? price / price_modifier : price * price_modifier
+
+      # Round to two decimals using bankers' rounding
+      return unit_price.round(2, :half_even)
+    end
+
+    def price_for_customer(customer)
+      return price if customer.nil?
+      price_exception_for_customer(customer).try(:[], 'price').try(:to_d) || price
+    end
+
+    def price_includes_tax_for_customer(customer)
+      return price_includes_tax if customer.nil?
+      price_exception = price_exception_for_customer(customer)
+      if price_exception.present?
+        ActiveRecord::Type::Boolean.new.cast(price_exception['price_includes_tax'])
+      else
+        price_includes_tax
+      end
+    end
+
+    def in_stock?
+      return true unless stock_enabled?
+      stock_level > 0
+    end
+
+    # All properties are dynamically stored using jsonb
+    def properties
+      decorate_with_methods(read_attribute(:properties))
+    end
+
+    # Get products by filtering their properties
+    # Based on querying the jsonb column using Postgres
+    def self.filtered(filters)
+      products = all
+
+      filters ||= []
+      filters.each do |filter|
+        case filter[:field_type]
+        when "select"
+          products = products.where_any_tags(filter[:property], filter[:value])
+        when "percentage", "decimal", "number"
+          if filter[:value]["min"].present? && filter[:value]["max"].present?
+            products = products.where_in_range(filter[:property], filter[:value]["min"].presence.try(:to_d) || 0, filter[:value]["max"].presence.try(:to_d) || 0)
+          end
+        when "price"
+          min = filter[:value]["min"].presence.try(:to_d) || 0
+          max = filter[:value]["max"].presence.try(:to_d) || 0
+          products = products.where(price: min..max)
+        end
+      end
+
+      return products
+    end
+
+    def cache_stock_level
+      update_columns(
+        stock_level: stock_level_adjustments.sum(:adjustment), 
+        sales_count: stock_level_adjustments.sales.sum(:adjustment) * -1,
+        expiration_date: can_expire? ? earliest_expiration_date : nil
+      )
+    end
+
+    def earliest_expiration_date
+      offset = 0
+      sum = 0
+      adjustment = stock_level_adjustments.ordered.additions.offset(offset).first
+      while sum < stock_level && adjustment.present? do
+        adjustment = stock_level_adjustments.ordered.additions.offset(offset).first
+        offset = offset.next
+        sum = sum + adjustment.try(:adjustment).to_i
+      end 
+
+      if adjustment.try(:expiration_year).present?
+        Date.new.change(day: 1, month: adjustment.expiration_month || 1, year: adjustment.expiration_year)
+      else
+        nil
+      end
+    end
+
+    private
+
+      def rewrite_rule
+        Spina::RewriteRule.where(old_path: old_path).first_or_create.update_attributes(new_path: materialized_path) if old_path != materialized_path
+      end
+
+      # Get price exception based on Customer / CustomerGroup if available
+      def price_exception_for_customer(customer)
+        price_exceptions.try(:[], 'customer_groups').try(:find) do |h|
+          h["customer_group_id"].to_i == customer.customer_group_id
+        end
+      end
+
+      # Get all values for properties defined on the ProductCategory.
+      # Defines singleton methods on the properties attribute for this product.
+      def decorate_with_methods(jsonb)
+        return nil unless product_category.present?
+        product_category.properties.each do |property|
+          jsonb.define_singleton_method(property.name) do
+            case property.field_type
+            when 'select'
+              if jsonb[property.name].is_a? Array
+                jsonb[property.name].map do |option|
+                  property.property_options.where(name: option).first
+                end.compact
+              else
+                property.property_options.where(name: jsonb[property.name]).first
+              end
+            else
+              jsonb[property.name]
+            end
+          end
+        end
+        jsonb
+      end
+
+      # Each product has a unique materialized path which can be used in URL's
+      # Actually more like a slug than a path
+      # TODO: rename materialized_path to slug
+      def set_materialized_path
+        self.old_path = materialized_path
+        self.materialized_path = localized_materialized_path
+        self.materialized_path += "-#{self.class.where(materialized_path: materialized_path).count}" if self.class.where(materialized_path: materialized_path).where.not(id: id).count > 0
+        materialized_path
+      end
+
+      def localized_materialized_path
+        if I18n.locale == I18n.default_locale
+          name.try(:parameterize).prepend('/products/')
+        else
+          name.try(:parameterize).prepend("/#{I18n.locale}/products/").gsub(/\/\z/, "")
+        end
+      end
+
+  end
+end