effective_orders 2.2.4 → 3.0.0

data/app/helpers/effective_orders_helper.rb

@@ -1,8 +1,8 @@
 module EffectiveOrdersHelper
-  def price_to_currency(price, options = {})
-    raise 'price_to_currency expects an Integer representing the number of cents in a price' unless price.kind_of?(Integer)
-    options[:precision] ||= 2
-    number_to_currency(price / 100.0, options)
+  def price_to_currency(price)
+    price = price || 0
+    raise 'price_to_currency expects an Integer representing the number of cents' unless price.kind_of?(Integer)
+    number_to_currency(price / 100.0)
   end
 
   def tax_rate_to_percentage(tax_rate, options = {})
@@ -33,11 +33,15 @@ module EffectiveOrdersHelper
   end
 
   def order_checkout_label(processor = nil)
-    return 'Checkout' if (EffectiveOrders.single_payment_processor? && processor != :pretend)
+    return 'Checkout' if (EffectiveOrders.single_payment_processor? && ![:pretend, :mark_as_paid, :free, :refund].include?(processor))
 
     case processor
+    when :mark_as_paid
+      'Mark as paid'
     when :free
-      'Checkout'
+      'Checkout free'
+    when :refund
+      'Complete refund'
     when :moneris, :stripe, :ccbill
       'Checkout with credit card'
     when :paypal
@@ -45,7 +49,7 @@ module EffectiveOrdersHelper
     when :pretend
       EffectiveOrders.allow_pretend_purchase_in_production ? 'Purchase Order' : 'Purchase Order (development only)'
     when :cheque
-      'Pay by Cheque'
+      'Pay by cheque'
     when :app_checkout
       EffectiveOrders.app_checkout[:checkout_label].presence || 'Checkout'
     else
@@ -82,27 +86,38 @@ 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_step1(order, opts = {})
-    raise ArgumentError.new('unable to checkout an order without a user') unless order.user.present?
+  def render_checkout_step1(order, namespace: nil, purchased_url: nil, declined_url: nil)
+    raise 'unable to checkout an order without a user' unless order && order.user
 
-    locals = { purchased_redirect_url: nil, declined_redirect_url: nil }.merge(opts)
+    locals = { order: order, purchased_url: purchased_url, declined_url: declined_url, namespace: namespace }
 
-    render(partial: 'effective/orders/checkout_step1', locals: locals.merge({order: order}))
+    render partial: 'effective/orders/checkout_step1', locals: locals
   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?
+  def render_checkout_step2(order, namespace: nil, purchased_url: nil, declined_url: nil)
+    raise 'unable to checkout an order without a user' unless order && order.user
 
-    locals = { purchased_redirect_url: nil, declined_redirect_url: nil }.merge(opts)
+    locals = { order: order, purchased_url: purchased_url, declined_url: declined_url, namespace: namespace }
 
     if order.new_record? || !order.valid?
-      render(partial: 'effective/orders/checkout_step1', locals: locals.merge({order: order}))
+      render(partial: 'effective/orders/checkout_step1', locals: locals)
+    else
+      render(partial: 'effective/orders/checkout_step2', locals: locals)
+    end
+  end
+
+  def checkout_step1_form_url(order, namespace = nil)
+    raise 'expected an order' unless order
+    raise 'invalid namespace, expecting nil or :admin' unless [nil, :admin].include?(namespace)
+
+    if order.new_record?
+      namespace == nil ? effective_orders.orders_path : effective_orders.admin_orders_path
     else
-      render(partial: 'effective/orders/checkout_step2', locals: locals.merge({order: order}))
+      namespace == nil ? effective_orders.order_path(order) : effective_orders.checkout_admin_order_path(order)
     end
   end
 
@@ -116,56 +131,25 @@ module EffectiveOrdersHelper
     label = options.delete(:label)
     options[:class] = ((options[:class] || '') + ' btn-my-purchases')
 
-    link_to(label, effective_orders.my_purchases_path, options)
+    link_to(label, effective_orders.my_purchases_orders_path, options)
   end
   alias_method :link_to_order_history, :link_to_my_purchases
 
-  def render_orders(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)
-      orders = user_or_orders.to_a
-    else
-      raise ArgumentError.new('expecting an instance of User or an array/collection of Effective::Order objects')
+
+  def render_orders(obj, opts = {})
+    orders = Array(obj.kind_of?(User) ? Effective::Order.purchased_by(obj) : obj)
+
+    if orders.any? { |order| order.kind_of?(Effective::Order) == false }
+      raise 'expected a User or Effective::Order'
     end
 
-    render(partial: 'effective/orders/orders_table', locals: {orders: orders}.merge(opts))
+    render(partial: 'effective/orders/orders_table', locals: { orders: orders }.merge(opts))
   end
 
   alias_method :render_purchases, :render_orders
   alias_method :render_my_purchases, :render_orders
   alias_method :render_order_history, :render_orders
 
-  # Used by the _payment_details partial
-  def tableize_order_payment(hash, options = {class: 'table table-bordered'})
-    if hash.present? && hash.kind_of?(Hash)
-      content_tag(:table, class: options[:class]) do
-        title = options.delete(:title)
-
-        content = content_tag(:tbody) do
-          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
-                  end
-                end
-            end
-          end.join.html_safe
-        end
-
-        title.blank? ? content : (content_tag(:thead) { content_tag(:tr) { content_tag(:th, title, colspan: 2) } } + content)
-      end
-    else
-      hash.to_s.html_safe
-    end
-  end
-
   def payment_card_label(card)
     card = card.to_s.downcase.gsub(' ', '').strip
 

data/app/helpers/effective_paypal_helper.rb

@@ -15,9 +15,9 @@ module EffectivePaypalHelper
   APP_KEY_PEM     = ConfigReader.cert_or_key(:app_key)
 
   def paypal_encrypted_payload(order)
-    raise ArgumentError.new("unable to read EffectiveOrders PayPal paypal_cert #{EffectiveOrders.paypal[:paypal_cert]}") unless PAYPAL_CERT_PEM.present?
-    raise ArgumentError.new("unable to read EffectiveOrders PayPal app_cert #{EffectiveOrders.paypal[:app_cert]}") unless APP_CERT_PEM.present?
-    raise ArgumentError.new("unable to read EffectiveOrders PayPal app_key #{EffectiveOrders.paypal[:app_key]}") unless APP_KEY_PEM.present?
+    raise "unable to read EffectiveOrders PayPal paypal_cert #{EffectiveOrders.paypal[:paypal_cert]}" unless PAYPAL_CERT_PEM.present?
+    raise "unable to read EffectiveOrders PayPal app_cert #{EffectiveOrders.paypal[:app_cert]}" unless APP_CERT_PEM.present?
+    raise "unable to read EffectiveOrders PayPal app_key #{EffectiveOrders.paypal[:app_key]}" unless APP_KEY_PEM.present?
 
     values = {
       business: EffectiveOrders.paypal[:seller_email],

data/app/helpers/effective_stripe_helper.rb

@@ -4,13 +4,13 @@ module EffectiveStripeHelper
   STRIPE_CONNECT_TOKEN_URL = 'https://connect.stripe.com/oauth/token'
 
   def is_stripe_connect_seller?(user)
-    Effective::Customer.for_user(user).try(:is_stripe_connect_seller?) == true
+    Effective::Customer.for_buyer(user).stripe_connect_access_token.present?
   end
 
   def link_to_new_stripe_connect_customer(opts = {})
     client_id = EffectiveOrders.stripe[:connect_client_id]
 
-    raise ArgumentError.new('effective_orders config: stripe.connect_client_id has not been set') unless client_id.present?
+    raise 'effective_orders config: stripe.connect_client_id has not been set' unless client_id.present?
 
     authorize_params = {
       response_type: :code,
@@ -26,28 +26,35 @@ module EffectiveStripeHelper
     stripe_user_params = opts.delete :stripe_user
     authorize_params.merge!({stripe_user: stripe_user_params}) if stripe_user_params.is_a?(Hash)
 
-    authorize_url = STRIPE_CONNECT_AUTHORIZE_URL.chomp('/') + '?' + authorize_params.to_query
+    authorize_url = STRIPE_CONNECT_AUTHORIZE_URL + '?' + authorize_params.to_query
     options = {}.merge(opts)
     link_to image_tag('/assets/effective_orders/stripe_connect.png'), authorize_url, options
   end
 
-  ### Subscriptions Helpers
-  def stripe_plans_collection(plans)
-    (plans || []).map { |plan| [stripe_plan_description(plan), plan.id, {'data-amount' => plan.amount}] }
-  end
+  def stripe_plan_description(obj)
+    plan = (
+      case obj
+      when Hash            ; obj
+      when ::Stripe::Plan  ; EffectiveOrders.stripe_plans.find { |plan| plan.id == obj.id }
+      else                 ; raise 'unexpected object'
+      end
+    )
 
-  def stripe_plan_description(plan)
-    occurrence = case plan.interval
-      when 'weekly'   ; '/week'
-      when 'monthly'  ; '/month'
-      when 'yearly'   ; '/year'
-      when 'week'     ; plan.interval_count == 1 ? '/week' : " every #{plan.interval_count} weeks"
-      when 'month'    ; plan.interval_count == 1 ? '/month' : " every #{plan.interval_count} months"
-      when 'year'     ; plan.interval_count == 1 ? '/year' : " every #{plan.interval_count} years"
-      else            ; plan.interval
-    end
+    raise("unknown stripe plan: #{obj}") unless plan.kind_of?(Hash) && plan[:id].present?
+
+    plan[:description]
+  end
 
-    "#{plan.name} - #{ActionController::Base.helpers.price_to_currency(plan.amount)} #{plan.currency.upcase}#{occurrence}"
+  def stripe_invoice_line_description(line, simple: false)
+    [
+      "#{line.quantity}x",
+      line.plan.name,
+      price_to_currency(line.amount),
+      ("#{Time.zone.at(line.period.start).strftime('%F')}" unless simple),
+      ('to' unless simple),
+      ("#{Time.zone.at(line.period.end).strftime('%F')}" unless simple),
+      line.description.presence
+    ].compact.join(' ')
   end
 
   def stripe_coupon_description(coupon)
@@ -60,4 +67,26 @@ module EffectiveStripeHelper
     end
   end
 
+  def stripe_site_image_url
+    return nil unless EffectiveOrders.stripe && (url = EffectiveOrders.stripe[:site_image].to_s).present?
+    url.start_with?('http') ? url : asset_url(url)
+  end
+
+  def stripe_order_description(order)
+    "#{order.num_items} items (#{price_to_currency(order.total)})"
+  end
+
+  def stripe_charge_data(order)
+    {
+      stripe: {
+        key: EffectiveOrders.stripe[:publishable_key],
+        name: EffectiveOrders.stripe[:site_title],
+        image: stripe_site_image_url,
+        email: order.user.email,
+        amount: order.total,
+        description: stripe_order_description(order)
+      }.to_json
+    }
+  end
+
 end

data/app/helpers/effective_subscriptions_helper.rb

@@ -0,0 +1,79 @@
+module EffectiveSubscriptionsHelper
+
+  def effective_customer_fields(form, submit: true)
+    raise 'expected a SimpleForm::FormBuilder object' unless form.class.name == 'SimpleForm::FormBuilder'
+    raise 'form object must be an Effective::Subscripter object' unless form.object.class.name == 'Effective::Subscripter'
+
+    render(
+      partial: 'effective/customers/fields',
+      locals: {
+        f: form,
+        submit: submit,
+        stripe: {
+          email: form.object.customer.user.email,
+          image: stripe_site_image_url,
+          key: EffectiveOrders.stripe[:publishable_key],
+          name: EffectiveOrders.stripe[:site_title],
+        }
+      }
+    )
+  end
+
+  def stripe_plans_collection(form, include_trial: nil, selected_class: 'selected panel-primary')
+    raise 'expected a SimpleForm::FormBuilder object' unless form.class.name == 'SimpleForm::FormBuilder'
+    raise 'form object must be an acts_as_subscribable object' unless form.object.subscribable.subscripter.present?
+
+    include_trial = form.object.subscribable.subscribed?('trial') if include_trial.nil?
+
+    plans = include_trial ? EffectiveOrders.stripe_plans : EffectiveOrders.stripe_plans.except('trial')
+    plans = plans.values.sort { |x, y| (amount = x[:amount] <=> y[:amount]) != 0 ? amount : x[:name] <=> y[:name] }
+
+    plans.map do |plan|
+      partial = (
+        if lookup_context.template_exists?("effective/subscriptions/#{plan[:id].downcase}", [], true)
+          "effective/subscriptions/#{plan[:id].downcase}" # Render the app's views/effective/subscriptions/_gold.html.haml
+        else
+          'effective/subscriptions/plan' # Render effective_orders default plan panel
+        end
+      )
+
+      content = render(partial: partial, locals: {
+        f: form,
+        plan: plan,
+        selected: Array(form.object.stripe_plan_id).include?(plan[:id]),
+        selected_class: selected_class,
+        subscribable: form.object.subscribable,
+        subscribed: form.object.subscribable.subscribed?(plan[:id])
+      })
+
+      [content, plan[:id]]
+    end
+  end
+
+  def effective_subscription_fields(form, label: false, required: true, include_trial: nil, item_wrapper_class: 'col-sm-6 col-md-4 col-lg-3', selected_class: 'selected panel-primary', wrapper_class: 'row')
+    raise 'expected a SimpleForm::FormBuilder object' unless form.class.name == 'SimpleForm::FormBuilder'
+    raise 'form object must be an acts_as_subscribable object' unless form.object.subscripter.present?
+
+    render(
+      partial: 'effective/subscriptions/fields',
+      locals: {
+        form: form,
+        label: label,
+        required: required,
+        include_trial: include_trial,
+        item_wrapper_class: item_wrapper_class,
+        selected_class: selected_class,
+        stripe: {
+          email: form.object.buyer.email,
+          image: stripe_site_image_url,
+          key: EffectiveOrders.stripe[:publishable_key],
+          name: EffectiveOrders.stripe[:site_title],
+          plans: EffectiveOrders.stripe_plans.values,
+          token_required: form.object.subscripter.token_required?
+        },
+        wrapper_class: wrapper_class
+      }
+    )
+  end
+
+end

data/app/mailers/effective/orders_mailer.rb

@@ -5,6 +5,8 @@ module Effective
     layout EffectiveOrders.mailer[:layout].presence || 'effective_orders_mailer_layout'
 
     def order_receipt_to_admin(order_param)
+      return true unless EffectiveOrders.mailer[:send_order_receipt_to_admin]
+
       @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
 
       mail(
@@ -15,6 +17,8 @@ module Effective
     end
 
     def order_receipt_to_buyer(order_param)  # Buyer
+      return true unless EffectiveOrders.mailer[:send_order_receipt_to_buyer]
+
       @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
 
       mail(
@@ -25,6 +29,8 @@ module Effective
     end
 
     def order_receipt_to_seller(order_param, seller, order_items)
+      return true unless EffectiveOrders.mailer[:send_order_receipt_to_seller]
+
       @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
       @user = seller.user
       @order_items = order_items
@@ -40,6 +46,8 @@ module Effective
     # 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)
+      return true unless EffectiveOrders.mailer[:send_payment_request_to_buyer]
+
       @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
 
       mail(
@@ -51,6 +59,8 @@ module Effective
 
     # This is sent when someone chooses to Pay by Cheque
     def pending_order_invoice_to_buyer(order_param)
+      return true unless EffectiveOrders.mailer[:send_pending_order_invoice_to_buyer]
+
       @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
 
       mail(
@@ -60,6 +70,71 @@ module Effective
       )
     end
 
+    # Sent by the invoice.payment_succeeded webhook event
+    def subscription_payment_succeeded(customer_param)
+      return true unless EffectiveOrders.mailer[:send_subscription_payment_succeeded]
+
+      @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
+
+      mail(
+        to: @customer.user.email,
+        from: EffectiveOrders.mailer[:default_from],
+        subject: subject_for_subscription_payment_succeeded(@customer)
+      )
+    end
+
+    # Sent by the invoice.payment_failed webhook event
+    def subscription_payment_failed(customer_param)
+      return true unless EffectiveOrders.mailer[:send_subscription_payment_failed]
+
+      @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
+
+      mail(
+        to: @customer.user.email,
+        from: EffectiveOrders.mailer[:default_from],
+        subject: subject_for_subscription_payment_failed(@customer)
+      )
+    end
+
+    # Sent by the invoice.payment_failed webhook event
+    def subscription_canceled(customer_param)
+      return true unless EffectiveOrders.mailer[:send_subscription_canceled]
+
+      @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
+
+      mail(
+        to: @customer.user.email,
+        from: EffectiveOrders.mailer[:default_from],
+        subject: subject_for_subscription_canceled(@customer)
+      )
+    end
+
+    # Sent by the effective_orders:notify_trial_users rake task.
+    def subscription_trial_expiring(subscribable)
+      return true unless EffectiveOrders.mailer[:send_subscription_trial_expiring]
+
+      @subscribable = subscribable
+
+      mail(
+        to: @subscribable.buyer.email,
+        from: EffectiveOrders.mailer[:default_from],
+        subject: subject_for_subscription_trial_expiring(@subscribable)
+      )
+    end
+
+    # Sent by the effective_orders:notify_trial_users rake task.
+    def subscription_trial_expired(subscribable)
+      return true unless EffectiveOrders.mailer[:send_subscription_trial_expired]
+
+      @subscribable = subscribable
+
+      mail(
+        to: @subscribable.buyer.email,
+        from: EffectiveOrders.mailer[:default_from],
+        subject: subject_for_subscription_trial_expired(@subscribable)
+      )
+    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))
@@ -77,7 +152,6 @@ module Effective
       ) do |format|
         format.html { render(template) }
       end
-
     end
 
     private
@@ -103,7 +177,7 @@ module Effective
     end
 
     def subject_for_order_receipt_to_seller(order, order_items, seller)
-      string_or_callable = EffectiveOrders.mailer[:subject_for_seller_receipt]
+      string_or_callable = EffectiveOrders.mailer[:subject_for_order_receipt_to_seller]
 
       if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
         string_or_callable = self.instance_exec(order, order_items, seller, &string_or_callable)
@@ -132,6 +206,55 @@ module Effective
       prefix_subject(string_or_callable.presence || "Pending Order: ##{order.to_param}")
     end
 
+    def subject_for_subscription_payment_succeeded(customer)
+      string_or_callable = EffectiveOrders.mailer[:subject_for_subscription_payment_succeeded]
+
+      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 || 'Thank you for your payment')
+    end
+
+    def subject_for_subscription_payment_failed(customer)
+      string_or_callable = EffectiveOrders.mailer[:subject_for_subscription_payment_failed]
+
+      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 || 'Payment failed - please update your card details')
+    end
+
+    def subject_for_subscription_canceled(customer)
+      string_or_callable = EffectiveOrders.mailer[:subject_for_subscription_canceled]
+
+      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 || 'Subscription canceled')
+    end
+
+    def subject_for_subscription_trial_expiring(customer)
+      string_or_callable = EffectiveOrders.mailer[:subject_for_subscription_trial_expiring]
+
+      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 || 'Trial expiring soon')
+    end
+
+    def subject_for_subscription_trial_expired(customer)
+      string_or_callable = EffectiveOrders.mailer[:subject_for_subscription_trial_expired]
+
+      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 || 'Trial expired')
+    end
 
     def prefix_subject(text)
       prefix = (EffectiveOrders.mailer[:subject_prefix].to_s rescue '')