effective_orders 1.0.0

data/app/controllers/effective/providers/stripe.rb

@@ -0,0 +1,125 @@
+require 'stripe'
+
+module Effective
+  module Providers
+    module Stripe
+      extend ActiveSupport::Concern
+
+      included do
+      end
+
+      def stripe_charge
+        @order = Effective::Order.find(stripe_charge_params[:effective_order_id])
+        @stripe_charge = Effective::StripeCharge.new(stripe_charge_params)
+        @stripe_charge.order = @order
+
+        EffectiveOrders.authorized?(self, :update, @order)
+
+        if @stripe_charge.valid? && (response = process_stripe_charge(@stripe_charge)) != false
+          order_purchased(response) # orders_controller#order_purchased
+        else
+          flash[:danger] = @stripe_charge.errors.full_messages.join(',')
+          render 'checkout'
+        end
+      end
+
+      private
+
+      def process_stripe_charge(charge)
+        Effective::Order.transaction do
+          begin
+            @buyer = Customer.for_user(charge.order.user)
+            @buyer.update_card!(charge.token)
+
+            if EffectiveOrders.stripe_connect_enabled
+              return charge_with_stripe_connect(charge, @buyer)
+            else
+              return charge_with_stripe(charge, @buyer)
+            end
+          rescue => e
+            charge.errors.add(:base, "Unable to process order with Stripe.  Your credit card has not been charged.  Message: \"#{e.message}\".")
+            raise ActiveRecord::Rollback
+          end
+        end
+
+        false
+      end
+
+      def charge_with_stripe(charge, buyer)
+        results = {:subscriptions => {}, :charge => nil}
+
+        # Process subscriptions.
+        charge.subscriptions.each do |subscription|
+          next if subscription.stripe_plan_id.blank?
+
+          stripe_subscription = if subscription.stripe_coupon_id.present?
+            buyer.stripe_customer.subscriptions.create({:plan => subscription.stripe_plan_id, :coupon => subscription.stripe_coupon_id})
+          else
+            buyer.stripe_customer.subscriptions.create({:plan => subscription.stripe_plan.id})
+          end
+
+          subscription.stripe_subscription_id = stripe_subscription.id
+          subscription.save!
+
+          results[:subscriptions][subscription.stripe_plan_id] = JSON.parse(stripe_subscription.to_json)
+        end
+
+        # Process regular order_items.
+        amount = (charge.order_items.collect(&:total).sum)  # A positive integer in cents representing how much to charge the card. The minimum amount is 50 cents.
+        description = "Charge for Order ##{charge.order.to_param}"
+
+        if amount > 0
+          results[:charge] = JSON.parse(::Stripe::Charge.create(
+            :amount => amount,
+            :currency => EffectiveOrders.stripe[:currency],
+            :customer => buyer.stripe_customer.id,
+            :description => description
+          ).to_json)
+        end
+
+        results
+      end
+
+      def charge_with_stripe_connect(charge, buyer)
+        # Go through and create Stripe::Tokens for each seller
+        items = charge.order_items.group_by(&:seller)
+        results = {}
+
+        # We do all these Tokens first, so if one throws an exception no charges are made
+        items.each do |seller, _|
+          seller.token = ::Stripe::Token.create({:customer => buyer.stripe_customer.id}, seller.stripe_connect_access_token)
+        end
+
+        # Make one charge per seller, for all his order_items
+        items.each do |seller, order_items|
+          amount = order_items.sum(&:total)
+          description = "Charge for Order ##{charge.order.to_param} with OrderItems ##{order_items.map(&:id).join(', #')}"
+          application_fee = order_items.sum(&:stripe_connect_application_fee)
+
+          results[seller.id] = JSON.parse(::Stripe::Charge.create(
+            {
+              :amount => amount,
+              :currency => EffectiveOrders.stripe[:currency],
+              :card => seller.token.id,
+              :description => description,
+              :application_fee => application_fee
+            },
+            seller.stripe_connect_access_token
+          ).to_json)
+        end
+
+        results
+      end
+
+      # StrongParameters
+      def stripe_charge_params
+        begin
+          params.require(:effective_stripe_charge).permit(:token, :effective_order_id)
+        rescue => e
+          params[:effective_stripe_charge]
+        end
+      end
+
+    end
+  end
+end

data/app/controllers/effective/providers/stripe_connect.rb

@@ -0,0 +1,47 @@
+module Effective
+  module Providers
+    module StripeConnect
+      extend ActiveSupport::Concern
+
+      included do
+        prepend_before_filter :set_stripe_connect_state_params, :only => [:stripe_connect_redirect_uri]
+      end
+
+      # So this is the postback after Stripe does its oAuth authentication
+      def stripe_connect_redirect_uri
+        if params[:code].present?
+          token_params = request_access_token(params[:code]) # We got a code, so now we make a curl request for the access_token
+          customer = Effective::Customer.for_user(current_user)
+
+          if token_params['access_token'].present? && customer.present?
+            if customer.update_attributes(:stripe_connect_access_token => token_params['access_token'])
+              flash[:success] = 'Successfully Connected with Stripe Connect'
+            else
+              flash[:danger] = "Unable to update customer: #{customer.errors[:base].first}"
+            end
+          else
+            flash[:danger] = "Error when connecting to Stripe /oauth/token: #{token_params[:error]}.  Please try again."
+          end
+        else
+          flash[:danger] = "Error when connecting to Stripe /oauth/authorize: #{params[:error]}.  Please try again."
+        end
+
+        redirect_to URI.parse(@stripe_state_params['redirect_to']).path rescue effective_orders.orders_path
+      end
+
+      private
+
+      def request_access_token(code)
+        stripe_response = `curl -F client_secret='#{EffectiveOrders.stripe[:secret_key]}' -F code='#{code}' -F grant_type='authorization_code' #{EffectiveStripeHelper::STRIPE_CONNECT_TOKEN_URL}`
+        JSON.parse(stripe_response) rescue {}
+      end
+
+      def set_stripe_connect_state_params
+        @stripe_state_params = (JSON.parse(params[:state]) rescue {})
+        @stripe_state_params = {} unless @stripe_state_params.kind_of?(Hash)
+
+        params[:authenticity_token] = @stripe_state_params['form_authenticity_token']
+      end
+    end
+  end
+end

data/app/controllers/effective/subscriptions_controller.rb

@@ -0,0 +1,123 @@
+module Effective
+  class SubscriptionsController < ApplicationController
+    include EffectiveCartsHelper
+    include EffectiveStripeHelper
+
+    layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:subscriptions] : EffectiveOrders.layout)
+
+    before_filter :authenticate_user!
+    before_filter :assign_customer
+
+    # This is a 'My Subscriptions' page
+    def index
+      @page_title ||= 'My Subscriptions'
+
+      @subscriptions = @customer.subscriptions.purchased
+
+      EffectiveOrders.authorized?(self, :index, Effective::Subscription)
+    end
+
+    def new
+      @page_title ||= 'New Subscription'
+
+      @subscription = @customer.subscriptions.new()
+
+      purchased_plans = @customer.subscriptions.purchased.map(&:stripe_plan_id)
+      @plans = Stripe::Plan.all.reject { |stripe_plan| purchased_plans.include?(stripe_plan.id) }
+
+      EffectiveOrders.authorized?(self, :new, @subscription)
+    end
+
+    def create
+      @page_title ||= 'New Subscription'
+
+      # Don't let the user create another Subscription object if it's already created
+      @subscription = @customer.subscriptions.where(:stripe_plan_id => subscription_params[:stripe_plan_id]).first_or_initialize
+
+      EffectiveOrders.authorized?(self, :create, @subscription)
+
+      if @subscription.update_attributes(subscription_params) && (current_cart.find(@subscription).present? || current_cart.add(@subscription))
+        flash[:success] = "Successfully added subscription to cart"
+        redirect_to effective_orders.new_order_path
+      else
+        purchased_plans = @customer.subscriptions.purchased.map(&:stripe_plan_id)
+        @plans = Stripe::Plan.all.reject { |stripe_plan| purchased_plans.include?(stripe_plan.id) }
+
+        flash[:danger] ||= 'Unable to add subscription to cart.  Please try again.'
+        render :action => :new
+      end
+    end
+
+    def show
+      @plan = Stripe::Plan.retrieve(params[:id])
+
+      unless @plan.present?
+        flash[:danger] = "Unrecognized Stripe Plan: #{params[:id]}"
+        raise ActiveRecord::RecordNotFound
+      end
+
+      @subscription = @customer.subscriptions.find { |subscription| subscription.stripe_plan_id == params[:id] }
+
+      unless @subscription.present?
+        flash[:danger] = "Unable to find Customer Subscription for plan: #{params[:id]}"
+        raise ActiveRecord::RecordNotFound
+      end
+
+      @stripe_subscription = @subscription.try(:stripe_subscription)
+
+      unless @stripe_subscription.present?
+        flash[:danger] = "Unable to find Stripe Subscription for plan: #{params[:id]}"
+        raise ActiveRecord::RecordNotFound
+      end
+
+      EffectiveOrders.authorized?(self, :show, @subscription)
+
+      @invoices = @customer.stripe_customer.invoices.all.select do |invoice| 
+        invoice.lines.any? { |line| line.id == @stripe_subscription.id }
+      end
+
+      @page_title ||= "#{@plan.name}"
+    end
+
+    def destroy
+      @plan = Stripe::Plan.retrieve(params[:id])
+      raise ActiveRecord::RecordNotFound unless @plan.present?
+
+      @subscription = @customer.subscriptions.find { |subscription| subscription.stripe_plan_id == params[:id] }
+      @stripe_subscription = @subscription.try(:stripe_subscription)
+      raise ActiveRecord::RecordNotFound unless @subscription.present?
+
+      EffectiveOrders.authorized?(self, :destroy, @subscription)
+
+      if @subscription.present?
+        begin
+          @stripe_subscription.delete if @stripe_subscription
+          @subscription.destroy
+          flash[:success] = "Successfully unsubscribed from #{params[:id]}"
+        rescue => e
+          flash[:danger] = "Unable to unsubscribe.  Message: \"#{e.message}\"."
+        end
+      else
+        flash[:danger] = "Unable to find stripe subscription for #{params[:id]}" unless @subscription.present?
+      end
+
+      redirect_to effective_orders.subscriptions_path
+    end
+
+    private
+
+    def assign_customer
+      @customer ||= Customer.for_user(current_user)
+    end
+
+    # StrongParameters
+    def subscription_params
+      begin
+        params.require(:effective_subscription).permit(:stripe_plan_id, :stripe_coupon_id)
+      rescue => e
+        params[:effective_subscription]
+      end
+    end
+
+  end
+end

data/app/controllers/effective/webhooks_controller.rb

@@ -0,0 +1,86 @@
+module Effective
+  class WebhooksController < ApplicationController
+    protect_from_forgery :except => [:stripe]
+    skip_authorization_check if defined?(CanCan)
+
+    # Webhook from stripe
+    def stripe
+      (head(:ok) and return) if (params[:livemode] == false && Rails.env.production?) || params[:object] != 'event' || params[:id].blank?
+
+      # Dont trust the POST, and instead request the actual event from Stripe
+      @event = Stripe::Event.retrieve(params[:id]) rescue (head(:ok) and return)
+
+      Effective::Customer.transaction do
+        begin
+          case @event.type
+          when 'customer.created'   ; stripe_customer_created(@event)
+          when 'customer.deleted'   ; stripe_customer_deleted(@event)
+          when 'customer.subscription.created'    ; stripe_subscription_created(@event)
+          when 'customer.subscription.deleted'    ; stripe_subscription_deleted(@event)
+          end
+        rescue => e
+          Rails.logger.info "Stripe Webhook Error: #{e.message}"
+          raise ActiveRecord::Rollback
+        end
+      end
+
+      head :ok  # Always return success
+    end
+
+    private
+
+    def stripe_customer_created(event)
+      stripe_customer = event.data.object
+      user = ::User.where(:email => stripe_customer.email).first
+
+      if user.present?
+        customer = Effective::Customer.for_user(user)  # This is a first_or_create
+        customer.stripe_customer_id = stripe_customer.id
+        customer.save!
+      end
+    end
+
+    def stripe_customer_deleted(event)
+      stripe_customer = event.data.object
+      user = ::User.where(:email => stripe_customer.email).first
+
+      if user.present?
+        customer = Effective::Customer.where(:user_id => user.id).first
+        customer.destroy! if customer
+      end
+    end
+
+    def stripe_subscription_created(event)
+      stripe_subscription = event.data.object
+      @customer = Effective::Customer.where(:stripe_customer_id => stripe_subscription.customer).first
+
+      if @customer.present?
+        subscription = @customer.subscriptions.where(:stripe_plan_id => stripe_subscription.plan.id).first_or_initialize
+
+        subscription.stripe_subscription_id = stripe_subscription.id
+        subscription.stripe_plan_id = (stripe_subscription.plan.id rescue nil)
+        subscription.stripe_coupon_id = stripe_subscription.discount.coupon.id if (stripe_subscription.discount.present? rescue false)
+
+        subscription.save!
+
+        unless subscription.purchased?
+          # Now we have to purchase it
+          @order = Effective::Order.new(subscription)
+          @order.user = @customer.user
+          @order.purchase!("via Stripe webhook #{event.id}")
+        end
+
+      end
+    end
+
+    def stripe_subscription_deleted(event)
+      stripe_subscription = event.data.object
+      customer = Effective::Customer.where(:stripe_customer_id => stripe_subscription.customer).first
+
+      if customer.present?
+        customer.subscriptions.find { |subscription| subscription.stripe_plan_id == stripe_subscription.plan.id }.try(:destroy)
+      end
+    end
+
+  end
+end

data/app/helpers/effective_carts_helper.rb

@@ -0,0 +1,90 @@
+module EffectiveCartsHelper
+  def current_cart(for_user = nil)
+    @cart ||= (
+      user = for_user || (current_user rescue nil) # rescue protects me against Devise not being installed
+
+      if user.present?
+        Effective::Cart.where(:user_id => user.id).first_or_create.tap do |user_cart|
+          if session[:cart].present?
+            session_cart = Effective::Cart.where('user_id IS NULL').where(:id => session[:cart]).first
+
+            if session_cart.present?
+              session_cart.cart_items.update_all(:cart_id => user_cart.id)
+              session_cart.destroy
+              user_cart.reload
+            end
+
+            session[:cart] = nil
+          end
+        end
+      elsif session[:cart].present?
+        Effective::Cart.where('user_id IS NULL').where(:id => session[:cart]).first_or_create
+      else
+        cart = Effective::Cart.create!
+        session[:cart] = cart.id
+        cart
+      end
+    )
+  end
+
+  def link_to_current_cart(opts = {})
+    options = {:id => 'current_cart', :rel => :nofollow}.merge(opts)
+
+    if current_cart.size == 0
+      link_to (options.delete(:label) || 'Cart'), effective_orders.cart_path, options
+    else
+      link_to (options.delete(:label) || "Cart (#{current_cart.size})"), effective_orders.cart_path, options
+    end
+  end
+
+  def link_to_add_to_cart(purchasable, opts = {})
+    raise ArgumentError.new('expecting an acts_as_purchasable object') unless purchasable.respond_to?(:is_effectively_purchasable?)
+
+    options = {:class => 'btn', :rel => :nofollow, 'data-disable-with' => 'Add to Cart...'}.merge(opts)
+    options[:class] = ((options[:class] || '') + ' btn-add-to-cart')
+
+    link_to (options.delete(:label) || 'Add to Cart'), effective_orders.add_to_cart_path(:purchasable_type => purchasable.class.name, :purchasable_id => purchasable.id.to_i), options
+  end
+
+  def link_to_remove_from_cart(cart_item, opts = {})
+    raise ArgumentError.new('expecting an Effective::CartItem object') unless cart_item.kind_of?(Effective::CartItem)
+
+    options = {
+      :rel => :nofollow,
+      :data => {:confirm => 'Are you sure? This cannot be undone!'},
+      :method => :delete
+    }.merge(opts)
+    options[:class] = ((options[:class] || '') + ' btn-remove-from-cart')
+
+    link_to (options.delete(:label) || 'Remove'), effective_orders.remove_from_cart_path(cart_item), options
+  end
+
+  def link_to_empty_cart(opts = {})
+    options = {
+      :rel => :nofollow,
+      :class => 'btn',
+      :data => {:confirm => 'This will clear your entire cart.  Are you sure?  This cannot be undone!'},
+      :method => :delete
+    }.merge(opts)
+    options[:class] = ((options[:class] || '') + ' btn-empty-cart btn-danger')
+
+    link_to (options.delete(:label) || 'Empty Cart'), effective_orders.cart_path, options
+  end
+
+  def link_to_checkout(opts = {})
+    options = {:class => 'btn', :rel => :nofollow}.merge(opts)
+    options[:class] = ((options[:class] || '') + ' btn-checkout')
+
+    link_to (options.delete(:label) || 'Proceed to Checkout'), effective_orders.new_order_path, options
+  end
+
+  def render_cart(cart = nil)
+    cart ||= current_cart
+    render(:partial => 'effective/carts/cart', :locals => {:cart => cart})
+  end
+
+  def render_purchasables(*purchasables)
+    render(:partial => 'effective/orders/order_items', :locals => {:order => Effective::Order.new(purchasables)})
+  end
+
+end

data/app/helpers/effective_orders_helper.rb

@@ -0,0 +1,108 @@
+module EffectiveOrdersHelper
+  def price_to_currency(price)
+    raise 'price_to_currency expects an Integer representing the number of cents in a price' unless price.kind_of?(Integer)
+    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')}:") +
+
+    content_tag(:ul) do
+      order.order_items.map do |item|
+        content_tag(:li) do
+          title = item.title.split('<br>')
+          "#{item.quantity}x #{title.first} for #{price_to_currency(item.price)}".tap do |output|
+            title[1..-1].each { |line| output << "<br>#{line}" }
+          end.html_safe
+        end
+      end.join().html_safe
+    end
+  end
+
+  def order_item_summary(order_item)
+    if order_item.quantity > 1
+      content_tag(:p, "#{price_to_currency(order_item.total)} total for #{pluralize(order_item.quantity, 'item')}")
+    else
+      content_tag(:p, "#{price_to_currency(order_item.total)} total")
+    end
+  end
+
+  # This is called on the My Sales Page and is intended to be overridden in the app if needed
+  def acts_as_purchasable_path(purchasable, action = :show)
+    polymorphic_path(purchasable)
+  end
+
+  def order_payment_to_html(order)
+    payment = order.payment
+
+    if order.purchased?(:stripe_connect) && order.payment.kind_of?(Hash)
+      payment = Hash[
+        order.payment.map do |seller_id, v|
+          if (user = Effective::Customer.find(seller_id).try(:user))
+            [link_to(user, admin_user_path(user)), order.payment[seller_id]]
+          else
+            [seller_id, order.payment[seller_id]]
+          end
+        end
+      ]
+    end
+
+    content_tag(:pre) do
+      raw JSON.pretty_generate(payment).html_safe
+        .gsub('\"', '')
+        .gsub("[\n\n    ]", '[]')
+        .gsub("{\n    }", '{}')
+    end
+  end
+
+  def render_order(order)
+    render(:partial => 'effective/orders/order', :locals => {:order => order})
+  end
+
+  def render_checkout(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?
+      render(:partial => 'effective/orders/checkout_step_1', :locals => locals.merge({:order => order}))
+    else
+      raise ArgumentError.new('unable to checkout a persisted but invalid order') unless order.valid?
+      render(:partial => 'effective/orders/checkout_step_2', :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
+  end
+  alias_method :link_to_order_history, :link_to_my_purchases
+
+  def render_order_history(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
+    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)
+  end
+
+  alias_method :render_purchases, :render_order_history
+  alias_method :render_my_purchases, :render_order_history
+
+end

data/app/helpers/effective_paypal_helper.rb

@@ -0,0 +1,37 @@
+module EffectivePaypalHelper
+  # These're constants so they only get read once, not every order request
+  PAYPAL_CERT_PEM = (File.read(EffectiveOrders.paypal[:paypal_cert]) rescue {})
+  APP_CERT_PEM = (File.read(EffectiveOrders.paypal[:app_cert]) rescue {})
+  APP_KEY_PEM = (File.read(EffectiveOrders.paypal[:app_key]) rescue {})
+
+  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?
+
+    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 + EffectiveOrders.paypal[:order_id_nudge].to_i,
+      :amount => (order.subtotal / 100.0).round(2),
+      :tax_cart => (order.tax / 100.0).round(2)
+    }
+
+    order.order_items.each_with_index do |item, x|
+      values["item_number_#{x+1}"] = x+1
+      values["item_name_#{x+1}"] = item.title
+      values["quantity_#{x+1}"] = item.quantity
+      values["amount_#{x+1}"] = '%.2f' % (item.price / 100.0)
+      values["tax_#{x+1}"] = '%.2f' % ((item.tax / 100.0) / item.quantity)  # Tax for 1 of these items
+    end
+
+    signed = OpenSSL::PKCS7::sign(OpenSSL::X509::Certificate.new(APP_CERT_PEM), OpenSSL::PKey::RSA.new(APP_KEY_PEM, ''), values.map { |k, v| "#{k}=#{v}" }.join("\n"), [], OpenSSL::PKCS7::BINARY)
+    OpenSSL::PKCS7::encrypt([OpenSSL::X509::Certificate.new(PAYPAL_CERT_PEM)], signed.to_der, OpenSSL::Cipher::Cipher::new("DES3"), OpenSSL::PKCS7::BINARY).to_s.gsub("\n", "")
+  end
+end

data/app/helpers/effective_stripe_helper.rb

@@ -0,0 +1,63 @@
+module EffectiveStripeHelper
+
+  STRIPE_CONNECT_AUTHORIZE_URL = 'https://connect.stripe.com/oauth/authorize'
+  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
+  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?
+
+    authorize_params = {
+      response_type: :code,
+      client_id: client_id,            # This is the Application's ClientID
+      scope: :read_write,
+      state: {
+        form_authenticity_token: form_authenticity_token,   # Rails standard CSRF
+        redirect_to: URI.encode(request.original_url)  # TODO: Allow this to be customized
+      }.to_json
+    }
+
+    # Add the stripe_user parameter if it's possible
+    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
+    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(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
+
+    "#{plan.name} - #{ActionController::Base.helpers.price_to_currency(plan.amount)} #{plan.currency.upcase}#{occurrence}"
+  end
+
+  def stripe_coupon_description(coupon)
+    amount = coupon.amount_off.present? ? ActionController::Base.helpers.price_to_currency(coupon.amount_off) : "#{coupon.percent_off}%"
+
+    if coupon.duration_in_months.present?
+      "#{coupon.id} - #{amount} off for #{coupon.duration_in_months} months"
+    else
+      "#{coupon.id} - #{amount} off #{coupon.duration}"
+    end
+  end
+
+end