merchant_sidekick 0.4.2

data/lib/merchant_sidekick/buyer.rb

@@ -0,0 +1,99 @@
+module MerchantSidekick
+  module Buyer
+
+    def self.included(mod)
+      mod.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      # Defines helper methods for a person buying items.
+      #
+      # E.g.
+      #
+      #   class Client < ActiveRecord::Base
+      #     acts_as_buyer
+      #     ...
+      #   end
+      #
+      #   # Simple purchase
+      #   # => @client.purchase @products
+      #
+      #   # Purchase referencing a seller
+      #   # => @client.purchase @products, :from => @merchant
+      #
+      #   # Same as above
+      #   # => @client.purchase_from @merchant, @products
+      #
+      def acts_as_buyer
+        include MerchantSidekick::Buyer::InstanceMethods
+        has_many :orders, :as => :buyer, :dependent => :destroy, :class_name => "::MerchantSidekick::Order"
+        has_many :invoices, :as => :buyer, :dependent => :destroy, :class_name => "::MerchantSidekick::Invoice"
+        has_many :purchase_orders, :as => :buyer, :class_name => "::MerchantSidekick::PurchaseOrder"
+        has_many :purchase_invoices, :as => :buyer, :class_name => "::MerchantSidekick::PurchaseInvoice"
+      end
+    end
+
+    module InstanceMethods
+
+      # like purchase but forces the seller parameter, instead of
+      # taking it as a :seller option
+      def purchase_from(seller, *arguments)
+        purchase(arguments, :from => seller)
+      end
+
+      # purchase creates a purchase order based on
+      # the given sellables, e.g. product, or basically
+      # anything that has a price attribute.
+      #
+      # E.g.
+      #
+      #    buyer.purchase(product, :seller => seller)
+      #
+      def purchase(*arguments)
+        sellables = []
+        options = default_purchase_options
+
+        # distinguish between options and attributes
+        arguments = arguments.flatten
+        arguments.each do |argument|
+          case argument.class.name
+          when 'Hash'
+            options.merge! argument
+          else
+            sellables << (argument.is_a?(MerchantSidekick::ShoppingCart::Cart) ? argument.line_items : argument)
+          end
+        end
+        sellables.flatten!
+        sellables.reject! {|s| s.blank?}
+
+        raise ArgumentError.new("No sellable (e.g. product) model provided") if sellables.empty?
+        raise ArgumentError.new("Sellable models must have a :price") unless sellables.all? {|sellable| sellable.respond_to? :price}
+
+        self.purchase_orders.build do |po|
+          po.buyer = self
+          po.seller = options[:from]
+          po.build_addresses
+          sellables.each do |sellable|
+            if sellable && sellable.respond_to?(:before_add_to_order)
+              sellable.send(:before_add_to_order, self)
+              sellable.reload unless sellable.new_record?
+            end
+            li = LineItem.new(:sellable => sellable, :order => po)
+            po.line_items.push(li)
+            sellable.send(:after_add_to_order, self) if sellable && sellable.respond_to?(:after_add_to_order)
+          end
+          self
+        end
+      end
+
+      protected
+
+      # override in model, e.g. :from => @merchant
+      def default_purchase_options
+        {}
+      end
+
+    end
+  end
+end

data/lib/merchant_sidekick/gateway.rb

@@ -0,0 +1,81 @@
+# Base class for all merchant sidekick gateway implementations.
+module MerchantSidekick
+  
+  class << self
+    def default_gateway
+      MerchantSidekick::Gateway.default_gateway
+    end
+    
+    def default_gateway=(value)
+      MerchantSidekick::Gateway.default_gateway = value
+    end
+  end
+  
+  class Gateway
+    cattr_accessor :config_path
+    cattr_accessor :config_file_name
+    @@config_file_name = "merchant_sidekick.yml"
+    cattr_accessor :config
+    cattr_accessor :default_gateway  # ->  sets default gateway as instance or class (symbol) optional
+    cattr_accessor :gateway          # ->  caches gateway instance in decendants, e.g. in PaypalGateway.gateway
+
+    class << self
+
+      # Returns the gateway type name derived from the class name 
+      # independent of the module name, e.g. :authorize_net_gateway
+      def type
+        name.split("::").last ? name.split("::").last.underscore.to_sym : name.underscore.to_sym
+      end
+
+      def config_path(file_name = nil)
+        unless @@config_path
+          @@config_path = "#{Rails.root}/config/#{file_name || config_file_name}"
+        end
+        @@config_path
+      end
+
+      # Returns configuration hash. By default the configuration is read from
+      # a YAML file from the Rails config/merchant_sidekick.yml path.
+      #
+      # E.g.
+      #
+      #    # config/merchant_sidekick.yml
+      #    development:
+      #      login_id: foo
+      #      transaction_key: bar
+      #      mode: test
+      #    production:
+      #      ...
+      #
+      # or
+      #
+      #    # config/merchant_sidekick.yml
+      #    development:
+      #      authorize_net_gateway:
+      #        login_id: foo
+      #        transaction_key: bar
+      #        mode: test
+      #      paypal_gateway:
+      #        api_username: seller_XYZ_biz_api1.example.com
+      #        api_password: ABCDEFG123456789
+      #        signature: AsPC9BjkCyDFQXbStoZcgqH3hpacAX3IenGazd35.nEnXJKR9nfCmJDu
+      #        pem_file_name: config/paypal.pem
+      #        mode: test
+      #    production:
+      #      ...
+      #
+      def config
+        unless @@config
+          @@config = YAML.load_file(config_path)[Rails.env].symbolize_keys
+          @@config = @@config[type].symbolize_keys if @@config[type]
+        end
+        @@config
+      end
+
+      def default_gateway
+        @@default_gateway || raise("No gateway instance assigned, try e.g. MerchantSidekick::Gateway.default_gateway = ActiveMerchant::Billing::BogusGateway.new")
+      end
+
+    end
+  end
+end

data/lib/merchant_sidekick/install.rb

@@ -0,0 +1,19 @@
+require 'rails/generators'
+require "rails/generators/active_record"
+
+module MerchantSidekick
+  class Install < Rails::Generators::Base
+    include Rails::Generators::Migration
+    extend ActiveRecord::Generators::Migration
+
+    source_root File.expand_path('../migrations', __FILE__)
+
+    # Copies the migration template to db/migrate.
+    def copy_files(*args)
+      migration_template 'billing.rb', 'db/migrate/create_merchant_sidekick_billing_tables.rb'
+      migration_template 'shopping_cart.rb', 'db/migrate/create_merchant_sidekick_shopping_cart_tables.rb'
+      migration_template 'addressable.rb', 'db/migrate/create_merchant_sidekick_addressable_tables.rb'
+    end
+
+  end
+end

data/lib/merchant_sidekick/invoice.rb

@@ -0,0 +1,179 @@
+# Baseclass for in- and outbound invoices.
+module MerchantSidekick
+  class Invoice < ActiveRecord::Base
+    include AASM
+    # include ActionView::Helpers::TextHelper
+    self.table_name = "invoices"
+
+    attr_accessor :authorization
+
+    belongs_to :seller, :polymorphic => true
+    belongs_to :buyer, :polymorphic => true
+    has_many   :line_items, :class_name => "MerchantSidekick::LineItem"
+    belongs_to :order, :class_name => "MerchantSidekick::Order"
+    has_many   :payments, :as => :payable, :dependent => :destroy, :class_name => "MerchantSidekick::Payment"
+
+    money :net_amount,   :cents => :net_cents,   :currency => :currency
+    money :tax_amount,   :cents => :tax_cents,   :currency => :currency
+    money :gross_amount, :cents => :gross_cents, :currency => :currency
+    has_address :origin, :billing, :shipping
+
+    #--- state machine
+    aasm :column => "status" do
+      state :pending,          :enter => :enter_pending,          :exit => :exit_pending, :initial => true
+      state :authorized,       :enter => :enter_authorized,       :exit => :exit_authorized
+      state :paid,             :enter => :enter_paid,             :exit => :exit_paid
+      state :voided,           :enter => :enter_voided,           :exit => :exit_voided
+      state :refunded,         :enter => :enter_refunded,         :exit => :exit_refunded
+      state :payment_declined, :enter => :enter_payment_declined, :exit => :exit_payment_declined
+
+      event :payment_paid do
+        transitions :from => :pending, :to => :paid, :guard => :guard_payment_paid_from_pending
+      end
+
+      event :payment_authorized do
+        transitions :from => :pending, :to => :authorized, :guard => :guard_payment_authorized_from_pending
+        transitions :from => :payment_declined, :to => :authorized, :guard => :guard_payment_authorized_from_payment_declined
+      end
+
+      event :payment_captured do
+        transitions :from => :authorized, :to => :paid, :guard => :guard_payment_captured_from_authorized
+      end
+
+      event :payment_voided do
+        transitions :from => :authorized, :to => :voided, :guard => :guard_payment_voided_from_authorized
+      end
+
+      event :payment_refunded do
+        transitions :from => :paid, :to => :refunded, :guard => :guard_payment_refunded_from_paid
+      end
+
+      event :transaction_declined do
+        transitions :from => :pending, :to => :payment_declined, :guard => :guard_transaction_declined_from_pending
+        transitions :from => :payment_declined, :to => :payment_declined, :guard => :guard_transaction_declined_from_payment_declined
+        transitions :from => :authorized, :to => :authorized, :guard => :guard_transaction_declined_from_authorized
+      end
+    end
+
+    # state transition callbacks
+    def enter_pending; end
+    def enter_authorized; end
+    def enter_paid; end
+    def enter_voided; end
+    def enter_refunded; end
+    def enter_payment_declined; end
+
+    def exit_pending; end
+    def exit_authorized; end
+    def exit_paid; end
+    def exit_voided; end
+    def exit_refunded; end
+    def exit_payment_declined; end
+
+    # event guard callbacks
+    def guard_transaction_declined_from_authorized; true; end
+    def guard_transaction_declined_from_payment_declined; true; end
+    def guard_transaction_declined_from_pending; true; end
+    def guard_payment_refunded_from_paid; true; end
+    def guard_payment_voided_from_authorized; true; end
+    def guard_payment_captured_from_authorized; true; end
+    def guard_payment_authorized_from_payment_declined; true; end
+    def guard_payment_authorized_from_pending; true; end
+    def guard_payment_paid_from_pending; true; end
+
+    #--- scopes
+    scope :paid, :conditions => {:status => "paid"}
+
+    #--- callbacks
+    before_save :number
+
+    #--- instance methods
+    alias_method :current_state, :aasm_current_state
+
+    def number
+      self[:number] ||= Order.generate_unique_id
+    end
+
+    # returns a hash of additional merchant data passed to authorize
+    # you want to pass in the following additional options
+    #
+    #   :ip => ip address of the buyer
+    #
+    def payment_options(options={})
+      {}.merge(options)
+    end
+
+    # From payments, returns :credit_card, etc.
+    def payment_type
+      payments.first.payment_type if payments
+    end
+    alias_method :payment_method, :payment_type
+
+    # Human readable payment type
+    def payment_type_display
+      self.payment_type.to_s.titleize
+    end
+    alias_method :payment_method_display, :payment_type_display
+
+    # Net total amount
+    def net_total
+      self.net_amount ||= line_items.inject(::Money.new(0, self.currency || ::Money.default_currency.iso_code)) {|sum,line| sum + line.net_amount}
+    end
+
+    # Calculates tax and sets the tax_amount attribute
+    # It adds tax_amount across all line_items
+    def tax_total
+      self.tax_amount = line_items.inject(::Money.new(0, self.currency || ::Money.default_currency.iso_code)) {|sum,line| sum + line.tax_amount}
+      self.tax_amount
+    end
+
+    # Gross amount including tax
+    def gross_total
+      self.gross_amount ||= self.net_total + self.tax_total
+    end
+
+    # Same as gross_total
+    def total
+      self.gross_total
+    end
+
+    # updates the order and all contained line_items after an address has changed
+    # or an order item was added or removed. The order can only be evaluated if the
+    # created state is active. The order is saved if it is an existing order.
+    # Returns true if evaluation happend, false if not.
+    def evaluate
+      result = false
+      self.line_items.each(&:evaluate)
+      self.calculate
+      result = save(false) unless self.new_record?
+      result
+    end
+
+    protected
+
+    # override in subclass
+    def purchase_invoice?
+      false
+    end
+
+    # marks sales invoice, override in subclass
+    def sales_invoice?
+      false
+    end
+
+    def push_payment(a_payment)
+      a_payment.payable = self
+      self.payments.push(a_payment)
+    end
+
+    # Recalculates the order, adding order lines, tax and gross totals
+    def calculate
+=begin
+      self.net_amount = nil
+      self.tax_amount = nil
+      self.gross_amount = nil
+=end
+      self.total
+    end
+  end
+end

data/lib/merchant_sidekick/line_item.rb

@@ -0,0 +1,128 @@
+# Line Items used in orders and invoices
+#
+#  LineItem::tax_rate_class_name = 'TaxRate'
+#
+module MerchantSidekick
+  class LineItem < ActiveRecord::Base
+    self.table_name = "line_items"
+
+    #--- accessors
+    cattr_accessor :tax_rate_class_name
+
+    #--- associations
+    belongs_to :order, :class_name => "::MerchantSidekick::Order"
+    belongs_to :invoice, :class_name => "::MerchantSidekick::Invoice"
+    belongs_to :sellable, :polymorphic => true
+
+    #--- mixins
+    money :net_amount,   :cents => :net_cents,   :currency => "currency"
+    money :tax_amount,   :cents => :tax_cents,   :currency => "currency"
+    money :gross_amount, :cents => :gross_cents, :currency => "currency"
+
+    #--- callbacks
+    before_save :save_sellable
+
+    #--- instance methods
+
+    # set #amount when adding sellable.  This method is aliased to <tt>sellable=</tt>.
+    def sellable_with_price=(a_sellable)
+      calculate(a_sellable)
+      self.sellable_without_price = a_sellable
+    end
+    alias_method_chain :sellable=, :price
+
+    # There used to be a money :amount declration. When we added
+    # taxable line items, we assume that amount will refer to the
+    # net_amount (net_cents)
+    def amount
+      self.net_amount
+    end
+    alias_method :net_total, :amount
+
+    # Amount amounts to the net, for compatibility reasons
+    def amount=(net_money_amount)
+      self.net_amount = net_money_amount
+    end
+    alias_method :net_total=, :amount=
+
+    # shorter for gross_amount
+    def total
+      self.gross_amount
+    end
+    alias_method :gross_total, :total
+
+    # short for tax_amount
+    def tax
+      self.tax_amount
+    end
+    alias_method :tax_total, :tax
+
+    # calculates the amounts, like after an address change in the order and tries to save
+    # the line_item unless locked
+    # TODO find a better way to determine if the line item can still be updated
+    def evaluate
+      calculate(self.sellable)
+      save(false) unless new_record?
+    end
+
+    protected
+
+    def calculate(a_sellable)
+      if a_sellable && a_sellable.price
+        tax_rate_class = tax_rate_class_name.camelize.constantize rescue nil
+
+        # calculate tax amounts
+        #
+        # If we want to provide tax rates based on the order's billing address location,
+        # we require a class method,
+        #
+        # e.g.
+        #
+        #   Tax.find_tax_rate({:origin => {...}, :destination => {...}})
+        #   # where each hash provides :country_code => 'DE', :state_code => 'BY'
+
+        if tax_rate_class && a_sellable.respond_to?(:taxable?) && a_sellable.send(:taxable?)
+          # find tax rate for billing address, country/province
+          self.tax_rate = tax_rate_class.find_tax_rate(
+            :origin => order && order.origin_address ? order.origin_address.content_attributes : {},
+            :destination => order && order.shipping_address ? order.shipping_address.content_attributes : {},
+            :sellable => a_sellable
+          )
+
+          if a_sellable.respond_to?( :price_is_net? ) && a_sellable.send( :price_is_net? )
+            # gross = net + tax
+            self.net_amount = a_sellable.price
+            this_cents, this_currency = self.net_amount.cents, self.net_amount.currency
+            this_tax_cents = ( Float( this_cents * self.tax_rate / 10) / 10 ).round
+            self.tax_amount = ::Money.new(this_tax_cents, this_currency)
+            self.gross_amount = self.net_amount + self.tax_amount
+          else # price is gross
+            # net = gross - tax
+            this_gross_cents, this_currency = a_sellable.price.cents, a_sellable.price.currency
+            this_net_cents = (this_gross_cents * Float(100) / Float(100 + self.tax_rate)).round
+            self.net_amount = ::Money.new(this_net_cents, this_currency)
+            self.gross_amount = a_sellable.price
+            self.tax_amount = self.gross_amount - self.net_amount
+          end
+        else
+          # net = gross, tax = 0
+          self.net_amount = a_sellable.price
+          self.gross_amount = a_sellable.price
+          self.tax_amount = ::Money.new(0, a_sellable.currency)
+          self.tax_rate = 0
+        end
+      else
+        self.net_cents = 0
+        self.gross_cents = 0
+        self.tax_cents = 0
+        self.tax_rate = 0
+        self.currency = "USD"
+      end
+    end
+
+    def save_sellable
+      sellable.save if sellable && sellable.new_record?
+    end
+
+  end
+end