pay 2.7.1 → 3.0.2

data/app/controllers/pay/webhooks/braintree_controller.rb

@@ -6,7 +6,7 @@ module Pay
       end
 
       def create
-        delegate_event(verified_event)
+        queue_event(verified_event)
         head :ok
       rescue ::Braintree::InvalidSignature
         head :bad_request
@@ -14,8 +14,15 @@ module Pay
 
       private
 
-      def delegate_event(event)
-        Pay::Webhooks.instrument type: "braintree.#{event.kind}", event: event
+      def queue_event(event)
+        return unless Pay::Webhooks.delegator.listening?("braintree.#{event.kind}")
+
+        record = Pay::Webhook.create(
+          processor: :braintree,
+          event_type: event.kind,
+          event: {bt_signature: params[:bt_signature], bt_payload: params[:bt_payload]}
+        )
+        Pay::Webhooks::ProcessJob.perform_later(record)
       end
 
       def verified_event

data/app/controllers/pay/webhooks/paddle_controller.rb

@@ -6,7 +6,7 @@ module Pay
       end
 
       def create
-        delegate_event(verified_event)
+        queue_event(verified_event)
         head :ok
       rescue Pay::Paddle::Error
         head :bad_request
@@ -14,22 +14,21 @@ module Pay
 
       private
 
-      def delegate_event(event)
-        Pay::Webhooks.instrument type: "paddle.#{type}", event: event
-      end
+      def queue_event(event)
+        return unless Pay::Webhooks.delegator.listening?("paddle.#{params[:alert_name]}")
 
-      def type
-        params[:alert_name]
+        record = Pay::Webhook.create(processor: :paddle, event_type: params[:alert_name], event: event)
+        Pay::Webhooks::ProcessJob.perform_later(record)
       end
 
       def verified_event
-        event = check_params.as_json
+        event = verify_params.as_json
         verifier = Pay::Paddle::Webhooks::SignatureVerifier.new(event)
         return event if verifier.verify
         raise Pay::Paddle::Error, "Unable to verify Paddle webhook event"
       end
 
-      def check_params
+      def verify_params
         params.except(:action, :controller).permit!
       end
     end

data/app/controllers/pay/webhooks/stripe_controller.rb

@@ -6,7 +6,7 @@ module Pay
       end
 
       def create
-        delegate_event(verified_event)
+        queue_event(verified_event)
         head :ok
       rescue ::Stripe::SignatureVerificationError => e
         log_error(e)
@@ -15,8 +15,11 @@ module Pay
 
       private
 
-      def delegate_event(event)
-        Pay::Webhooks.instrument type: "stripe.#{event.type}", event: event
+      def queue_event(event)
+        return unless Pay::Webhooks.delegator.listening?("stripe.#{event.type}")
+
+        record = Pay::Webhook.create(processor: :stripe, event_type: event.type, event: event)
+        Pay::Webhooks::ProcessJob.perform_later(record)
       end
 
       def verified_event

data/app/jobs/pay/{email_sync_job.rb → customer_sync_job.rb}

@@ -1,10 +1,9 @@
 module Pay
-  class EmailSyncJob < ApplicationJob
+  class CustomerSyncJob < ApplicationJob
     queue_as :default
 
-    def perform(id, class_name)
-      billable = class_name.constantize.find(id)
-      billable.sync_email_with_processor
+    def perform(pay_customer_id)
+      Pay::Customer.find(pay_customer_id).update_customer!
     rescue ActiveRecord::RecordNotFound
       Rails.logger.info "Couldn't find a #{class_name} with ID = #{id}"
     end

data/app/models/pay/application_record.rb

@@ -1,10 +1,6 @@
 module Pay
   class ApplicationRecord < Pay.model_parent_class.constantize
     self.abstract_class = true
-
-    def self.json_column?(name)
-      return unless connected? && table_exists?
-      [:json, :jsonb].include?(attribute_types[name].type)
-    end
+    self.table_name_prefix = "pay_"
   end
 end

data/app/models/pay/charge.rb

@@ -1,44 +1,56 @@
 module Pay
   class Charge < Pay::ApplicationRecord
-    self.table_name = Pay.chargeable_table
-
-    # Only serialize for non-json columns
-    serialize :data unless json_column?("data")
+    self.inheritance_column = nil
 
     # Associations
-    belongs_to :owner, polymorphic: true
-    belongs_to :subscription, optional: true, class_name: "Pay::Subscription", foreign_key: :pay_subscription_id
+    belongs_to :customer
+    belongs_to :subscription, optional: true
 
     # Scopes
     scope :sorted, -> { order(created_at: :desc) }
+    scope :with_active_customer, -> { joins(:customer).merge(Customer.active) }
+    scope :with_deleted_customer, -> { joins(:customer).merge(Customer.deleted) }
     default_scope -> { sorted }
 
     # Validations
     validates :amount, presence: true
-    validates :processor, presence: true
-    validates :processor_id, presence: true
-    validates :card_type, presence: true
+    validates :processor_id, presence: true, uniqueness: {scope: :customer_id, case_sensitive: true}
 
+    # Store the payment method kind (card, paypal, etc)
     store_accessor :data, :paddle_receipt_url
     store_accessor :data, :stripe_account
 
+    # Payment method attributes
+    store_accessor :data, :payment_method_type # card, paypal, sepa, etc
+    store_accessor :data, :brand # Visa, Mastercard, Discover, PayPal
+    store_accessor :data, :last4
+    store_accessor :data, :exp_month
+    store_accessor :data, :exp_year
+    store_accessor :data, :email # PayPal email, etc
+    store_accessor :data, :username # Venmo
+    store_accessor :data, :bank
+
     # Helpers for payment processors
     %w[braintree stripe paddle fake_processor].each do |processor_name|
       define_method "#{processor_name}?" do
-        processor == processor_name
+        customer.processor == processor_name
       end
 
       scope processor_name, -> { where(processor: processor_name) }
     end
 
-    def payment_processor
-      @payment_processor ||= payment_processor_for(processor).new(self)
+    def self.find_by_processor_and_id(processor, processor_id)
+      joins(:customer).find_by(processor_id: processor_id, pay_customers: {processor: processor})
     end
 
-    def payment_processor_for(name)
+    def self.pay_processor_for(name)
       "Pay::#{name.to_s.classify}::Charge".constantize
     end
 
+    def payment_processor
+      @payment_processor ||= self.class.pay_processor_for(customer.processor).new(self)
+    end
+
     def processor_charge
       payment_processor.charge
     end
@@ -49,11 +61,36 @@ module Pay
     end
 
     def charged_to
-      "#{card_type} (**** **** **** #{card_last4})"
-    end
+      case payment_method_type
+      when "card"
+        "#{brand.titleize} (**** **** **** #{last4})"
+      when "paypal"
+        "#{brand} (#{email})"
 
-    def paypal?
-      braintree? && card_type == "PayPal"
+      # Braintree
+      when "venmo"
+        "#{brand.titleize} #{username}"
+      when "us_bank_account"
+        "#{bank} #{last4}"
+
+      # Stripe
+      when "acss_debit"
+        "#{bank} #{last4}"
+      when "eps", "fpx", "ideal", "p24"
+        bank
+
+      when "au_becs_debit"
+        "BECS Debit #{last4}"
+
+      when "bacs_debit"
+        "Bacs Debit #{last4}"
+
+      when "sepa_debit"
+        "SEPA Debit #{last4}"
+
+      else
+        payment_method_type&.titleize
+      end
     end
   end
 end

data/app/models/pay/customer.rb

@@ -0,0 +1,87 @@
+module Pay
+  class Customer < Pay::ApplicationRecord
+    belongs_to :owner, polymorphic: true
+    has_many :charges, dependent: :destroy
+    has_many :subscriptions, dependent: :destroy
+    has_many :payment_methods, dependent: :destroy
+    has_one :default_payment_method, -> { where(default: true) }, class_name: "Pay::PaymentMethod"
+
+    scope :active, -> { where(deleted_at: nil) }
+    scope :deleted, -> { where.not(deleted_at: nil) }
+
+    validates :processor, presence: true
+    validates :processor_id, allow_blank: true, uniqueness: {scope: :processor, case_sensitive: true}
+
+    attribute :plan, :string
+    attribute :quantity, :integer
+    attribute :payment_method_token, :string
+
+    # Account(s) for marketplace payments
+    store_accessor :data, :stripe_account
+    store_accessor :data, :braintree_account
+
+    delegate :email, to: :owner
+    delegate_missing_to :pay_processor
+
+    def self.processor_for(name)
+      "Pay::#{name.to_s.classify}::Billable".constantize
+    end
+
+    def pay_processor
+      @pay_processor ||= self.class.processor_for(processor).new(self)
+    end
+
+    def update_payment_method(payment_method_id)
+      add_payment_method(payment_method_id, default: true)
+    end
+
+    def subscription(name: Pay.default_product_name)
+      subscriptions.loaded? ? subscriptions.reverse.detect { |s| s.name == name } : subscriptions.for_name(name).last
+    end
+
+    def subscribed?(name: Pay.default_product_name, processor_plan: nil)
+      subscription = subscription(name: name)
+
+      return false if subscription.nil?
+      return subscription.active? if processor_plan.nil?
+
+      subscription.active? && subscription.processor_plan == processor_plan
+    end
+
+    def on_trial?(name: Pay.default_product_name, plan: nil)
+      sub = subscription(name: name)
+      return sub&.on_trial? if plan.nil?
+
+      sub&.on_trial? && sub.processor_plan == plan
+    end
+
+    def on_trial_or_subscribed?(name: Pay.default_product_name, processor_plan: nil)
+      on_trial?(name: name, plan: processor_plan) ||
+        subscribed?(name: name, processor_plan: processor_plan)
+    end
+
+    def has_incomplete_payment?
+      subscriptions.active.incomplete.any?
+    end
+
+    def customer_name
+      [owner.try(:first_name), owner.try(:last_name)].compact.join(" ")
+    end
+
+    def active?
+      deleted_at.nil?
+    end
+
+    def deleted?
+      deleted_at.present?
+    end
+
+    %w[stripe braintree paddle fake_processor].each do |processor_name|
+      scope processor_name, -> { where(processor: processor_name) }
+
+      define_method "#{processor_name}?" do
+        processor == processor_name
+      end
+    end
+  end
+end

data/app/models/pay/merchant.rb

@@ -0,0 +1,19 @@
+module Pay
+  class Merchant < Pay::ApplicationRecord
+    belongs_to :owner, polymorphic: true
+
+    validates :processor, presence: true
+
+    store_accessor :data, :onboarding_complete
+
+    delegate_missing_to :pay_processor
+
+    def self.processor_for(name)
+      "Pay::#{name.to_s.classify}::Merchant".constantize
+    end
+
+    def pay_processor
+      @pay_processor ||= self.class.processor_for(processor).new(self)
+    end
+  end
+end

data/app/models/pay/payment_method.rb

@@ -0,0 +1,41 @@
+module Pay
+  class PaymentMethod < Pay::ApplicationRecord
+    self.inheritance_column = nil
+
+    belongs_to :customer
+
+    store_accessor :data, :brand # Visa, Mastercard, Discover, PayPal
+    store_accessor :data, :last4
+    store_accessor :data, :exp_month
+    store_accessor :data, :exp_year
+    store_accessor :data, :email # PayPal email, etc
+    store_accessor :data, :username
+    store_accessor :data, :bank
+
+    # Aliases to share PaymentMethodAttributes
+    alias_attribute :payment_method_type, :type
+
+    validates :processor_id, presence: true, uniqueness: {scope: :customer_id, case_sensitive: true}
+
+    def self.find_by_processor_and_id(processor, processor_id)
+      joins(:customer).find_by(processor_id: processor_id, pay_customers: {processor: processor})
+    end
+
+    def self.pay_processor_for(name)
+      "Pay::#{name.to_s.classify}::PaymentMethod".constantize
+    end
+
+    def payment_processor
+      @payment_processor ||= self.class.pay_processor_for(customer.processor).new(self)
+    end
+
+    def make_default!
+      return if default?
+
+      payment_processor.make_default!
+
+      customer.payment_methods.update_all(default: false)
+      update!(default: true)
+    end
+  end
+end

data/app/models/pay/subscription.rb

@@ -1,24 +1,11 @@
 module Pay
   class Subscription < Pay::ApplicationRecord
-    self.table_name = Pay.subscription_table
-
     STATUSES = %w[incomplete incomplete_expired trialing active past_due canceled unpaid paused]
 
-    # Only serialize for non-json columns
-    serialize :data unless json_column?("data")
-
     # Associations
-    belongs_to :owner, polymorphic: true
+    belongs_to :customer
     has_many :charges, class_name: "Pay::Charge", foreign_key: :pay_subscription_id
 
-    # Validations
-    validates :name, presence: true
-    validates :processor, presence: true
-    validates :processor_id, presence: true
-    validates :processor_plan, presence: true
-    validates :quantity, presence: true
-    validates :status, presence: true
-
     # Scopes
     scope :for_name, ->(name) { where(name: name) }
     scope :on_trial, -> { where.not(trial_ends_at: nil).where("#{table_name}.trial_ends_at > ?", Time.zone.now) }
@@ -27,8 +14,12 @@ module Pay
     scope :active, -> { where(ends_at: nil).or(on_grace_period).or(on_trial) }
     scope :incomplete, -> { where(status: :incomplete) }
     scope :past_due, -> { where(status: :past_due) }
+    scope :with_active_customer, -> { joins(:customer).merge(Customer.active) }
+    scope :with_deleted_customer, -> { joins(:customer).merge(Customer.deleted) }
+
+    # Callbacks
+    before_destroy :cancel_if_active
 
-    # TODO: Include these with a module
     store_accessor :data, :paddle_update_url
     store_accessor :data, :paddle_cancel_url
     store_accessor :data, :paddle_paused_from
@@ -36,29 +27,40 @@ module Pay
 
     attribute :prorate, :boolean, default: true
 
-    # Helpers for payment processors
+    # Validations
+    validates :name, presence: true
+    validates :processor_id, presence: true, uniqueness: {scope: :customer_id, case_sensitive: true}
+    validates :processor_plan, presence: true
+    validates :quantity, presence: true, numericality: {only_integer: true, greater_than_or_equal_to: 1}
+    validates :status, presence: true
+
+    delegate :on_grace_period?,
+      :paused?,
+      :pause,
+      :cancel,
+      :cancel_now!,
+      to: :payment_processor
+
+    # Helper methods for payment processors
     %w[braintree stripe paddle fake_processor].each do |processor_name|
       define_method "#{processor_name}?" do
-        processor == processor_name
+        customer.processor == processor_name
       end
 
-      scope processor_name, -> { where(processor: processor_name) }
+      scope processor_name, -> { joins(:customer).where(pay_customers: {processor: processor_name}) }
     end
 
-    def payment_processor
-      @payment_processor ||= payment_processor_for(processor).new(self)
+    def self.find_by_processor_and_id(processor, processor_id)
+      joins(:customer).find_by(processor_id: processor_id, pay_customers: {processor: processor})
     end
 
-    def payment_processor_for(name)
+    def self.pay_processor_for(name)
       "Pay::#{name.to_s.classify}::Subscription".constantize
     end
 
-    delegate :on_grace_period?,
-      :paused?,
-      :pause,
-      :cancel,
-      :cancel_now!,
-      to: :payment_processor
+    def payment_processor
+      @payment_processor ||= self.class.pay_processor_for(customer.processor).new(self)
+    end
 
     def no_prorate
       self.prorate = false
@@ -103,13 +105,14 @@ module Pay
 
     def resume
       payment_processor.resume
-      update(ends_at: nil, status: "active")
+      update(ends_at: nil, status: :active)
       self
     end
 
     def swap(plan)
+      raise ArgumentError, "plan must be a string. Got `#{plan.inspect}` instead." unless plan.is_a?(String)
       payment_processor.swap(plan)
-      update(processor_plan: plan, ends_at: nil)
+      update(processor_plan: plan, ends_at: nil, status: :active)
     end
 
     def swap_and_invoice(plan)
@@ -122,8 +125,17 @@ module Pay
     end
 
     def latest_payment
-      return unless stripe?
       processor_subscription(expand: ["latest_invoice.payment_intent"]).latest_invoice.payment_intent
     end
+
+    private
+
+    def cancel_if_active
+      if active?
+        cancel_now!
+      end
+    rescue => e
+      Rails.logger.info "[Pay] Unable to automatically cancel subscription `#{processor} #{id}`: #{e.message}"
+    end
   end
 end