effective_orders 1.8.1 → 2.0.0

data/app/helpers/effective_ccbill_helper.rb

@@ -0,0 +1,25 @@
+module EffectiveCcbillHelper
+  def ccbill_form_digest(order)
+    digested_variables = [
+      ccbill_price(order.total),
+      EffectiveOrders.ccbill[:form_period],
+      EffectiveOrders.ccbill[:currency_code],
+      EffectiveOrders.ccbill[:dynamic_pricing_salt]
+    ]
+    string = digested_variables.join('')
+    Digest::MD5.hexdigest(string)
+  end
+
+  def ccbill_price(price)
+    number_to_currency(price/100.0, unit: '')
+  end
+
+  def ccbill_customer_name(order, name = :full_name)
+    if order.user.present? && order.user.try(name).present?
+      order.user.public_send(name)
+    elsif order.billing_address.present?
+      order.billing_address.public_send(name)
+    end
+  end
+end
+

data/app/helpers/effective_orders_helper.rb

@@ -4,10 +4,12 @@ module EffectiveOrdersHelper
     number_to_currency(price / 100.0)
   end
 
-  def order_summary(order)
-    content_tag(:p, "#{price_to_currency(order.total)} total for #{pluralize(order.num_items, 'item')}:") +
+  def tax_rate_to_percentage(tax_rate)
+    number_to_percentage(tax_rate, strip_insignificant_zeros: true)
+  end
 
-    content_tag(:ul) do
+  def order_summary(order)
+    order_item_list = content_tag(:ul) do
       order.order_items.map do |item|
         content_tag(:li) do
           title = item.title.split('<br>')
@@ -17,6 +19,7 @@ module EffectiveOrdersHelper
         end
       end.join.html_safe
     end
+    content_tag(:p, "#{price_to_currency(order.total)} total for #{pluralize(order.num_items, 'item')}:") + order_item_list
   end
 
   def order_item_summary(order_item)
@@ -33,16 +36,16 @@ module EffectiveOrdersHelper
     case processor
     when :free
       'Checkout'
-    when :moneris
-      'Checkout with Moneris'
+    when :moneris, :stripe, :ccbill
+      'Checkout with credit card'
     when :paypal
       'Checkout with PayPal'
-    when :pretend  # The logic for this is in orders/views/_checkout_step_2.html.haml
+    when :pretend
       EffectiveOrders.allow_pretend_purchase_in_production ? 'Purchase Order' : 'Purchase Order (development only)'
-    when :stripe
-      'Checkout with Stripe'
+    when :cheque
+      'Pay by Cheque'
     when :app_checkout
-      EffectiveOrders.app_checkout[:checkout_label]
+      EffectiveOrders.app_checkout[:checkout_label].presence || 'Checkout'
     else
       'Checkout'
     end
@@ -77,53 +80,59 @@ module EffectiveOrdersHelper
   end
 
   def render_order(order)
-    render(:partial => 'effective/orders/order', :locals => {:order => order})
+    render(partial: 'effective/orders/order', locals: {order: order})
   end
 
-  def render_checkout(order, opts = {})
+  def render_checkout_step1(order, opts = {})
     raise ArgumentError.new('unable to checkout an order without a user') unless order.user.present?
 
-    locals = {
-      :purchased_redirect_url => nil,
-      :declined_redirect_url => nil
-    }.merge(opts)
+    locals = { purchased_redirect_url: nil, declined_redirect_url: nil }.merge(opts)
+
+    render(partial: 'effective/orders/checkout_step1', locals: locals.merge({order: order}))
+  end
+  alias_method :render_checkout, :render_checkout_step1
+
+  def render_checkout_step2(order, opts = {})
+    raise ArgumentError.new('unable to checkout an order without a user') unless order.user.present?
+
+    locals = { purchased_redirect_url: nil, declined_redirect_url: nil }.merge(opts)
 
     if order.new_record? || !order.valid?
-      render(:partial => 'effective/orders/checkout_step_1', :locals => locals.merge({:order => order}))
+      render(partial: 'effective/orders/checkout_step1', locals: locals.merge({order: order}))
     else
-      render(:partial => 'effective/orders/checkout_step_2', :locals => locals.merge({:order => order}))
+      render(partial: 'effective/orders/checkout_step2', locals: locals.merge({order: order}))
     end
   end
 
   def link_to_my_purchases(opts = {})
-    options = {:rel => :nofollow}.merge(opts)
-    link_to (options.delete(:label) || 'My Purchases'), effective_orders.my_purchases_path, options
+    options = {
+      label: 'My Purchases',
+      class: 'btn btn-default',
+      rel: :nofollow
+    }.merge(opts)
+
+    label = options.delete(:label)
+    options[:class] = ((options[:class] || '') + ' btn-my-purchases')
+
+    link_to(label, effective_orders.my_purchases_path, options)
   end
   alias_method :link_to_order_history, :link_to_my_purchases
 
-  def render_order_history(user_or_orders, opts = {})
+  def render_orders_table(user_or_orders, opts = {})
     if user_or_orders.kind_of?(User)
       orders = Effective::Order.purchased_by(user_or_orders)
     elsif user_or_orders.respond_to?(:to_a)
-      begin
-        orders = user_or_orders.to_a.select { |order| order.purchased? }
-      rescue => e
-        raise ArgumentError.new('expecting an instance of User or an array/collection of Effective::Order objects')
-      end
+      orders = user_or_orders.to_a
     else
       raise ArgumentError.new('expecting an instance of User or an array/collection of Effective::Order objects')
     end
 
-    locals = {
-      :orders => orders,
-      :order_path => effective_orders.order_path(':id') # The :id string will be replaced with the order id
-    }.merge(opts)
-
-    render(:partial => 'effective/orders/my_purchases', :locals => locals)
+    render(partial: 'effective/orders/orders_table', locals: {orders: orders}.merge(opts))
   end
 
-  alias_method :render_purchases, :render_order_history
-  alias_method :render_my_purchases, :render_order_history
+  alias_method :render_purchases, :render_orders_table
+  alias_method :render_my_purchases, :render_orders_table
+  alias_method :render_order_history, :render_orders_table
 
   # Used by the _payment_details partial
   def tableize_order_payment(hash, options = {class: 'table table-bordered'})
@@ -135,15 +144,15 @@ module EffectiveOrdersHelper
           hash.map do |k, v|
             content_tag(:tr) do
               content_tag((options[:th] ? :th : :td), k) +
-              content_tag(:td) do
-                if v.kind_of?(Hash)
-                  tableize_order_payment(v, options.merge(th: (options.key?(:sub_th) ? options[:sub_th] : options[:th])))
-                elsif v.kind_of?(Array)
-                  '[' + v.join(', ') + ']'
-                else
-                  v
+                content_tag(:td) do
+                  if v.kind_of?(Hash)
+                    tableize_order_payment(v, options.merge(th: (options.key?(:sub_th) ? options[:sub_th] : options[:th])))
+                  elsif v.kind_of?(Array)
+                    '[' + v.join(', ') + ']'
+                  else
+                    v
+                  end
                 end
-              end
             end
           end.join.html_safe
         end

data/app/helpers/effective_paypal_helper.rb

@@ -20,17 +20,17 @@ module EffectivePaypalHelper
     raise ArgumentError.new("unable to read EffectiveOrders PayPal app_key #{EffectiveOrders.paypal[:app_key]}") unless APP_KEY_PEM.present?
 
     values = {
-      :business => EffectiveOrders.paypal[:seller_email],
-      :custom => EffectiveOrders.paypal[:secret],
-      :cmd => '_cart',
-      :upload => 1,
-      :return => effective_orders.order_purchased_url(order),
-      :notify_url => effective_orders.paypal_postback_url,
-      :cert_id => EffectiveOrders.paypal[:cert_id],
-      :currency_code => EffectiveOrders.paypal[:currency],
-      :invoice => order.id,
-      :amount => (order.subtotal / 100.0).round(2),
-      :tax_cart => (order.tax / 100.0).round(2)
+      business: EffectiveOrders.paypal[:seller_email],
+      custom: EffectiveOrders.paypal[:secret],
+      cmd: '_cart',
+      upload: 1,
+      return: effective_orders.order_purchased_url(order),
+      notify_url: effective_orders.paypal_postback_url,
+      cert_id: EffectiveOrders.paypal[:cert_id],
+      currency_code: EffectiveOrders.paypal[:currency],
+      invoice: order.id,
+      amount: (order.subtotal / 100.0).round(2),
+      tax_cart: (order.tax / 100.0).round(2)
     }
 
     order.order_items.each_with_index do |item, x|

data/app/mailers/effective/orders_mailer.rb

@@ -1,52 +1,108 @@
 module Effective
   class OrdersMailer < ActionMailer::Base
     helper EffectiveOrdersHelper
-    default :from => EffectiveOrders.mailer[:default_from]
 
     layout EffectiveOrders.mailer[:layout].presence || 'effective_orders_mailer_layout'
 
-    def order_receipt_to_admin(order)
-      @order = order
-      mail(:to => EffectiveOrders.mailer[:admin_email], :subject => receipt_to_admin_subject(order))
+    def order_receipt_to_admin(order_param)
+      @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
+
+      mail(
+        to: EffectiveOrders.mailer[:admin_email],
+        from: EffectiveOrders.mailer[:default_from],
+        subject: subject_for_order_receipt_to_admin(@order)
+      )
     end
 
-    def order_receipt_to_buyer(order)  # Buyer
-      @order = order
-      mail(:to => order.user.email, :subject => receipt_to_buyer_subject(order))
+    def order_receipt_to_buyer(order_param)  # Buyer
+      @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
+
+      mail(
+        to: @order.user.email,
+        from: EffectiveOrders.mailer[:default_from],
+        subject: subject_for_order_receipt_to_buyer(@order)
+      )
     end
 
-    def order_receipt_to_seller(order, seller, order_items)
-      @order = order
+    def order_receipt_to_seller(order_param, seller, order_items)
+      @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
       @user = seller.user
       @order_items = order_items
-      @subject = receipt_to_seller_subject(order, order_items, seller.user)
+      @subject = subject_for_order_receipt_to_seller(@order, @order_items, seller.user)
+
+      mail(
+        to: @user.email,
+        from: EffectiveOrders.mailer[:default_from],
+        subject: @subject
+      )
+    end
+
+    # This is sent when an admin creates a new order or /admin/orders/new
+    # Or uses the order action Send Payment Request
+    def payment_request_to_buyer(order_param)
+      @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
+
+      mail(
+        to: @order.user.email,
+        from: EffectiveOrders.mailer[:default_from],
+        subject: subject_for_payment_request_to_buyer(@order)
+      )
+    end
+
+    # This is sent when someone chooses to Pay by Cheque
+    def pending_order_invoice_to_buyer(order_param)
+      @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
+
+      mail(
+        to: @order.user.email,
+        from: EffectiveOrders.mailer[:default_from],
+        subject: subject_for_pending_order_invoice_to_buyer(@order)
+      )
+    end
+
+    def order_error(order: nil, error: nil, to: nil, from: nil, subject: nil, template: 'order_error')
+      if order.present?
+        @order = (order.kind_of?(Effective::Order) ? order : Effective::Order.find(order))
+        @subject = (subject || "An error occurred with order: ##{@order.try(:to_param)}")
+      else
+        @subject = (subject || "An order error occurred with an unknown order")
+      end
+
+      @error = error.to_s
+
+      mail(
+        to: (to || EffectiveOrders.mailer[:admin_email]),
+        from: (from || EffectiveOrders.mailer[:default_from]),
+        subject: prefix_subject(@subject),
+      ) do |format|
+        format.html { render(template) }
+      end
 
-      mail(:to => @user.email, :subject => @subject)
     end
 
     private
 
-    def receipt_to_admin_subject(order)
-      string_or_callable = EffectiveOrders.mailer[:subject_for_admin_receipt]
+    def subject_for_order_receipt_to_admin(order)
+      string_or_callable = EffectiveOrders.mailer[:subject_for_order_receipt_to_admin]
 
       if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
         string_or_callable = self.instance_exec(order, &string_or_callable)
       end
 
-      prefix_subject(string_or_callable.presence || "Order ##{order.to_param} Receipt")
+      prefix_subject(string_or_callable.presence || "Order Receipt: ##{order.to_param}")
     end
 
-    def receipt_to_buyer_subject(order)
-      string_or_callable = EffectiveOrders.mailer[:subject_for_buyer_receipt]
+    def subject_for_order_receipt_to_buyer(order)
+      string_or_callable = EffectiveOrders.mailer[:subject_for_order_receipt_to_buyer]
 
       if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
         string_or_callable = self.instance_exec(order, &string_or_callable)
       end
 
-      prefix_subject(string_or_callable.presence || "Order ##{order.to_param} Receipt")
+      prefix_subject(string_or_callable.presence || "Order Receipt: ##{order.to_param}")
     end
 
-    def receipt_to_seller_subject(order, order_items, seller)
+    def subject_for_order_receipt_to_seller(order, order_items, seller)
       string_or_callable = EffectiveOrders.mailer[:subject_for_seller_receipt]
 
       if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
@@ -56,11 +112,30 @@ module Effective
       prefix_subject(string_or_callable.presence || "#{order_items.length} of your products #{order_items.length > 1 ? 'have' : 'has'} been purchased")
     end
 
+    def subject_for_payment_request_to_buyer(order)
+      string_or_callable = EffectiveOrders.mailer[:subject_for_payment_request_to_buyer]
+
+      if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
+        string_or_callable = self.instance_exec(order, &string_or_callable)
+      end
+
+      prefix_subject(string_or_callable.presence || "Request for Payment: Invoice ##{order.to_param}")
+    end
+
+    def subject_for_pending_order_invoice_to_buyer(order)
+      string_or_callable = EffectiveOrders.mailer[:subject_for_pending_order_invoice_to_buyer]
+
+      if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
+        string_or_callable = self.instance_exec(order, &string_or_callable)
+      end
+
+      prefix_subject(string_or_callable.presence || "Pending Order: ##{order.to_param}")
+    end
+
+
     def prefix_subject(text)
       prefix = (EffectiveOrders.mailer[:subject_prefix].to_s rescue '')
       prefix.present? ? (prefix.chomp(' ') + ' ' + text) : text
     end
-
   end
 end
-

data/app/models/concerns/acts_as_purchasable.rb

@@ -1,33 +1,36 @@
 module ActsAsPurchasable
   extend ActiveSupport::Concern
 
+  mattr_accessor :descendants
+
   module ActiveRecord
     def acts_as_purchasable(*options)
       @acts_as_purchasable = options || []
       include ::ActsAsPurchasable
+      (ActsAsPurchasable.descendants ||= []) << self
     end
   end
 
   included do
-    has_many :orders, :through => :order_items, :class_name => 'Effective::Order'
-    has_many :order_items, :as => :purchasable, :class_name => 'Effective::OrderItem'
-    has_many :cart_items, :as => :purchasable, :dependent => :delete_all, :class_name => 'Effective::CartItem'
+    has_many :orders, through: :order_items, class_name: 'Effective::Order'
+    has_many :order_items, as: :purchasable, class_name: 'Effective::OrderItem'
+    has_many :cart_items, as: :purchasable, dependent: :delete_all, class_name: 'Effective::CartItem'
 
-    validates_with Effective::SoldOutValidator, :on => :create
+    validates_with Effective::SoldOutValidator, on: :create
 
     # Database max integer value is 2147483647.  So let's round that down and use a max/min of $20 million (2000000000)
-    validates :price, :presence => true, :numericality => { less_than_or_equal_to: 2000000000, message: 'maximum price is $20,000,000' }
+    validates :price, presence: true, numericality: { less_than_or_equal_to: 2000000000, message: 'maximum price is $20,000,000' }
 
-    validates :tax_exempt, :inclusion => {:in => [true, false]}
+    validates :tax_exempt, inclusion: {in: [true, false]}
 
     # These are breaking on the check for quanitty_enabled?.  More research is due
-    validates :quantity_purchased, :numericality => {:allow_nil => true}, :if => proc { |purchasable| (purchasable.quantity_enabled? rescue false) }
-    validates :quantity_max, :numericality => {:allow_nil => true}, :if => proc { |purchasable| (purchasable.quantity_enabled? rescue false) }
+    validates :quantity_purchased, numericality: {allow_nil: true}, if: proc { |purchasable| (purchasable.quantity_enabled? rescue false) }
+    validates :quantity_max, numericality: {allow_nil: true}, if: proc { |purchasable| (purchasable.quantity_enabled? rescue false) }
 
-    scope :purchased, -> { joins(:order_items).joins(:orders).where(:orders => {:purchase_state => EffectiveOrders::PURCHASED}).uniq }
-    scope :purchased_by, lambda { |user| joins(:order_items).joins(:orders).where(:orders => {:user_id => user.try(:id), :purchase_state => EffectiveOrders::PURCHASED}).uniq }
+    scope :purchased, -> { joins(:order_items).joins(:orders).where(orders: {purchase_state: EffectiveOrders::PURCHASED}).uniq }
+    scope :purchased_by, lambda { |user| joins(:order_items).joins(:orders).where(orders: {user_id: user.try(:id), purchase_state: EffectiveOrders::PURCHASED}).uniq }
     scope :sold, -> { purchased() }
-    scope :sold_by, lambda { |user| joins(:order_items).joins(:orders).where(:order_items => {:seller_id => user.try(:id)}).where(:orders => {:purchase_state => EffectiveOrders::PURCHASED}).uniq }
+    scope :sold_by, lambda { |user| joins(:order_items).joins(:orders).where(order_items: {seller_id: user.try(:id)}).where(orders: {purchase_state: EffectiveOrders::PURCHASED}).uniq }
 
     scope :not_purchased, -> { where('id NOT IN (?)', purchased.pluck(:id).presence || [0]) }
     scope :not_purchased_by, lambda { |user| where('id NOT IN (?)', purchased_by(user).pluck(:id).presence || [0]) }
@@ -44,9 +47,6 @@ module ActsAsPurchasable
   end
 
   # Regular instance methods
-  def is_effectively_purchasable?
-    true
-  end
 
   def price
     self[:price] || 0
@@ -75,14 +75,6 @@ module ActsAsPurchasable
     self[:tax_exempt] || false
   end
 
-  def tax_rate
-    @tax_rate ||= (
-      self.instance_exec(self, &EffectiveOrders.tax_rate_method).to_f.tap do |rate|
-        raise ArgumentError.new("expected EffectiveOrders.tax_rate_method to return a value between 0 and 1. Received #{rate}. Please return 0.05 for 5% tax.") if (rate > 1.0 || rate < 0.0)
-      end
-    )
-  end
-
   def seller
     if EffectiveOrders.stripe_connect_enabled
       raise 'acts_as_purchasable object requires the seller be defined to return the User selling this item.  This is only a requirement when using StripeConnect.'

data/app/models/effective/cart.rb

@@ -5,16 +5,16 @@ module Effective
     belongs_to :user    # This is optional.  We want to let non-logged-in people have carts too
     has_many :cart_items, :inverse_of => :cart, :dependent => :delete_all
 
-    structure do
-      timestamps
-    end
+    # structure do
+    #   timestamps
+    # end
 
     default_scope -> { includes(:cart_items => :purchasable) }
 
-    def add(item, quantity = 1)
-      raise 'expecting an acts_as_purchasable object' unless item.respond_to?(:is_effectively_purchasable?)
+    def add(item, quantity: 1)
+      raise 'expecting an acts_as_purchasable object' unless item.kind_of?(ActsAsPurchasable)
 
-      existing_item = cart_items.where(:purchasable_id => item.id, :purchasable_type => item.class.name).first
+      existing_item = cart_items.where(purchasable_id: item.id, purchasable_type: item.class.name).first
 
       if item.quantity_enabled? && (quantity + (existing_item.quantity rescue 0)) > item.quantity_remaining
         raise EffectiveOrders::SoldOutException, "#{item.title} is sold out"
@@ -22,9 +22,9 @@ module Effective
       end
 
       if existing_item.present?
-        existing_item.update_attributes(:quantity => existing_item.quantity + quantity)
+        existing_item.update_attributes(quantity: existing_item.quantity + quantity)
       else
-        cart_items.create(:cart => self, :purchasable_id => item.id, :purchasable_type => item.class.name, :quantity => quantity)
+        cart_items.create(cart: self, purchasable_id: item.id, purchasable_type: item.class.name, quantity: quantity)
       end
     end
     alias_method :add_to_cart, :add
@@ -53,13 +53,7 @@ module Effective
     def subtotal
       cart_items.map { |ci| ci.subtotal }.sum
     end
+    alias_method :total, :subtotal
 
-    def tax
-      cart_items.map { |ci| ci.tax }.sum
-    end
-
-    def total
-      cart_items.map { |ci| ci.total }.sum
-    end
   end
 end