pay 0.0.2 → 1.0.0.beta2

data/lib/pay/engine.rb

@@ -1,5 +1,18 @@
 module Pay
   class Engine < ::Rails::Engine
-    isolate_namespace Pay
+    engine_name 'pay'
+
+    initializer 'pay.processors' do
+      # Include processor backends
+      require 'pay/stripe'    if defined? ::Stripe
+      require 'pay/braintree' if defined? ::Braintree
+    end
+
+    config.to_prepare do
+      Pay::Stripe.setup    if defined? ::Stripe
+      Pay::Braintree.setup if defined? ::Braintree
+
+      Pay.charge_model.include Pay::Receipts if defined? Receipts::Receipt
+    end
   end
 end

data/lib/pay/receipts.rb

@@ -0,0 +1,37 @@
+module Pay
+  module Receipts
+    def filename
+      "receipt-#{created_at.strftime('%Y-%m-%d')}.pdf"
+    end
+
+    # Must return a file object
+    def receipt
+      receipt_pdf.render
+    end
+
+    def receipt_pdf
+      Receipts::Receipt.new(
+        id: id,
+        product: Pay.config.application_name,
+        company: {
+          name:    Pay.config.business_name,
+          address: Pay.config.business_address,
+          email:   Pay.config.support_email,
+        },
+        line_items: line_items
+      )
+    end
+
+    def line_items
+      line_items = [
+        ["Date",           created_at.to_s],
+        ["Account Billed", "#{owner.name} (#{owner.email})"],
+        ["Product",        Pay.config.application_name],
+        ["Amount",         ActionController::Base.helpers.number_to_currency(amount / 100.0)],
+        ["Charged to",     charged_to],
+      ]
+      line_items << ["Additional Info", owner.extra_billing_info] if owner.extra_billing_info?
+      line_items
+    end
+  end
+end

data/lib/pay/stripe.rb

@@ -0,0 +1,17 @@
+require 'pay/stripe/api'
+require 'pay/stripe/billable'
+require 'pay/stripe/charge'
+require 'pay/stripe/subscription'
+require 'pay/stripe/webhooks'
+
+module Pay
+  module Stripe
+    def self.setup
+      Pay::Stripe::Api.set_api_keys
+
+      Pay.charge_model.include Pay::Stripe::Charge
+      Pay.subscription_model.include Pay::Stripe::Subscription
+      Pay.user_model.include Pay::Stripe::Billable
+    end
+  end
+end

data/lib/pay/stripe/api.rb

@@ -0,0 +1,13 @@
+module Pay
+  module Stripe
+    module Api
+      def self.set_api_keys
+        env         = Rails.env.to_sym
+        secrets     = Rails.application.secrets
+        credentials = Rails.application.credentials
+
+        ::Stripe.api_key = ENV["STRIPE_PRIVATE_KEY"] || secrets.dig(env, :stripe, :private_key) || credentials.dig(env, :stripe, :private_key)
+      end
+    end
+  end
+end

data/lib/pay/stripe/billable.rb

@@ -0,0 +1,143 @@
+module Pay
+  module Stripe
+    module Billable
+      # Handles Billable#customer
+      #
+      # Returns Stripe::Customer
+      def stripe_customer
+        if processor_id?
+          ::Stripe::Customer.retrieve(processor_id)
+        else
+          create_stripe_customer
+        end
+      rescue ::Stripe::StripeError => e
+        raise Error, e.message
+      end
+
+      # Handles Billable#charge
+      #
+      # Returns Pay::Charge
+      def create_stripe_charge(amount, options={})
+        args = {
+          amount: amount,
+          currency: 'usd',
+          customer: customer.id,
+          description: customer_name,
+        }.merge(options)
+
+        stripe_charge = ::Stripe::Charge.create(args)
+
+        # Save the charge to the db, returns Charge
+        Pay::Stripe::Webhooks::ChargeSucceeded.new.create_charge(self, stripe_charge)
+      rescue ::Stripe::StripeError => e
+        raise Error, e.message
+      end
+
+      # Handles Billable#subscribe
+      #
+      # Returns Pay::Subscription
+      def create_stripe_subscription(name, plan, options={})
+        opts = { plan: plan, trial_from_plan: true }.merge(options)
+        stripe_sub   = customer.subscriptions.create(opts)
+        subscription = create_subscription(stripe_sub, 'stripe', name, plan)
+        subscription
+      rescue ::Stripe::StripeError => e
+        raise Error, e.message
+      end
+
+      # Handles Billable#update_card
+      #
+      # Returns true if successful
+      def update_stripe_card(token)
+        customer = stripe_customer
+        token = ::Stripe::Token.retrieve(token)
+
+        return if token.card.id == customer.default_source
+
+        card = customer.sources.create(source: token.id)
+        customer.default_source = card.id
+        customer.save
+
+        update_stripe_card_on_file(card)
+        true
+      rescue ::Stripe::StripeError => e
+        raise Error, e.message
+      end
+
+      def update_stripe_email!
+        customer = stripe_customer
+        customer.email = email
+        customer.description = customer_name
+        customer.save
+      end
+
+      def stripe_subscription(subscription_id)
+        ::Stripe::Subscription.retrieve(subscription_id)
+      end
+
+      def stripe_invoice!
+        return unless processor_id?
+        ::Stripe::Invoice.create(customer: processor_id).pay
+      end
+
+      def stripe_upcoming_invoice
+        ::Stripe::Invoice.upcoming(customer: processor_id)
+      end
+
+      def stripe?
+        processor == "stripe"
+      end
+
+      # Used by webhooks when the customer or source changes
+      def sync_card_from_stripe
+        stripe_cust = stripe_customer
+        default_source_id = stripe_cust.default_source
+
+        if default_source_id.present?
+          card = stripe_customer.sources.data.find{ |s| s.id == default_source_id }
+          update(
+            card_type:      card.brand,
+            card_last4:     card.last4,
+            card_exp_month: card.exp_month,
+            card_exp_year:  card.exp_year
+          )
+
+        # Customer has no default payment source
+        else
+          update(card_type: nil, card_last4: nil)
+        end
+      end
+
+      private
+
+      def create_stripe_customer
+        customer = ::Stripe::Customer.create(email: email, source: card_token, description: customer_name)
+        update(processor: 'stripe', processor_id: customer.id)
+
+        # Update the user's card on file if a token was passed in
+        source = customer.sources.data.first
+        if source.present?
+          update_stripe_card_on_file customer.sources.retrieve(source.id)
+        end
+
+        customer
+      end
+
+      def stripe_trial_end_date(stripe_sub)
+        stripe_sub.trial_end.present? ? Time.at(stripe_sub.trial_end) : nil
+      end
+
+      # Save the card to the database as the user's current card
+      def update_stripe_card_on_file(card)
+        update!(
+          card_type:      card.brand,
+          card_last4:     card.last4,
+          card_exp_month: card.exp_month,
+          card_exp_year:  card.exp_year
+        )
+
+        self.card_token = nil
+      end
+    end
+  end
+end

data/lib/pay/stripe/charge.rb

@@ -0,0 +1,30 @@
+module Pay
+  module Stripe
+
+    module Charge
+      extend ActiveSupport::Concern
+
+      def stripe?
+        processor == "stripe"
+      end
+
+      def stripe_charge
+        Stripe::Charge.retrieve(processor_id)
+      rescue ::Stripe::StripeError => e
+        raise Error, e.message
+      end
+
+      def stripe_refund!(amount_to_refund)
+        Stripe::Refund.create(
+          charge: processor_id,
+          amount: amount_to_refund
+        )
+
+        update(amount_refunded: amount_to_refund)
+      rescue ::Stripe::StripeError => e
+        raise Error, e.message
+      end
+    end
+
+  end
+end

data/lib/pay/stripe/subscription.rb

@@ -0,0 +1,48 @@
+module Pay
+  module Stripe
+    module Subscription
+      def stripe?
+        processor == "stripe"
+      end
+
+      def stripe_cancel
+        subscription = processor_subscription
+        subscription.cancel_at_period_end = true
+        subscription.save
+
+        new_ends_at  = on_trial? ? trial_ends_at : Time.at(subscription.current_period_end)
+        update(ends_at: new_ends_at)
+      rescue ::Stripe::StripeError => e
+        raise Error, e.message
+      end
+
+      def stripe_cancel_now!
+        subscription = processor_subscription.delete
+        update(ends_at: Time.zone.now)
+      rescue ::Stripe::StripeError => e
+        raise Error, e.message
+      end
+
+      def stripe_resume
+        subscription = processor_subscription
+        subscription.plan = processor_plan
+        subscription.trial_end = on_trial? ? trial_ends_at.to_i : 'now'
+        subscription.cancel_at_period_end = false
+        subscription.save
+      rescue ::Stripe::StripeError => e
+        raise Error, e.message
+      end
+
+      def stripe_swap(plan)
+        subscription = processor_subscription
+        subscription.plan = plan
+        subscription.prorate = prorate
+        subscription.trial_end = on_trial? ? trial_ends_at.to_i : 'now'
+        subscription.quantity = quantity if quantity?
+        subscription.save
+      rescue ::Stripe::StripeError => e
+        raise Error, e.message
+      end
+    end
+  end
+end

data/lib/pay/stripe/webhooks.rb

@@ -0,0 +1,39 @@
+require 'stripe_event'
+Dir[File.join(__dir__, 'webhooks', '**', '*.rb')].each { |file| require file }
+
+env         = Rails.env.to_sym
+secrets     = Rails.application.secrets
+credentials = Rails.application.credentials
+
+StripeEvent.signing_secret = ENV["STRIPE_SIGNING_SECRET"] || secrets.dig(env, :stripe, :signing_secret) || credentials.dig(env, :stripe, :signing_secret)
+
+StripeEvent.configure do |events|
+  # Listen to the charge event to make sure we get non-subscription
+  # purchases as well. Invoice is only for subscriptions and manual creation
+  # so it does not include individual charges.
+  events.subscribe 'charge.succeeded', Pay::Stripe::Webhooks::ChargeSucceeded.new
+  events.subscribe 'charge.refunded', Pay::Stripe::Webhooks::ChargeRefunded.new
+
+  # Warn user of upcoming charges for their subscription. This is handy for
+  # notifying annual users their subscription will renew shortly.
+  # This probably should be ignored for monthly subscriptions.
+  events.subscribe 'invoice.upcoming', Pay::Stripe::Webhooks::SubscriptionRenewing.new
+
+  # If a subscription is manually created on Stripe, we want to sync
+  events.subscribe 'customer.subscription.created', Pay::Stripe::Webhooks::SubscriptionCreated.new
+
+  # If the plan, quantity, or trial ending date is updated on Stripe, we want to sync
+  events.subscribe 'customer.subscription.updated', Pay::Stripe::Webhooks::SubscriptionUpdated.new
+
+  # When a customers subscription is canceled, we want to update our records
+  events.subscribe 'customer.subscription.deleted', Pay::Stripe::Webhooks::SubscriptionDeleted.new
+
+  # Monitor changes for customer's default card changing
+  events.subscribe 'customer.updated', Pay::Stripe::Webhooks::CustomerUpdated.new
+
+  # If a customer was deleted in Stripe, their subscriptions should be cancelled
+  events.subscribe 'customer.deleted', Pay::Stripe::Webhooks::CustomerDeleted.new
+
+  # If a customer's payment source was deleted in Stripe, we should update as well
+  events.subscribe 'customer.source.deleted', Pay::Stripe::Webhooks::SourceDeleted.new
+end

data/lib/pay/stripe/webhooks/charge_refunded.rb

@@ -0,0 +1,25 @@
+module Pay
+  module Stripe
+    module Webhooks
+
+      class ChargeRefunded
+        def call(event)
+          object = event.data.object
+          charge = Pay.charge_model.find_by(processor: :stripe, processor_id: object.id)
+
+          return unless charge.present?
+
+          charge.update(amount_refunded: object.amount_refunded)
+          notify_user(charge.owner, charge)
+        end
+
+        def notify_user(user, charge)
+          if Pay.send_emails
+            Pay::UserMailer.refund(user, charge).deliver_later
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/pay/stripe/webhooks/charge_succeeded.rb

@@ -0,0 +1,47 @@
+module Pay
+  module Stripe
+    module Webhooks
+
+      class ChargeSucceeded
+        def call(event)
+          object = event.data.object
+          user   = Pay.user_model.find_by(
+            processor: :stripe,
+            processor_id: object.customer
+          )
+
+          return unless user.present?
+          return if user.charges.where(processor_id: object.id).any?
+
+          charge = create_charge(user, object)
+          notify_user(user, charge)
+          charge
+        end
+
+        def create_charge(user, object)
+          charge = user.charges.find_or_initialize_by(
+            processor:      :stripe,
+            processor_id:   object.id,
+          )
+
+          charge.update(
+            amount:         object.amount,
+            card_last4:     object.source.last4,
+            card_type:      object.source.brand,
+            card_exp_month: object.source.exp_month,
+            card_exp_year:  object.source.exp_year,
+            created_at:     Time.zone.at(object.created)
+          )
+
+          charge
+        end
+
+        def notify_user(user, charge)
+          if Pay.send_emails && charge.respond_to?(:receipt)
+            Pay::UserMailer.receipt(user, charge).deliver_later
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pay/stripe/webhooks/customer_deleted.rb

@@ -0,0 +1,31 @@
+module Pay
+  module Stripe
+    module Webhooks
+
+      class CustomerDeleted
+        def call(event)
+          object = event.data.object
+          user = Pay.user_model.find_by(processor: :stripe, processor_id: object.id)
+
+          # Couldn't find user, we can skip
+          return unless user.present?
+
+          user.update(
+            processor_id:   nil,
+            trial_ends_at:  nil,
+            card_type:      nil,
+            card_last4:     nil,
+            card_exp_month: nil,
+            card_exp_year:  nil,
+          )
+
+          user.subscriptions.update_all(
+            trial_ends_at: nil,
+            ends_at: Time.zone.now,
+          )
+        end
+      end
+
+    end
+  end
+end