kylekthompson-shoppe 1.0.7

data/app/models/shoppe/customer.rb

@@ -0,0 +1,41 @@
+module Shoppe
+  class Customer < ActiveRecord::Base
+
+    self.table_name = "shoppe_customers"
+
+    has_many :addresses, :dependent => :restrict_with_exception, :class_name => "Shoppe::Address"
+
+    has_many :orders, :dependent => :restrict_with_exception, :class_name => "Shoppe::Order"
+
+    # Validations
+    validates :email, :presence => true, :uniqueness => true, :format => {:with => /\A\b[A-Z0-9\.\_\%\-\+]+@(?:[A-Z0-9\-]+\.)+[A-Z]{2,6}\b\z/i}
+    validates :phone, :presence => true, :format => {:with => /\A[\d\ \-x\(\)]{7,}\z/}
+
+    # All customers ordered by their ID desending
+    scope :ordered, -> { order(:id => :desc)}
+
+    # 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 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
+
+    def self.ransackable_attributes(auth_object = nil) 
+      ["id", "first_name", "last_name", "company", "email", "phone", "mobile"] + _ransackers.keys
+    end
+  
+    def self.ransackable_associations(auth_object = nil)
+      []
+    end
+
+  end
+end

data/app/models/shoppe/delivery_service.rb

@@ -0,0 +1,33 @@
+module Shoppe
+  class DeliveryService < ActiveRecord::Base
+  
+    self.table_name = 'shoppe_delivery_services'
+
+    # Validations
+    validates :name, :presence => true
+    validates :courier, :presence => true
+  
+    # Orders which are assigned to this delivery service
+    has_many :orders, :dependent => :restrict_with_exception, :class_name => 'Shoppe::Order'
+    
+    # Prices for the different levels of service within this delivery service
+    has_many :delivery_service_prices, :dependent => :destroy, :class_name => 'Shoppe::DeliveryServicePrice'
+  
+    # All active delivery services
+    scope :active, -> { where(:active => true)}
+    
+    # Returns a tracking URL for the passed order
+    #
+    # @param order [Shoppe::Order]
+    # @return [String] the full URL for the order.
+    def tracking_url_for(order)
+      return nil if self.tracking_url.blank?
+      tracking_url = self.tracking_url.dup
+      tracking_url.gsub!("{{consignment_number}}", CGI.escape(order.consignment_number.to_s))
+      tracking_url.gsub!("{{delivery_postcode}}", CGI.escape(order.delivery_postcode.to_s))
+      tracking_url.gsub!("{{billing_postcode}}", CGI.escape(order.billing_postcode.to_s))
+      tracking_url
+    end
+
+  end
+end

data/app/models/shoppe/delivery_service_price.rb

@@ -0,0 +1,31 @@
+module Shoppe
+  class DeliveryServicePrice < ActiveRecord::Base
+
+    # Set the table name
+    self.table_name = 'shoppe_delivery_service_prices'
+  
+    include Shoppe::AssociatedCountries
+  
+    # The delivery service which this price belongs to
+    belongs_to :delivery_service, :class_name => 'Shoppe::DeliveryService'
+    
+    # The tax rate which should be applied
+    belongs_to :tax_rate, :class_name => "Shoppe::TaxRate"
+    
+    # Validations
+    validates :code, :presence => true
+    validates :price, :numericality => true
+    validates :cost_price, :numericality => true, :allow_blank => true
+    validates :min_weight, :numericality => true
+    validates :max_weight, :numericality => true
+  
+    # All prices ordered by their price ascending
+    scope :ordered, -> { order(:price => :asc) }
+    
+    # All prices which are suitable for the weight passed.
+    #
+    # @param weight [BigDecimal] the weight of the order
+    scope :for_weight, -> weight { where("min_weight <= ? AND max_weight >= ?", weight, weight) }
+  
+  end
+end

data/app/models/shoppe/order.rb

@@ -0,0 +1,100 @@
+module Shoppe
+  class Order < ActiveRecord::Base
+
+    self.table_name = 'shoppe_orders'
+
+    # Orders can have properties
+    key_value_store :properties
+
+    # Require dependencies
+    require_dependency 'shoppe/order/states'
+    require_dependency 'shoppe/order/actions'
+    require_dependency 'shoppe/order/billing'
+    require_dependency 'shoppe/order/delivery'
+
+    # All items which make up this order
+    has_many :order_items, :dependent => :destroy, :class_name => 'Shoppe::OrderItem', :inverse_of => :order
+    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 => 'Shoppe::Product', :source => :ordered_item, :source_type => 'Shoppe::Product'
+
+    # The order can belong to a customer
+    belongs_to :customer, :class_name => 'Shoppe::Customer'
+    has_many :addresses, :through => :customers, :class_name => "Shoppe::Address"
+
+    # 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? }
+
+    # Some methods for setting the billing & delivery addresses
+    attr_accessor :save_addresses, :billing_address_id, :delivery_address_id
+
+    # 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/shoppe/order/actions.rb

@@ -0,0 +1,94 @@
+module Shoppe
+  class Order < ActiveRecord::Base
+    
+    extend ActiveModel::Callbacks
+    
+    # These additional callbacks allow for applications to hook into other
+    # parts of the order lifecycle.
+    define_model_callbacks :confirmation, :acceptance, :rejection
+  
+    # This method should be called by the base application when the user has completed their 
+    # first round of entering details. This will mark the order as "confirming" which means
+    # the customer now just must confirm.
+    #
+    # @param params [Hash] a hash of order attributes
+    # @return [Boolean]
+    def proceed_to_confirm(params = {})
+      self.status = 'confirming'
+      if self.update(params)
+        true
+      else
+        false
+      end
+    end
+  
+    # This method should be executed by the application when the order should be completed
+    # by the customer. It will raise exceptions if anything goes wrong or return true if
+    # the order has been confirmed successfully
+    #
+    # @return [Boolean]
+    def confirm!
+      no_stock_of = self.order_items.select(&:validate_stock_levels)
+      unless no_stock_of.empty?
+        raise Shoppe::Errors::InsufficientStockToFulfil, :order => self, :out_of_stock_items => no_stock_of
+      end
+    
+      run_callbacks :confirmation do
+        # If we have successfully charged the card (i.e. no exception) we can go ahead and mark this
+        # order as 'received' which means it can be accepted by staff.
+        self.status = 'received'
+        self.received_at = Time.now
+        self.save!
+
+        self.order_items.each(&:confirm!)
+
+        # Send an email to the customer
+        deliver_received_order_email
+      end
+    
+      # We're all good.
+      true
+    end
+  
+    # Mark order as accepted
+    #
+    # @param user [Shoppe::User] the user who carried out this action    
+    def accept!(user = nil)
+      run_callbacks :acceptance do
+        self.accepted_at = Time.now
+        self.accepter = user if user
+        self.status = 'accepted'
+        self.save!
+        self.order_items.each(&:accept!)
+        #deliver_accepted_order_email
+      end
+    end
+  
+    # Mark order as rejected
+    #
+    # @param user [Shoppe::User] the user who carried out the action
+    def reject!(user = nil)
+      run_callbacks :rejection do
+        self.rejected_at = Time.now
+        self.rejecter = user if user
+        self.status = 'rejected'
+        self.save!
+        self.order_items.each(&:reject!)
+        #deliver_rejected_order_email
+      end
+    end
+
+    def deliver_accepted_order_email
+      Shoppe::OrderMailer.accepted(self).deliver_now
+    end
+
+    def deliver_rejected_order_email
+      Shoppe::OrderMailer.rejected(self).deliver_now
+    end
+
+    def deliver_received_order_email
+      Shoppe::OrderMailer.received(self).deliver_now
+    end
+    
+  end
+end

data/app/models/shoppe/order/billing.rb

@@ -0,0 +1,105 @@
+module Shoppe
+  class Order < ActiveRecord::Base
+
+    # The country which this order should be billed to
+    #
+    # @return [Shoppe::Country]
+    belongs_to :billing_country, :class_name => 'Shoppe::Country', :foreign_key => 'billing_country_id'
+
+    # Payments which have been stored for the order
+    has_many :payments, :dependent => :destroy, :class_name => 'Shoppe::Payment'
+
+    # Validations
+    with_options :if => Proc.new { |o| !o.building? } do |order|
+      order.validates :first_name, :presence => true
+      order.validates :last_name, :presence => true
+      order.validates :billing_address1, :presence => true
+      order.validates :billing_address3, :presence => true
+      order.validates :billing_address4, :presence => true
+      order.validates :billing_postcode, :presence => true
+      order.validates :billing_country, :presence => true
+    end
+
+    # The name for billing purposes
+    #
+    # @return [String]
+    def billing_name
+      company.blank? ? full_name : "#{full_name} (#{company})"
+    end
+
+    # The total cost of the order
+    #
+    # @return [BigDecimal]
+    def total_cost
+      self.delivery_cost_price +
+      order_items.inject(BigDecimal(0)) { |t, i| t + i.total_cost }
+    end
+
+    # Return the price for the order
+    #
+    # @return [BigDecimal]
+    def profit
+      total_before_tax - total_cost
+    end
+
+    # The total price of all items in the basket excluding delivery
+    #
+    # @return [BigDecimal]
+    def items_sub_total
+      order_items.inject(BigDecimal(0)) { |t, i| t + i.sub_total }
+    end
+
+    # The total price of the order before tax
+    #
+    # @return [BigDecimal]
+    def total_before_tax
+      self.delivery_price + self.items_sub_total
+    end
+
+    # The total amount of tax due on this order
+    #
+    # @return [BigDecimal]
+    def tax
+      self.delivery_tax_amount +
+      order_items.inject(BigDecimal(0)) { |t, i| t + i.tax_amount }
+    end
+
+    # The total of the order including tax
+    #
+    # @return [BigDecimal]
+    def total
+      self.delivery_price +
+      self.delivery_tax_amount +
+      order_items.inject(BigDecimal(0)) { |t, i| t + i.total }
+    end
+
+    # The total amount due on the order
+    #
+    # @return [BigDecimal]
+    def balance
+      @balance ||= total - amount_paid
+    end
+
+    # Is there a payment still outstanding on this order?
+    #
+    # @return [Boolean]
+    def payment_outstanding?
+      balance > BigDecimal(0)
+    end
+
+    # Has this order been paid in full?
+    #
+    # @return [Boolean]
+    def paid_in_full?
+      !payment_outstanding?
+    end
+
+    # Is the order invoiced?
+    #
+    # @return [Boolean]
+    def invoiced?
+      !invoice_number.blank?
+    end
+
+  end
+end

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

@@ -0,0 +1,229 @@
+module Shoppe
+  class Order < ActiveRecord::Base
+
+    # The associated delivery service
+    #
+    # @return [Shoppe::DeliveryService]
+    belongs_to :delivery_service, :class_name => 'Shoppe::DeliveryService'
+
+    # The country where this order is being delivered to (if one has been provided)
+    #
+    # @return [Shoppe::Country]
+    belongs_to :delivery_country, :class_name => 'Shoppe::Country', :foreign_key => 'delivery_country_id'
+
+    # The user who marked the order has shipped
+    #
+    # @return [Shoppe::User]
+    belongs_to :shipper, :class_name => 'Shoppe::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 Shoppe::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 Shoppe::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 Shoppe:DeliveryServicePrice objects
+    def delivery_service_prices
+      if delivery_required?
+        prices = Shoppe::DeliveryServicePrice.joins(:delivery_service).where(:shoppe_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 [Shoppe::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!
+        #Shoppe::OrderMailer.shipped(self).deliver_now
+      end
+    end
+
+  end
+end