pay 0.0.2 → 1.0.0.beta2

data/lib/pay/billable/sync_email.rb

@@ -0,0 +1,41 @@
+module Pay
+  module Billable
+    module SyncEmail
+      # Sync email address changes from the model to the processor.
+      # This way they're kept in sync and email notifications are
+      # always sent to the correct email address after an update.
+      #
+      # Processor classes simply need to implement a method named:
+      #
+      # update_PROCESSOR_email!
+      #
+      # This method should take the email address on the billable
+      # object and update the associated API record.
+
+      extend ActiveSupport::Concern
+
+      included do
+        after_update :enqeue_sync_email_job,
+                     if: :should_sync_email_with_processor?
+      end
+
+      def should_sync_email_with_processor?
+        respond_to? :saved_change_to_email?
+      end
+
+      def sync_email_with_processor
+        send("update_#{processor}_email!")
+      end
+
+      private
+
+      def enqeue_sync_email_job
+        # Only update if the processor id is the same
+        # This prevents duplicate API hits if this is their first time
+        if processor_id? && !processor_id_changed? && saved_change_to_email?
+          EmailSyncJob.perform_later(id)
+        end
+      end
+    end
+  end
+end

data/lib/pay/braintree.rb

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

data/lib/pay/braintree/api.rb

@@ -0,0 +1,30 @@
+module Pay
+  module Braintree
+    module Api
+      def self.set_api_keys
+        environment = get_key_for(:environment, 'sandbox')
+        merchant_id = get_key_for(:merchant_id)
+        public_key  = get_key_for(:public_key)
+        private_key = get_key_for(:private_key)
+
+        Pay.braintree_gateway = ::Braintree::Gateway.new(
+          environment: environment.to_sym,
+          merchant_id: merchant_id,
+          public_key: public_key,
+          private_key: private_key
+        )
+      end
+
+      def self.get_key_for(name, default = '')
+        env         = Rails.env.to_sym
+        secrets     = Rails.application.secrets
+        credentials = Rails.application.credentials
+
+        ENV["BRAINTREE_#{name.upcase}"] ||
+          secrets.dig(env, :braintree, name) ||
+          credentials.dig(env, :braintree, name) ||
+          default
+      end
+    end
+  end
+end

data/lib/pay/braintree/billable.rb

@@ -0,0 +1,219 @@
+module Pay
+  module Braintree
+    module Billable
+      # Handles Billable#customer
+      #
+      # Returns Braintree::Customer
+      def braintree_customer
+        if processor_id?
+          gateway.customer.find(processor_id)
+        else
+          result = gateway.customer.create(
+            email: email,
+            first_name: try(:first_name),
+            last_name: try(:last_name),
+            payment_method_nonce: card_token,
+          )
+          raise Pay::Error.new(result.message) unless result.success?
+
+          update(processor: 'braintree', processor_id: result.customer.id)
+
+          if card_token.present?
+            update_braintree_card_on_file result.customer.payment_methods.last
+          end
+
+          result.customer
+        end
+      rescue ::Braintree::BraintreeError => e
+        raise Error, e.message
+      end
+
+      # Handles Billable#charge
+      #
+      # Returns a Pay::Charge
+      def create_braintree_charge(amount, options={})
+        args = {
+          amount: amount / 100.0,
+          customer_id: customer.id,
+          options: { submit_for_settlement: true }
+        }.merge(options)
+
+        result = gateway.transaction.sale(args)
+        save_braintree_transaction(result.transaction) if result.success?
+      rescue ::BraintreeError => e
+        raise Error, e.message
+      end
+
+      # Handles Billable#subscribe
+      #
+      # Returns Pay::Subscription
+      def create_braintree_subscription(name, plan, options={})
+        token = customer.payment_methods.find(&:default?).try(:token)
+        raise Pay::Error, "Customer has no default payment method" if token.nil?
+
+        subscription_options = options.merge(
+          payment_method_token: token,
+          plan_id: plan
+        )
+
+        result = gateway.subscription.create(subscription_options)
+        raise Pay::Error.new(result.message) unless result.success?
+
+        create_subscription(result.subscription, 'braintree', name, plan)
+      rescue ::Braintree::BraintreeError => e
+        raise Error, e.message
+      end
+
+      # Handles Billable#update_card
+      #
+      # Returns true if successful
+      def update_braintree_card(token)
+        result = gateway.payment_method.create(
+          customer_id: processor_id,
+          payment_method_nonce: token,
+          options: {
+            make_default: true,
+            verify_card: true
+          }
+        )
+        raise Pay::Error.new(result.message) unless result.success?
+
+        update_braintree_card_on_file result.payment_method
+        update_subscriptions_to_payment_method(result.payment_method.token)
+        true
+      rescue ::Braintree::BraintreeError => e
+        raise Error, e.message
+      end
+
+      def update_braintree_email!
+        braintree_customer.update(
+          email:      email,
+          first_name: try(:first_name),
+          last_name:  try(:last_name),
+        )
+      end
+
+      def braintree_trial_end_date(subscription)
+        return unless subscription.trial_period
+        Time.zone.parse(subscription.first_billing_date)
+      end
+
+      def update_subscriptions_to_payment_method(token)
+        subscriptions.each do |subscription|
+          if subscription.active?
+            gateway.subscription.update(subscription.processor_id, { payment_method_token: token })
+          end
+        end
+      end
+
+      def braintree_subscription(subscription_id)
+        gateway.subscription.find(subscription_id)
+      end
+
+      def braintree_invoice!
+        # pass
+      end
+
+      def braintree_upcoming_invoice
+        # pass
+      end
+
+      def braintree?
+        processor == "braintree"
+      end
+
+      def paypal?
+        braintree? && card_type == "PayPal"
+      end
+
+      def save_braintree_transaction(transaction)
+        attrs = card_details_for_braintree_transaction(transaction)
+        attrs.merge!(amount: transaction.amount.to_f * 100)
+
+        charge = charges.find_or_initialize_by(
+          processor: :braintree,
+          processor_id: transaction.id
+        )
+        charge.update(attrs)
+        charge
+      end
+
+      private
+
+        def gateway
+          Pay.braintree_gateway
+        end
+
+        def update_braintree_card_on_file(payment_method)
+          case payment_method
+          when ::Braintree::CreditCard
+            update!(
+              card_type: payment_method.card_type,
+              card_last4: payment_method.last_4,
+              card_exp_month: payment_method.expiration_month,
+              card_exp_year: payment_method.expiration_year
+            )
+
+          when ::Braintree::PayPalAccount
+            update!(
+              card_type: "PayPal",
+              card_last4: payment_method.email
+            )
+          end
+
+          # Clear the card token so we don't accidentally update twice
+          self.card_token = nil
+        end
+
+        def card_details_for_braintree_transaction(transaction)
+          case transaction.payment_instrument_type
+          when "credit_card", "samsung_pay_card", "masterpass_card", "samsung_pay_card", "visa_checkout_card"
+            payment_method = transaction.send("#{transaction.payment_instrument_type}_details")
+            {
+              card_type:      payment_method.card_type,
+              card_last4:     payment_method.last_4,
+              card_exp_month: payment_method.expiration_month,
+              card_exp_year:  payment_method.expiration_year,
+            }
+
+          when "paypal_account"
+            {
+              card_type: "PayPal",
+              card_last4: transaction.paypal_details.payer_email,
+              card_exp_month: nil,
+              card_exp_year: nil,
+            }
+
+          when "android_pay_card"
+            payment_method = transaction.android_pay_details
+            {
+              card_type:      payment_method.source_card_type,
+              card_last4:     payment_method.source_card_last_4,
+              card_exp_month: payment_method.expiration_month,
+              card_exp_year:  payment_method.expiration_year,
+            }
+
+          when "venmo_account"
+            {
+              card_type: "Venmo",
+              card_last4: transaction.venmo_account_details.username,
+              card_exp_month: nil,
+              card_exp_year: nil,
+            }
+
+          when "apple_pay_card"
+            payment_method = transaction.apple_pay_details
+            {
+              card_type:      payment_method.card_type,
+              card_last4:     payment_method.last_4,
+              card_exp_month: payment_method.expiration_month,
+              card_exp_year:  payment_method.expiration_year,
+            }
+
+          else
+            {}
+          end
+        end
+    end
+  end
+end

data/lib/pay/braintree/charge.rb

@@ -0,0 +1,27 @@
+module Pay
+  module Braintree
+
+    module Charge
+      extend ActiveSupport::Concern
+
+      def braintree?
+        processor == "braintree"
+      end
+
+      def braintree_charge
+        Pay.braintree_gateway.transaction.find(processor_id)
+      rescue ::Braintree::BraintreeError => e
+        raise Error, e.message
+      end
+
+      def braintree_refund!(amount_to_refund)
+        Pay.braintree_gateway.transaction.refund(processor_id, amount_to_refund / 100.0)
+
+        update(amount_refunded: amount_to_refund)
+      rescue ::Braintree::BraintreeError => e
+        raise Error, e.message
+      end
+    end
+
+  end
+end

data/lib/pay/braintree/subscription.rb

@@ -0,0 +1,173 @@
+module Pay
+  module Braintree
+    module Subscription
+      def braintree?
+        processor == "braintree"
+      end
+
+      def braintree_cancel
+        subscription = processor_subscription
+
+        if on_trial?
+          gateway.subscription.cancel(processor_subscription.id)
+          update(ends_at: trial_ends_at)
+        else
+          gateway.subscription.update(subscription.id, {
+            number_of_billing_cycles: subscription.current_billing_cycle
+          })
+          update(ends_at: subscription.billing_period_end_date)
+        end
+      rescue ::Braintree::BraintreeError => e
+        raise Error, e.message
+      end
+
+      def braintree_cancel_now!
+        gateway.subscription.cancel(processor_subscription.id)
+        update(ends_at: Time.zone.now)
+      rescue ::Braintree::BraintreeError => e
+        raise Error, e.message
+      end
+
+      def braintree_resume
+        if cancelled? && on_trial?
+          duration = trial_ends_at.to_date - Date.today
+
+          owner.subscribe(
+            name: name,
+            plan: processor_plan,
+            trial_period: true,
+            trial_duration: duration.to_i,
+            trial_duration_unit: :day
+          )
+
+        else
+          subscription = processor_subscription
+
+          gateway.subscription.update(subscription.id, {
+            never_expires: true,
+            number_of_billing_cycles: nil
+          })
+        end
+      rescue ::Braintree::BraintreeError => e
+        raise Error, e.message
+      end
+
+      def braintree_swap(plan)
+        if on_grace_period? && processor_plan == plan
+          resume
+          return
+        end
+
+        if !active?
+          owner.subscribe(name, plan, processor, trial_period: false)
+          return
+        end
+
+        braintree_plan = find_braintree_plan(plan)
+
+        if would_change_billing_frequency?(braintree_plan) && prorate?
+          swap_across_frequencies(braintree_plan)
+          return
+        end
+
+        subscription = processor_subscription
+
+        result = gateway.subscription.update(subscription.id, {
+          plan_id: braintree_plan.id,
+          price: braintree_plan.price,
+          never_expires: true,
+          number_of_billing_cycles: nil,
+          options: {
+            prorate_charges: prorate?,
+          }
+        })
+
+        if result.success?
+          update(processor_plan: braintree_plan.id, ends_at: nil)
+        else
+          raise Error, "Braintree failed to swap plans: #{result.message}"
+        end
+      rescue ::Braintree::BraintreeError => e
+        raise Error, e.message
+      end
+
+      private
+
+        def gateway
+          Pay.braintree_gateway
+        end
+
+        def would_change_billing_frequency?(plan)
+          plan.billing_frequency != find_braintree_plan(processor_plan).billing_frequency
+        end
+
+        def find_braintree_plan(id)
+          @braintree_plans ||= gateway.plan.all
+          @braintree_plans.find{ |p| p.id == id }
+        end
+
+        # Helper methods for swapping plans
+        def switching_to_monthly_plan?(current_plan, plan)
+          current_plan.billing_frequency == 12 && plan.billing_frequency == 1
+        end
+
+        def discount_for_switching_to_monthly(current_plan, plan)
+          cycles = (money_remaining_on_yearly_plan(current_plan) / plan.price).floor
+          OpenStruct.new(
+            amount: plan.price,
+            number_of_billing_cycles: cycles
+          )
+        end
+
+        def money_remaining_on_yearly_plan(current_plan)
+          end_date = processor_subscription.billing_period_end_date.to_date
+          (current_plan.price / 365) * (end_date - Date.today)
+        end
+
+        def discount_for_switching_to_yearly
+          amount = 0
+
+          processor_subscription.discounts.each do |discount|
+            if discount.id == 'plan-credit'
+              amount += discount.amount * discount.number_of_billing_cycles
+            end
+          end
+
+          OpenStruct.new(
+            amount: amount,
+            number_of_billing_cycles: 1
+          )
+        end
+
+        def swap_across_frequencies(plan)
+          current_plan = find_braintree_plan(processor_plan)
+
+          discount = if switching_to_monthly_plan?(current_plan, plan)
+                       discount_for_switching_to_monthly(current_plan, plan)
+                     else
+                       discount_for_switching_to_yearly
+                     end
+
+          options = {}
+
+          if discount.amount > 0 && discount.number_of_billing_cycles > 0
+            options = {
+              discounts: {
+                add: [
+                  {
+                    inherited_from_id: 'plan-credit',
+                    amount: discount.amount,
+                    number_of_billing_cycles: discount.number_of_billing_cycles
+                  }
+                ]
+              }
+            }
+          end
+
+          cancel_now!
+
+          owner.subscribe(options.merge(name: name, plan: plan.id))
+        end
+    end
+  end
+end