tienda 1.0.0

data/app/models/tienda/order/delivery.rb

@@ -0,0 +1,229 @@
+module Tienda
+  class Order < ActiveRecord::Base
+
+    # The associated delivery service
+    #
+    # @return [Tienda::DeliveryService]
+    belongs_to :delivery_service, :class_name => 'Tienda::DeliveryService'
+
+    # The country where this order is being delivered to (if one has been provided)
+    #
+    # @return [Tienda::Country]
+    belongs_to :delivery_country, :class_name => 'Tienda::Country', :foreign_key => 'delivery_country_id'
+
+    # The user who marked the order has shipped
+    #
+    # @return [Tienda::User]
+    belongs_to :shipper, :class_name => 'Tienda::User', :foreign_key => 'shipped_by'
+
+    # Set up a callback for use when an order is shipped
+    define_model_callbacks :ship
+
+    # Validations
+    with_options :if => :separate_delivery_address? do |order|
+      order.validates :delivery_name, :presence => true
+      order.validates :delivery_address1, :presence => true
+      order.validates :delivery_address3, :presence => true
+      order.validates :delivery_address4, :presence => true
+      order.validates :delivery_postcode, :presence => true
+      order.validates :delivery_country, :presence => true
+    end
+
+    validate do
+      if self.delivery_required?
+        if self.delivery_service.nil?
+          errors.add :delivery_service_id, :must_be_specified
+        elsif !self.valid_delivery_service?
+          errors.add :delivery_service_id, :not_suitable
+        end
+      end
+    end
+
+    before_confirmation do
+      # Ensure that before we confirm the order that the delivery service which has been selected
+      # is appropritae for the contents of the order.
+      if self.delivery_required? && !self.valid_delivery_service?
+        raise Tienda::Errors::InappropriateDeliveryService, :order => self
+      end
+      cache_delivery_pricing
+    end
+
+    # If an order has been received and something changes the delivery service or the delivery price
+    # is cleared, we will re-cache all the delivery pricing so that we have the latest.
+    before_save do
+      if received? && (delivery_service_id_changed? || (self.delivery_price_changed? && read_attribute(:delivery_price).blank?))
+        self.delivery_price = nil
+        self.delivery_cost_price = nil
+        self.delivery_tax_rate = nil
+        self.delivery_tax_amount = nil
+        cache_delivery_pricing
+      end
+    end
+
+    # If there isn't a seperate address needed, clear all the fields back to nil
+    before_validation do
+      unless separate_delivery_address?
+        self.delivery_name = nil
+        self.delivery_address1 = nil
+        self.delivery_address2 = nil
+        self.delivery_address3 = nil
+        self.delivery_address4 = nil
+        self.delivery_postcode = nil
+        self.delivery_country = nil
+      end
+    end
+
+    # Create some delivery_ methods which will mimic the billing methods if the order does
+    # not need a seperate address.
+    [:delivery_name, :delivery_address1, :delivery_address2, :delivery_address3, :delivery_address4, :delivery_postcode, :delivery_country].each do |f|
+      define_method(f) do
+        separate_delivery_address? ? super() : send(f.to_s.gsub('delivery_', 'billing_'))
+      end
+    end
+
+    # Cache delivery prices for the order
+    def cache_delivery_pricing
+      if self.delivery_service
+        write_attribute :delivery_service_id, self.delivery_service.id
+        write_attribute :delivery_price, self.delivery_price
+        write_attribute :delivery_cost_price, self.delivery_cost_price
+        write_attribute :delivery_tax_rate, self.delivery_tax_rate
+      else
+        write_attribute :delivery_service_id, nil
+        write_attribute :delivery_price, nil
+        write_attribute :delivery_cost_price, nil
+        write_attribute :delivery_tax_rate, nil
+        write_attribute :delivery_tax_amount, nil
+      end
+    end
+
+    # Cache prices and save the order
+    def cache_delivery_pricing!
+      cache_delivery_pricing
+      save!
+    end
+
+    # Has this order been shipped?
+    #
+    # @return [Boolean]
+    def shipped?
+      !!self.shipped_at?
+    end
+
+    # The total weight of the order
+    #
+    # @return [BigDecimal]
+    def total_weight
+      order_items.inject(BigDecimal(0)) { |t,i| t + i.total_weight}
+    end
+
+    # Is delivery required for this order?
+    #
+    # @return [Boolean]
+    def delivery_required?
+      total_weight > BigDecimal(0)
+    end
+
+    # An array of all the delivery services which are suitable for this order in it's
+    # current state (based on its current weight)
+    #
+    # @return [Array] an array of Tienda::DeliveryService objects
+    def available_delivery_services
+      delivery_service_prices.map(&:delivery_service).uniq
+    end
+
+    # An array of all the delivery service prices which can be applied to this order.
+    #
+    # @return [Array] an array of Tienda:DeliveryServicePrice objects
+    def delivery_service_prices
+      if delivery_required?
+        prices = Tienda::DeliveryServicePrice.joins(:delivery_service).where(:tienda_delivery_services => {:active => true}).order(:price).for_weight(total_weight)
+        prices = prices.select { |p| p.countries.empty? || p.country?(self.delivery_country) }
+        prices.sort{ |x,y| (y.delivery_service.default? ? 1 : 0) <=> (x.delivery_service.default? ? 1 : 0) } # Order by truthiness
+      else
+        []
+      end
+    end
+
+    # The recommended delivery service for this order
+    #
+    # @return [Tienda::DeliveryService]
+    def delivery_service
+      super || available_delivery_services.first
+    end
+
+    # Return the delivery price for this order in its current state
+    #
+    # @return [BigDecimal]
+    def delivery_service_price
+      self.delivery_service && self.delivery_service.delivery_service_prices.for_weight(self.total_weight).first
+    end
+
+    # The price for delivering this order in its current state
+    #
+    # @return [BigDecimal]
+    def delivery_price
+      read_attribute(:delivery_price) || delivery_service_price.try(:price) || BigDecimal(0)
+    end
+
+    # The cost of delivering this order in its current state
+    #
+    # @return [BigDecimal]
+    def delivery_cost_price
+      read_attribute(:delivery_cost_price) || delivery_service_price.try(:cost_price) || BigDecimal(0)
+    end
+
+    # The tax amount due for the delivery of this order in its current state
+    #
+    # @return [BigDecimal]
+    def delivery_tax_amount
+      read_attribute(:delivery_tax_amount) ||
+      delivery_price / BigDecimal(100) * delivery_tax_rate
+    end
+
+    # The tax rate for the delivery of this order in its current state
+    #
+    # @return [BigDecimal]
+    def delivery_tax_rate
+      read_attribute(:delivery_tax_rate) ||
+      delivery_service_price.try(:tax_rate).try(:rate_for, self) ||
+      BigDecimal(0)
+    end
+
+    # Is the currently assigned delivery service appropriate for this order?
+    #
+    # @return [Boolean]
+    def valid_delivery_service?
+      self.delivery_service ? self.available_delivery_services.include?(self.delivery_service) : !self.delivery_required?
+    end
+
+    # Remove the associated delivery service if it's invalid
+    def remove_delivery_service_if_invalid
+      unless self.valid_delivery_service?
+        self.delivery_service = nil
+        self.save
+      end
+    end
+
+    # The URL which can be used to track the delivery of this order
+    #
+    # @return [String]
+    def courier_tracking_url
+      return nil if self.shipped_at.blank? || self.consignment_number.blank?
+      @courier_tracking_url ||= self.delivery_service.tracking_url_for(self)
+    end
+
+    # Mark this order as shipped
+    def ship!(consignment_number, user = nil)
+      run_callbacks :ship do
+        self.shipped_at = Time.now
+        self.shipper = user if user
+        self.status = 'shipped'
+        self.consignment_number = consignment_number
+        self.save!
+        Tienda::OrderMailer.shipped(self).deliver
+      end
+    end
+
+  end
+end

data/app/models/tienda/order/states.rb

@@ -0,0 +1,69 @@
+module Tienda
+  class Order < ActiveRecord::Base
+
+    # An array of all the available statuses for an order
+    STATUSES = ['building', 'confirming', 'received', 'accepted', 'rejected', 'shipped']
+
+    # The Tienda::User who accepted the order
+    #
+    # @return [Tienda::User]
+    belongs_to :accepter, :class_name => 'Tienda::User', :foreign_key => 'accepted_by'
+
+    # The Tienda::User who rejected the order
+    #
+    # @return [Tienda::User]
+    belongs_to :rejecter, :class_name => 'Tienda::User', :foreign_key => 'rejected_by'
+
+    # Validations
+    validates :status, :inclusion => {:in => STATUSES}
+
+    # Set the status to building if we don't have a status
+    after_initialize  { self.status = STATUSES.first if self.status.blank? }
+
+    # All orders which have been received
+    scope :received, -> {where("received_at is not null")}
+
+    # All orders which are currently pending acceptance/rejection
+    scope :pending, -> { where(:status => 'received') }
+
+    # All ordered ordered by their ID desending
+    scope :ordered, -> { order(:id => :desc)}
+
+    # Is this order still being built by the user?
+    #
+    # @return [Boolean]
+    def building?
+      self.status == 'building'
+    end
+
+    # Is this order in the user confirmation step?
+    #
+    # @return [Boolean]
+    def confirming?
+      self.status == 'confirming'
+    end
+
+    # Has this order been rejected?
+    #
+    # @return [Boolean]
+    def rejected?
+      !!self.rejected_at
+    end
+
+    # Has this order been accepted?
+    #
+    # @return [Boolean]
+    def accepted?
+      !!self.accepted_at
+    end
+
+    # Has the order been received?
+    #
+    # @return [Boolean]
+    def received?
+      !!self.received_at?
+    end
+
+
+  end
+end

data/app/models/tienda/order.rb

@@ -0,0 +1,93 @@
+module Tienda
+  class Order < ActiveRecord::Base
+
+    self.table_name = 'tienda_orders'
+
+    # Orders can have properties
+    key_value_store :properties
+
+    # Require dependencies
+    require_dependency 'tienda/order/states'
+    require_dependency 'tienda/order/actions'
+    require_dependency 'tienda/order/billing'
+    require_dependency 'tienda/order/delivery'
+
+    # All items which make up this order
+    has_many :order_items, :dependent => :destroy, :class_name => 'Tienda::OrderItem'
+    accepts_nested_attributes_for :order_items, :allow_destroy => true, :reject_if => Proc.new { |a| a['ordered_item_id'].blank? }
+
+    # All products which are part of this order (accessed through the items)
+    has_many :products, :through => :order_items, :class_name => 'Tienda::Product', :source => :ordered_item, :source_type => 'Tienda::Product'
+
+    # Validations
+    validates :token, :presence => true
+    with_options :if => Proc.new { |o| !o.building? } do |order|
+      order.validates :email_address, :format => {:with => /\A\b[A-Z0-9\.\_\%\-\+]+@(?:[A-Z0-9\-]+\.)+[A-Z]{2,6}\b\z/i}
+      order.validates :phone_number, :format => {:with => /\A[\d\ \-x\(\)]{7,}\z/}
+    end
+
+    # Set some defaults
+    before_validation { self.token = SecureRandom.uuid  if self.token.blank? }
+
+    # The order number
+    #
+    # @return [String] - the order number padded with at least 5 zeros
+    def number
+      id ? id.to_s.rjust(6, '0') : nil
+    end
+
+    # The length of time the customer spent building the order before submitting it to us.
+    # The time from first item in basket to received.
+    #
+    # @return [Float] - the length of time
+    def build_time
+      return nil if self.received_at.blank?
+      self.created_at - self.received_at
+    end
+
+    # The name of the customer in the format of "Company (First Last)" or if they don't have
+    # company specified, just "First Last".
+    #
+    # @return [String]
+    def customer_name
+      company.blank? ? full_name : "#{company} (#{full_name})"
+    end
+
+    # The full name of the customer created by concatinting the first & last name
+    #
+    # @return [String]
+    def full_name
+      "#{first_name} #{last_name}"
+    end
+
+    # Is this order empty? (i.e. doesn't have any items associated with it)
+    #
+    # @return [Boolean]
+    def empty?
+      order_items.empty?
+    end
+
+    # Does this order have items?
+    #
+    # @return [Boolean]
+    def has_items?
+      total_items > 0
+    end
+
+    # Return the number of items in the order?
+    #
+    # @return [Integer]
+    def total_items
+      order_items.inject(0) { |t,i| t + i.quantity }
+    end
+
+    def self.ransackable_attributes(auth_object = nil)
+      ["id", "billing_postcode", "billing_address1", "billing_address2", "billing_address3", "billing_address4", "first_name", "last_name", "company", "email_address", "phone_number", "consignment_number", "status", "received_at"] + _ransackers.keys
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      []
+    end
+
+  end
+end

data/app/models/tienda/order_item.rb

@@ -0,0 +1,239 @@
+module Tienda
+  class OrderItem < ActiveRecord::Base
+
+    self.table_name = 'tienda_order_items'
+
+    # The associated order
+    #
+    # @return [Tienda::Order]
+    belongs_to :order, :class_name => 'Tienda::Order', :touch => true
+
+    # The item which has been ordered
+    belongs_to :ordered_item, :polymorphic => true
+
+    # Any stock level adjustments which have been made for this order item
+    has_many :stock_level_adjustments, :as => :parent, :dependent => :nullify, :class_name => 'Tienda::StockLevelAdjustment'
+
+    # Validations
+    validates :quantity, :numericality => true
+    validates :ordered_item, :presence => true
+
+    validate do
+      unless in_stock?
+        errors.add :quantity, :too_hight_quantity
+      end
+    end
+
+    # Before saving an order item which belongs to a received order, cache the pricing again if appropriate.
+    before_save do
+      if order.received? && (unit_price_changed? || unit_cost_price_changed? || tax_rate_changed? || tax_amount_changed?)
+        cache_pricing
+      end
+    end
+
+    # After saving, if the order has been shipped, reallocate stock appropriate
+    after_save do
+      if order.shipped?
+        allocate_unallocated_stock!
+      end
+    end
+
+    # This allows you to add a product to the scoped order. For example Order.first.order_items.add_product(...).
+    # This will either increase the quantity of the value in the order or create a new item if one does not
+    # exist already.
+    #
+    # @param ordered_item [Object] an object which implements the Tienda::OrderableItem protocol
+    # @param quantity [Fixnum] the number of items to order
+    # @return [Tienda::OrderItem]
+    def self.add_item(ordered_item, quantity = 1)
+      raise Errors::UnorderableItem, :ordered_item => ordered_item unless ordered_item.orderable?
+      transaction do
+        if existing = self.where(:ordered_item_id => ordered_item.id, :ordered_item_type => ordered_item.class.to_s).first
+          existing.increase!(quantity)
+          existing
+        else
+          new_item = self.create(:ordered_item => ordered_item, :quantity => 0)
+          new_item.increase!(quantity)
+          new_item
+        end
+      end
+    end
+
+    # Remove a product from an order. It will also ensure that the order's custom delivery
+    # service is updated if appropriate.
+    #
+    # @return [Tienda::OrderItem]
+    def remove
+      transaction do
+        self.destroy!
+        self.order.remove_delivery_service_if_invalid
+        self
+      end
+    end
+
+    # Increases the quantity of items in the order by the number provided. Will raise an error if we don't have
+    # the stock to do this.
+    #
+    # @param quantity [Fixnum]
+    def increase!(amount = 1)
+      transaction do
+        self.quantity += amount
+        unless self.in_stock?
+          raise Tienda::Errors::NotEnoughStock, :ordered_item => self.ordered_item, :requested_stock => self.quantity
+        end
+        self.save!
+        self.order.remove_delivery_service_if_invalid
+      end
+    end
+
+    # Decreases the quantity of items in the order by the number provided.
+    #
+    # @param amount [Fixnum]
+    def decrease!(amount = 1)
+      transaction do
+        self.quantity -= amount
+        self.quantity == 0 ? self.destroy : self.save!
+        self.order.remove_delivery_service_if_invalid
+      end
+    end
+
+    # The total weight of the item
+    #
+    # @return [BigDecimal]
+    def weight
+      read_attribute(:weight) || ordered_item.try(:weight) || BigDecimal(0)
+    end
+
+    # Return the total weight of the item
+    #
+    # @return [BigDecimal]
+    def total_weight
+      quantity * weight
+    end
+
+    # The unit price for the item
+    #
+    # @return [BigDecimal]
+    def unit_price
+      read_attribute(:unit_price) || ordered_item.try(:price) || BigDecimal(0)
+    end
+
+    # The cost price for the item
+    #
+    # @return [BigDecimal]
+    def unit_cost_price
+      read_attribute(:unit_cost_price) || ordered_item.try(:cost_price) || BigDecimal(0)
+    end
+
+    # The tax rate for the item
+    #
+    # @return [BigDecimal]
+    def tax_rate
+      read_attribute(:tax_rate) || ordered_item.try(:tax_rate).try(:rate_for, self.order) || BigDecimal(0)
+    end
+
+    # The total tax for the item
+    #
+    # @return [BigDecimal]
+    def tax_amount
+      read_attribute(:tax_amount) || (self.sub_total / BigDecimal(100)) * self.tax_rate
+    end
+
+    # The total cost for the product
+    #
+    # @return [BigDecimal]
+    def total_cost
+      quantity * unit_cost_price
+    end
+
+    # The sub total for the product
+    #
+    # @return [BigDecimal]
+    def sub_total
+      quantity * unit_price
+    end
+
+    # The total price including tax for the order line
+    #
+    # @return [BigDecimal]
+    def total
+      tax_amount + sub_total
+    end
+
+    # Cache the pricing for this order item
+    def cache_pricing
+      write_attribute :weight, self.weight
+      write_attribute :unit_price, self.unit_price
+      write_attribute :unit_cost_price, self.unit_cost_price
+      write_attribute :tax_rate, self.tax_rate
+    end
+
+    # Cache the pricing for this order item and save
+    def cache_pricing!
+      cache_pricing
+      save!
+    end
+
+    # Trigger when the associated order is confirmed. It handles caching the values
+    # of the monetary items and allocating stock as appropriate.
+    def confirm!
+      cache_pricing!
+      allocate_unallocated_stock!
+    end
+
+    # Trigger when the associated order is accepted
+    def accept!
+    end
+
+    # Trigged when the associated order is rejected..
+    def reject!
+      self.stock_level_adjustments.destroy_all
+    end
+
+    # Do we have the stock needed to fulfil this order?
+    #
+    # @return [Boolean]
+    def in_stock?
+      if self.ordered_item && self.ordered_item.stock_control?
+        self.ordered_item.stock >= unallocated_stock
+      else
+        true
+      end
+    end
+
+    # How much stock remains to be allocated for this order?
+    #
+    # @return [Fixnum]
+    def unallocated_stock
+      self.quantity - allocated_stock
+    end
+
+    # How much stock has been allocated to this item?
+    #
+    # @return [Fixnum]
+    def allocated_stock
+      0 - self.stock_level_adjustments.sum(:adjustment)
+    end
+
+    # Validate the stock level against the product and update as appropriate. This method will be executed
+    # before an order is completed. If we have run out of this product, we will update the quantity to an
+    # appropriate level (or remove the order item) and return the object.
+    def validate_stock_levels
+      if in_stock?
+        false
+      else
+        self.quantity = self.ordered_item.stock
+        self.quantity == 0 ? self.destroy : self.save!
+        self
+      end
+    end
+
+    # Allocate any unallocated stock for this order item. There is no return value.
+    def allocate_unallocated_stock!
+      if self.ordered_item.stock_control? && self.unallocated_stock != 0
+        self.ordered_item.stock_level_adjustments.create!(:parent => self, :adjustment => 0 - self.unallocated_stock, :description => "Order ##{self.order.number}")
+      end
+    end
+
+  end
+end

data/app/models/tienda/payment.rb

@@ -0,0 +1,80 @@
+module Tienda
+  class Payment < ActiveRecord::Base
+
+    # The associated order
+    #
+    # @return [Tienda::Order]
+    belongs_to :order, :class_name => 'Tienda::Order'
+
+    # An associated payment (only applies to refunds)
+    #
+    # @return [Tienda::Payment]
+    belongs_to :parent, :class_name => "Tienda::Payment", :foreign_key => "parent_payment_id"
+
+    # Validatiosn
+    validates :amount, :numericality => true
+    validates :reference, :presence => true
+    validates :method, :presence => true
+
+    # Payments can have associated properties
+    key_value_store :properties
+
+    # Callbacks
+    after_create :cache_amount_paid
+    after_destroy :cache_amount_paid
+    before_destroy { self.parent.update_attribute(:amount_refunded, self.parent.amount_refunded + amount) if self.parent }
+
+    # Is this payment a refund?
+    #
+    # @return [Boolean]
+    def refund?
+      self.amount < BigDecimal(0)
+    end
+
+    # Has this payment had any refunds taken from it?
+    #
+    # @return [Boolean]
+    def refunded?
+      self.amount_refunded > BigDecimal(0)
+    end
+
+    # How much of the payment can be refunded
+    #
+    # @return [BigDecimal]
+    def refundable_amount
+      refundable? ? (self.amount - self.amount_refunded) : BigDecimal(0)
+    end
+
+    # Process a refund from this payment.
+    #
+    # @param amount [String] the amount which should be refunded
+    # @return [Boolean]
+    def refund!(amount)
+      amount = BigDecimal(amount)
+      if refundable_amount >= amount
+        transaction do
+          self.class.create(:parent => self, :order_id => self.order_id, :amount => 0-amount, :method => self.method, :reference => reference)
+          self.update_attribute(:amount_refunded, self.amount_refunded + amount)
+          true
+        end
+      else
+        raise Tienda::Errors::RefundFailed, :message => I18n.t('.refund_failed', refundable_amount: refundable_amount)
+      end
+    end
+
+    # Return a transaction URL for viewing further information about this
+    # payment.
+    #
+    # @return [String]
+    def transaction_url
+      nil
+    end
+
+    private
+
+    def cache_amount_paid
+      self.order.update_attribute(:amount_paid, self.order.payments.sum(:amount))
+    end
+
+  end
+end