pay 2.6.11 → 3.0.0

data/lib/generators/active_record/templates/billable_migration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class AddPayBillableTo<%= table_name.camelize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    change_table :<%= table_name %>, bulk: true do |t|
+      t.string :processor
+      t.string :processor_id
+      t.public_send(Pay::Adapter.json_column_type, :pay_data)
+      t.datetime :trial_ends_at
+      t.string :card_type
+      t.string :card_last4
+      t.string :card_exp_month
+      t.string :card_exp_year
+      t.text :extra_billing_info
+    end
+  end
+end

data/lib/generators/active_record/templates/merchant_migration.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class AddPayMerchantTo<%= table_name.camelize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    add_column table_name, :merchant_processor, :string
+
+    # We may already have the pay_data column if a Pay::Billable object is also a Pay::Merchant
+    unless ActiveRecord::Base.connection.column_exists?(table_name, :pay_data)
+      add_column :<%= table_name %>, :pay_data, Pay::Adapter.json_column_type
+    end
+  end
+end

data/lib/generators/pay/{pay_generator.rb → billable_generator.rb}

@@ -4,13 +4,12 @@ require "rails/generators/named_base"
 
 module Pay
   module Generators
-    class PayGenerator < Rails::Generators::NamedBase
+    class BillableGenerator < Rails::Generators::NamedBase
       include Rails::Generators::ResourceHelpers
 
-      namespace "pay"
       source_root File.expand_path("../templates", __FILE__)
 
-      desc "Generates a migration to add Billable fields to a model."
+      desc "Generates a migration to add Pay::Billable fields to a model."
 
       hook_for :orm
     end

data/lib/generators/pay/merchant_generator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+
+module Pay
+  module Generators
+    class MerchantGenerator < Rails::Generators::NamedBase
+      include Rails::Generators::ResourceHelpers
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      desc "Generates a migration to add Pay::Merchant fields to a model."
+
+      hook_for :orm
+    end
+  end
+end

data/lib/generators/pay/orm_helpers.rb

@@ -3,12 +3,6 @@
 module Pay
   module Generators
     module OrmHelpers
-      def model_contents
-        <<-CONTENT
-  include Pay::Billable
-        CONTENT
-      end
-
       private
 
       def model_exists?
@@ -30,6 +24,16 @@ module Pay
       def model_path
         @model_path ||= File.join("app", "models", "#{file_path}.rb")
       end
+
+      def migration_version
+        if rails5_and_up?
+          "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+        end
+      end
+
+      def rails5_and_up?
+        Rails::VERSION::MAJOR >= 5
+      end
     end
   end
 end

data/lib/pay/adapter.rb

@@ -0,0 +1,22 @@
+module Pay
+  module Adapter
+    extend ActiveSupport::Concern
+
+    def self.current_adapter
+      if ActiveRecord::Base.respond_to?(:connection_db_config)
+        ActiveRecord::Base.connection_db_config.adapter
+      else
+        ActiveRecord::Base.connection_config[:adapter]
+      end
+    end
+
+    def self.json_column_type
+      case current_adapter
+      when "postgresql"
+        :jsonb
+      else
+        :json
+      end
+    end
+  end
+end

data/lib/pay/attributes.rb

@@ -0,0 +1,74 @@
+module Pay
+  # Adds Pay methods to ActiveRecord models
+
+  module Attributes
+    extend ActiveSupport::Concern
+
+    module CustomerExtension
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :pay_customers, class_name: "Pay::Customer", as: :owner, inverse_of: :owner
+        has_many :charges, through: :pay_customers, class_name: "Pay::Charge"
+        has_many :subscriptions, through: :pay_customers, class_name: "Pay::Subscription"
+        has_one :payment_processor, -> { where(default: true, deleted_at: nil) }, class_name: "Pay::Customer", as: :owner, inverse_of: :owner
+
+        after_commit :cancel_active_pay_subscriptions!, on: [:destroy]
+      end
+
+      # Changes a user's payment processor
+      #
+      # This has several effects:
+      # - Finds or creates a Pay::Customer for the process and marks it as default
+      # - Removes the default flag from all other Pay::Customers
+      # - Removes the default flag from all Pay::PaymentMethods
+      def set_payment_processor(processor_name, allow_fake: false, **attributes)
+        raise Pay::Error, "Processor `#{processor_name}` is not allowed" if processor_name.to_s == "fake_processor" && !allow_fake
+
+        ActiveRecord::Base.transaction do
+          pay_customers.update_all(default: false)
+          pay_customer = pay_customers.active.where(processor: processor_name).first_or_initialize
+          pay_customer.update!(attributes.merge(default: true))
+        end
+
+        # Return new payment processor
+        reload_payment_processor
+      end
+
+      def cancel_active_pay_subscriptions!
+        subscriptions.active.each(&:cancel_now!)
+      end
+    end
+
+    module MerchantExtension
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :pay_merchants, class_name: "Pay::Merchant", as: :owner, inverse_of: :owner
+        has_one :merchant_processor, -> { where(default: true) }, class_name: "Pay::Merchant", as: :owner, inverse_of: :owner
+      end
+
+      def set_merchant_processor(processor_name, **attributes)
+        ActiveRecord::Base.transaction do
+          pay_merchants.update_all(default: false)
+          pay_merchant = pay_merchants.where(processor: processor_name).first_or_initialize
+          pay_merchant.update!(attributes.merge(default: true))
+        end
+
+        # Return new payment processor
+        reload_merchant_processor
+      end
+    end
+
+    class_methods do
+      def pay_customer
+        include Billable::SyncCustomer
+        include CustomerExtension
+      end
+
+      def pay_merchant
+        include MerchantExtension
+      end
+    end
+  end
+end

data/lib/pay/billable/sync_customer.rb

@@ -0,0 +1,30 @@
+module Pay
+  module Billable
+    module SyncCustomer
+      # Syncs customer details to the payment processor.
+      # This way they're kept in sync and email notifications are
+      # always sent to the correct email address after an update.
+
+      extend ActiveSupport::Concern
+
+      included do
+        after_update :enqeue_sync_email_job, if: :pay_should_sync_customer?
+      end
+
+      def pay_should_sync_customer?
+        try(:saved_change_to_email?)
+      end
+
+      private
+
+      def enqeue_sync_email_job
+        if saved_change_to_email?
+          # Queue job to update each payment processor for this customer
+          pay_customers.pluck(:id).each do |pay_customer_id|
+            CustomerSyncJob.perform_later(id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pay/braintree/billable.rb

@@ -1,40 +1,42 @@
 module Pay
   module Braintree
     class Billable
-      attr_reader :billable
+      attr_reader :pay_customer
 
       delegate :processor_id,
         :processor_id?,
         :email,
         :customer_name,
-        :card_token,
-        to: :billable
+        :payment_method_token,
+        :payment_method_token?,
+        to: :pay_customer
 
-      def initialize(billable)
-        @billable = billable
+      def initialize(pay_customer)
+        @pay_customer = pay_customer
       end
 
-      # Handles Billable#customer
+      # Retrieve the Braintree::Customer object
       #
-      # Returns Braintree::Customer
+      # - If no processor_id is present, creates a Customer.
+      # - When 'payment_method_token' is present, it will also set the default payment method
       def customer
         if processor_id?
           customer = gateway.customer.find(processor_id)
-          update_card card_token if card_token.present?
+
+          if payment_method_token?
+            add_payment_method(payment_method_token, default: true)
+            pay_customer.payment_method_token = nil
+          end
+
           customer
         else
-          result = gateway.customer.create(
-            email: email,
-            first_name: try(:first_name),
-            last_name: try(:last_name),
-            payment_method_nonce: card_token
-          )
+          result = gateway.customer.create(email: email, first_name: try(:first_name), last_name: try(:last_name), payment_method_nonce: payment_method_token)
           raise Pay::Braintree::Error, result unless result.success?
+          pay_customer.update!(processor_id: result.customer.id)
 
-          billable.update(processor: "braintree", processor_id: result.customer.id)
-
-          if card_token.present?
-            update_card_on_file result.customer.payment_methods.last
+          if payment_method_token?
+            save_payment_method(result.customer.payment_methods.last, default: true)
+            pay_customer.payment_method_token = nil
           end
 
           result.customer
@@ -45,14 +47,12 @@ module Pay
         raise Pay::Braintree::Error, e
       end
 
-      # Handles Billable#charge
-      #
-      # Returns a Pay::Charge
       def charge(amount, options = {})
         args = {
           amount: amount.to_i / 100.0,
           customer_id: customer.id,
-          options: {submit_for_settlement: true}
+          options: {submit_for_settlement: true},
+          custom_fields: options.delete(:metadata)
         }.merge(options)
 
         result = gateway.transaction.sale(args)
@@ -65,9 +65,6 @@ module Pay
         raise Pay::Braintree::Error, e
       end
 
-      # Handles Billable#subscribe
-      #
-      # Returns Pay::Subscription
       def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
         token = customer.payment_methods.find(&:default?).try(:token)
         raise Pay::Error, "Customer has no default payment method" if token.nil?
@@ -77,6 +74,7 @@ module Pay
           options.merge!(trial_period: true, trial_duration: trial_period_days, trial_duration_unit: :day)
         end
 
+        metadata = options.delete(:metadata)
         subscription_options = options.merge(
           payment_method_token: token,
           plan_id: plan
@@ -85,32 +83,44 @@ module Pay
         result = gateway.subscription.create(subscription_options)
         raise Pay::Braintree::Error, result unless result.success?
 
-        billable.create_pay_subscription(result.subscription, "braintree", name, plan, status: :active)
+        pay_customer.subscriptions.create!(
+          name: name,
+          processor_id: result.subscription.id,
+          processor_plan: plan,
+          status: :active,
+          trial_ends_at: trial_end_date(result.subscription),
+          ends_at: nil,
+          metadata: metadata
+        )
       rescue ::Braintree::AuthorizationError => e
         raise Pay::Braintree::AuthorizationError, e
       rescue ::Braintree::BraintreeError => e
         raise Pay::Braintree::Error, e
       end
 
-      # Handles Billable#update_card
-      #
-      # Returns true if successful
-      def update_card(token)
+      def add_payment_method(token, default: false)
         customer unless processor_id?
 
         result = gateway.payment_method.create(
           customer_id: processor_id,
           payment_method_nonce: token,
           options: {
-            make_default: true,
+            make_default: default,
             verify_card: true
           }
         )
         raise Pay::Braintree::Error, result unless result.success?
 
-        update_card_on_file result.payment_method
-        update_subscriptions_to_payment_method(result.payment_method.token)
-        true
+        pay_payment_method = save_payment_method(result.payment_method, default: default)
+
+        # Update existing subscriptions to the new payment method
+        pay_customer.subscriptions.each do |subscription|
+          if subscription.active?
+            gateway.subscription.update(subscription.processor_id, {payment_method_token: token})
+          end
+        end
+
+        pay_payment_method
       rescue ::Braintree::AuthorizationError => e
         raise Pay::Braintree::AuthorizationError, e
       rescue ::Braintree::BraintreeError => e
@@ -127,35 +137,26 @@ module Pay
         subscription.first_billing_date.end_of_day
       end
 
-      def update_subscriptions_to_payment_method(token)
-        billable.subscriptions.braintree.each do |subscription|
-          if subscription.active?
-            gateway.subscription.update(subscription.processor_id, {payment_method_token: token})
-          end
-        end
-      end
-
       def processor_subscription(subscription_id, options = {})
         gateway.subscription.find(subscription_id)
       end
 
-      def braintree_invoice!(options = {})
-        # pass
-      end
-
-      def braintree_upcoming_invoice
-        # pass
-      end
-
       def save_transaction(transaction)
         attrs = card_details_for_braintree_transaction(transaction)
         attrs[:amount] = transaction.amount.to_f * 100
+        attrs[:metadata] = transaction.custom_fields
+        attrs[:currency] = transaction.currency_iso_code
+        attrs[:application_fee_amount] = transaction.service_fee_amount
+
+        # Associate charge with subscription if we can
+        if transaction.subscription_id
+          pay_subscription = pay_customer.subscriptions.find_by(processor_id: transaction.subscription_id)
+          attrs[:subscription] = pay_subscription
+          attrs[:metadata] = pay_subscription.metadata
+        end
 
-        charge = billable.charges.find_or_initialize_by(
-          processor: :braintree,
-          processor_id: transaction.id
-        )
-        charge.update(attrs)
+        charge = pay_customer.charges.find_or_initialize_by(processor_id: transaction.id)
+        charge.update!(attrs)
         charge
       end
 
@@ -165,74 +166,98 @@ module Pay
         Pay.braintree_gateway
       end
 
-      def update_card_on_file(payment_method)
-        case payment_method
-        when ::Braintree::CreditCard
-          billable.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
-          billable.update!(
-            card_type: "PayPal",
-            card_last4: payment_method.email
-          )
+      def save_payment_method(payment_method, default:)
+        attributes = case payment_method
+                     when ::Braintree::CreditCard, ::Braintree::ApplePayCard, ::Braintree::GooglePayCard, ::Braintree::SamsungPayCard, ::Braintree::VisaCheckoutCard
+                       {
+                         payment_method_type: :card,
+                         brand: payment_method.card_type,
+                         last4: payment_method.last_4,
+                         exp_month: payment_method.expiration_month,
+                         exp_year: payment_method.expiration_year
+                       }
+
+                     when ::Braintree::PayPalAccount
+                       {
+                         payment_method_type: :paypal,
+                         brand: "PayPal",
+                         email: payment_method.email
+                       }
+                     when ::Braintree::VenmoAccount
+                       {
+                         payment_method_type: :venmo,
+                         brand: "Venmo",
+                         username: payment_method.username
+                       }
+                     when ::Braintree::UsBankAccount
+                       {
+                         payment_method_type: "us_bank_account",
+                         bank: payment_method.bank_name,
+                         last4: payment_method.last_4
+                       }
+                     else
+                       {
+                         payment_method_type: payment_method.class.name.demodulize.underscore
+                       }
         end
 
-        # Clear the card token so we don't accidentally update twice
-        billable.card_token = nil
+        pay_payment_method = pay_customer.payment_methods.where(processor_id: payment_method.token).first_or_initialize
+
+        pay_customer.payment_methods.update_all(default: false) if default
+        pay_payment_method.update!(attributes.merge(default: default))
+
+        # Reload the Rails association
+        pay_customer.reload_default_payment_method if default
+
+        pay_payment_method
       end
 
       def card_details_for_braintree_transaction(transaction)
         case transaction.payment_instrument_type
-        when "credit_card", "samsung_pay_card", "masterpass_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 "android_pay_card", "apple_pay_card", "credit_card", "google_pay_card", "samsung_pay_card", "visa_checkout_card"
+          # Lookup the attribute with the payment method details by name
+          attribute_name = transaction.payment_instrument_type
 
-        when "paypal_account"
-          {
-            card_type: "PayPal",
-            card_last4: transaction.paypal_details.payer_email,
-            card_exp_month: nil,
-            card_exp_year: nil
-          }
+          # The attribute name for Apple and Google Pay don't include _card for some reason
+          if ["apple_pay_card", "google_pay_card"].include?(transaction.payment_instrument_type)
+            attribute_name = attribute_name.split("_card").first
+
+          # Android Pay was renamed to Google Pay, but test nonces still use android_pay_card
+          elsif attribute_name == "android_pay_card"
+            attribute_name = "google_pay"
+          end
+
+          # Retrieve payment method details from transaction
+          payment_method = transaction.send("#{attribute_name}_details")
 
-        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
+            payment_method_type: :card,
+            brand: payment_method.card_type,
+            last4: payment_method.last_4,
+            exp_month: payment_method.expiration_month,
+            exp_year: payment_method.expiration_year
           }
 
-        when "venmo_account"
+        when "paypal_account"
           {
-            card_type: "Venmo",
-            card_last4: transaction.venmo_account_details.username,
-            card_exp_month: nil,
-            card_exp_year: nil
+            payment_method_type: :paypal,
+            brand: "PayPal",
+            last4: transaction.paypal_details.payer_email,
+            exp_month: nil,
+            exp_year: nil
           }
 
-        when "apple_pay_card"
-          payment_method = transaction.apple_pay_details
+        when "venmo_account"
           {
-            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
+            payment_method_type: :venmo,
+            brand: "Venmo",
+            last4: transaction.venmo_account_details.username,
+            exp_month: nil,
+            exp_year: nil
           }
 
         else
-          {}
+          {payment_method_type: "unknown"}
         end
       end
     end