pay 7.3.0 → 11.2.2

data/{lib → app/models}/pay/stripe/payment_method.rb

@@ -1,14 +1,6 @@
 module Pay
   module Stripe
-    class PaymentMethod
-      attr_reader :pay_payment_method
-
-      delegate :customer, :processor_id, to: :pay_payment_method
-
-      def initialize(pay_payment_method)
-        @pay_payment_method = pay_payment_method
-      end
-
+    class PaymentMethod < Pay::PaymentMethod
       # Syncs a PaymentIntent's payment method to the database
       def self.sync_payment_intent(id, stripe_account: nil)
         payment_intent = ::Stripe::PaymentIntent.retrieve({id: id, expand: ["payment_method"]}, {stripe_account: stripe_account}.compact)
@@ -39,22 +31,22 @@ module Pay
           return
         end
 
-        default_payment_method_id = pay_customer.customer.invoice_settings.default_payment_method
+        default_payment_method_id = pay_customer.api_record.invoice_settings.default_payment_method
         default = (id == default_payment_method_id)
 
         attributes = extract_attributes(object).merge(default: default, stripe_account: stripe_account)
 
-        pay_customer.payment_methods.update_all(default: false) if default
-        pay_payment_method = pay_customer.payment_methods.where(processor_id: object.id).first_or_initialize
+        where(customer: pay_customer).update_all(default: false) if default
+        pay_payment_method = where(customer: pay_customer, processor_id: object.id).first_or_initialize
         pay_payment_method.update!(attributes)
         pay_payment_method
       rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique
-        try += 1
-        if try <= retries
-          sleep 0.1
-          retry
-        else
+        if try > retries
           raise
+        else
+          try += 1
+          sleep 0.15**try
+          retry
         end
       end
 
@@ -92,3 +84,5 @@ module Pay
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_stripe_payment_method, Pay::Stripe::PaymentMethod

data/{lib → app/models}/pay/stripe/subscription.rb

@@ -1,33 +1,7 @@
 module Pay
   module Stripe
-    class Subscription
-      attr_accessor :stripe_subscription
-      attr_reader :pay_subscription
-
-      delegate :active?,
-        :canceled?,
-        :ends_at?,
-        :ends_at,
-        :name,
-        :on_trial?,
-        :past_due?,
-        :pause_starts_at,
-        :pause_starts_at?,
-        :processor_id,
-        :processor_plan,
-        :processor_subscription,
-        :prorate,
-        :prorate?,
-        :quantity,
-        :quantity?,
-        :stripe_account,
-        :subscription_items,
-        :trial_ends_at,
-        :pause_behavior,
-        :pause_resumes_at,
-        :current_period_start,
-        :current_period_end,
-        to: :pay_subscription
+    class Subscription < Pay::Subscription
+      attr_writer :api_record
 
       def self.sync_from_checkout_session(session_id, stripe_account: nil)
         checkout_session = ::Stripe::Checkout::Session.retrieve({id: session_id}, {stripe_account: stripe_account}.compact)
@@ -49,6 +23,7 @@ module Pay
         end
 
         attributes = {
+          object: object.to_hash,
           application_fee_percent: object.application_fee_percent,
           created_at: Time.at(object.created),
           processor_plan: object.items.first.price.id,
@@ -56,12 +31,11 @@ module Pay
           status: object.status,
           stripe_account: pay_customer.stripe_account,
           metadata: object.metadata,
-          subscription_items: [],
           metered: false,
           pause_behavior: object.pause_collection&.behavior,
           pause_resumes_at: (object.pause_collection&.resumes_at ? Time.at(object.pause_collection&.resumes_at) : nil),
-          current_period_start: (object.current_period_start ? Time.at(object.current_period_start) : nil),
-          current_period_end: (object.current_period_end ? Time.at(object.current_period_end) : nil)
+          current_period_start: (object.items.first.current_period_start ? Time.at(object.items.first.current_period_start) : nil),
+          current_period_end: (object.items.first.current_period_end ? Time.at(object.items.first.current_period_end) : nil)
         }
 
         # Subscriptions that have ended should have their trial ended at the
@@ -73,15 +47,13 @@ module Pay
         if object.trial_end
           trial_ended_at = [object.ended_at, object.trial_end].compact.min
           attributes[:trial_ends_at] = Time.at(trial_ended_at)
+        else
+          attributes[:trial_ends_at] = nil
         end
 
-        # Record subscription items to db
         object.items.auto_paging_each do |subscription_item|
-          if !attributes[:metered] && (subscription_item.to_hash.dig(:price, :recurring, :usage_type) == "metered")
-            attributes[:metered] = true
-          end
-
-          attributes[:subscription_items] << subscription_item.to_hash.slice(:id, :price, :metadata, :quantity)
+          next if attributes[:metered]
+          attributes[:metered] = true if subscription_item.price.try(:recurring).try(:usage_type) == "metered"
         end
 
         attributes[:ends_at] = if object.ended_at
@@ -92,7 +64,7 @@ module Pay
           Time.at(object.cancel_at)
         elsif object.cancel_at_period_end
           # Subscriptions cancelling in the future
-          Time.at(object.current_period_end)
+          Time.at(object.items.first.current_period_end)
         end
 
         # Sync payment method if directly attached to subscription
@@ -107,13 +79,13 @@ module Pay
         end
 
         # Update or create the subscription
-        pay_subscription = pay_customer.subscriptions.find_by(processor_id: object.id)
+        pay_subscription = find_by(customer: pay_customer, processor_id: object.id)
         if pay_subscription
           # If pause behavior is changing to `void`, record the pause start date
           # Any other pause status (or no pause at all) should have nil for start
           if pay_subscription.pause_behavior != attributes[:pause_behavior]
             attributes[:pause_starts_at] = if attributes[:pause_behavior] == "void"
-              Time.at(object.current_period_end)
+              Time.at(object.items.first.current_period_end)
             end
           end
 
@@ -121,15 +93,24 @@ module Pay
         else
           # Allow setting the subscription name in metadata, otherwise use the default
           name ||= object.metadata["pay_name"] || Pay.default_product_name
-          pay_subscription = pay_customer.subscriptions.create!(attributes.merge(name: name, processor_id: object.id))
+          pay_subscription = create!(attributes.merge(customer: pay_customer, name: name, processor_id: object.id))
         end
 
         # Cache the Stripe subscription on the Pay::Subscription that we return
-        pay_subscription.stripe_subscription = object
+        pay_subscription.api_record = object
 
         # Sync the latest charge if we already have it loaded (like during subscrbe), otherwise, let webhooks take care of creating it
-        if (charge = object.try(:latest_invoice).try(:charge)) && charge.try(:status) == "succeeded"
-          Pay::Stripe::Charge.sync(charge.id, stripe_account: pay_subscription.stripe_account)
+        if (invoice = object.try(:latest_invoice))
+          Array(invoice.try(:payments)).each do |invoice_payment|
+            next unless invoice_payment.status == "paid"
+
+            case invoice_payment.payment.type
+            when "payment_intent"
+              Pay::Stripe::Charge.sync_payment_intent(invoice_payment.payment.payment_intent, stripe_account: pay_subscription.stripe_account)
+            when "charge"
+              Pay::Stripe::Charge.sync(invoice_payment.payment.charge, stripe_account: pay_subscription.stripe_account)
+            end
+          end
         end
 
         pay_subscription
@@ -148,39 +129,34 @@ module Pay
         {
           expand: [
             "default_payment_method",
-            "pending_setup_intent",
-            "latest_invoice.payment_intent",
-            "latest_invoice.charge",
+            "discounts",
+            "latest_invoice.confirmation_secret",
+            "latest_invoice.payments",
             "latest_invoice.total_discount_amounts.discount",
-            "latest_invoice.total_tax_amounts.tax_rate"
+            "pending_setup_intent",
+            "schedule"
           ]
         }
       end
 
-      def initialize(pay_subscription)
-        @pay_subscription = pay_subscription
-      end
-
-      def subscription(**options)
-        options[:id] = processor_id
-        @stripe_subscription ||= ::Stripe::Subscription.retrieve(options.merge(expand_options), {stripe_account: stripe_account}.compact)
+      def stripe_object
+        ::Stripe::Subscription.construct_from(object)
       end
 
-      def reload!
-        @stripe_subscription = nil
+      def api_record(**options)
+        @api_record ||= ::Stripe::Subscription.retrieve(options.with_defaults(id: processor_id).merge(expand_options), {stripe_account: stripe_account}.compact)
       end
 
       # Returns a SetupIntent or PaymentIntent client secret for the subscription
       def client_secret
-        stripe_sub = subscription
-        stripe_sub&.pending_setup_intent&.client_secret || stripe_sub&.latest_invoice&.payment_intent&.client_secret
+        api_record&.pending_setup_intent&.client_secret || api_record&.latest_invoice&.confirmation_secret&.client_secret
       end
 
       # Sets the default_payment_method on a subscription
       # Pass an empty string to unset
       def update_payment_method(id)
-        @stripe_subscription = ::Stripe::Subscription.update(processor_id, {default_payment_method: id}.merge(expand_options), stripe_options)
-        pay_subscription.update(payment_method_id: @stripe_subscription.default_payment_method&.id)
+        @api_record = ::Stripe::Subscription.update(processor_id, {default_payment_method: id}.merge(expand_options), stripe_options)
+        update(payment_method_id: @api_record.default_payment_method&.id)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -195,8 +171,8 @@ module Pay
         if past_due? && options.fetch(:past_due_cancel_now, true)
           cancel_now!
         else
-          @stripe_subscription = ::Stripe::Subscription.update(processor_id, {cancel_at_period_end: true}.merge(expand_options), stripe_options)
-          pay_subscription.update(ends_at: (on_trial? ? trial_ends_at : Time.at(@stripe_subscription.current_period_end)))
+          @api_record = ::Stripe::Subscription.update(processor_id, {cancel_at_period_end: true}.merge(expand_options), stripe_options)
+          update(ends_at: Time.at(@api_record.cancel_at))
         end
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
@@ -209,8 +185,12 @@ module Pay
       def cancel_now!(**options)
         return if canceled? && ends_at.past?
 
-        @stripe_subscription = ::Stripe::Subscription.cancel(processor_id, options.merge(expand_options), stripe_options)
-        pay_subscription.update(ends_at: Time.current, status: :canceled)
+        @api_record = ::Stripe::Subscription.cancel(processor_id, options.merge(expand_options), stripe_options)
+        update(
+          trial_ends_at: (@api_record.trial_end ? Time.at(@api_record.trial_end) : nil),
+          ends_at: Time.at(@api_record.ended_at),
+          status: @api_record.status
+        )
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -220,14 +200,14 @@ module Pay
       # For a subscription with a single item, we can update the subscription directly if no SubscriptionItem ID is available
       # Otherwise a SubscriptionItem ID is required so Stripe knows which entry to update
       def change_quantity(quantity, **options)
-        subscription_item_id = options.delete(:subscription_item_id) || subscription_items&.first&.dig("id")
+        subscription_item_id = options.delete(:subscription_item_id) || subscription_items&.first&.id
         if subscription_item_id
           ::Stripe::SubscriptionItem.update(subscription_item_id, options.merge(quantity: quantity), stripe_options)
-          @stripe_subscription = nil
+          @api_record = nil
         else
-          @stripe_subscription = ::Stripe::Subscription.update(processor_id, options.merge(quantity: quantity).merge(expand_options), stripe_options)
+          @api_record = ::Stripe::Subscription.update(processor_id, options.merge(quantity: quantity).merge(expand_options), stripe_options)
         end
-        true
+        update(quantity: quantity)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -265,12 +245,12 @@ module Pay
       # https://docs.stripe.com/billing/subscriptions/pause-payment
       def pause(**options)
         attributes = {pause_collection: options.reverse_merge(behavior: "void")}
-        @stripe_subscription = ::Stripe::Subscription.update(processor_id, attributes.merge(expand_options), stripe_options)
-        behavior = @stripe_subscription.pause_collection&.behavior
-        pay_subscription.update(
+        @api_record = ::Stripe::Subscription.update(processor_id, attributes.merge(expand_options), stripe_options)
+        behavior = @api_record.pause_collection&.behavior
+        update(
           pause_behavior: behavior,
-          pause_resumes_at: (@stripe_subscription.pause_collection&.resumes_at ? Time.at(@stripe_subscription.pause_collection&.resumes_at) : nil),
-          pause_starts_at: ((behavior == "void") ? Time.at(@stripe_subscription.current_period_end) : nil)
+          pause_resumes_at: (@api_record.pause_collection&.resumes_at ? Time.at(@api_record.pause_collection&.resumes_at) : nil),
+          pause_starts_at: ((behavior == "void") ? Time.at(@api_record.items.first.current_period_end) : nil)
         )
       end
 
@@ -278,8 +258,8 @@ module Pay
       #
       # https://docs.stripe.com/billing/subscriptions/pause-payment#unpausing
       def unpause
-        @stripe_subscription = ::Stripe::Subscription.update(processor_id, {pause_collection: ""}.merge(expand_options), stripe_options)
-        pay_subscription.update(
+        @api_record = ::Stripe::Subscription.update(processor_id, {pause_collection: ""}.merge(expand_options), stripe_options)
+        update(
           pause_behavior: nil,
           pause_resumes_at: nil,
           pause_starts_at: nil
@@ -292,22 +272,20 @@ module Pay
 
       def resume
         unless resumable?
-          raise StandardError, "You can only resume subscriptions within their grace period."
+          raise Error, "You can only resume subscriptions within their grace period."
         end
 
         if paused?
           unpause
         else
-          @stripe_subscription = ::Stripe::Subscription.update(
-            processor_id,
-            {
-              plan: processor_plan,
-              trial_end: (on_trial? ? trial_ends_at.to_i : "now"),
-              cancel_at_period_end: false
-            }.merge(expand_options),
-            stripe_options
-          )
+          @api_record = ::Stripe::Subscription.update(processor_id, {
+            plan: processor_plan,
+            trial_end: (on_trial? ? trial_ends_at.to_i : "now"),
+            cancel_at_period_end: false
+          }.merge(expand_options),
+            stripe_options)
         end
+        update(ends_at: nil, status: :active)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -315,9 +293,10 @@ module Pay
       def swap(plan, **options)
         raise ArgumentError, "plan must be a string" unless plan.is_a?(String)
 
+        prorate = options.fetch(:prorate) { true }
         proration_behavior = options.delete(:proration_behavior) || (prorate ? "always_invoice" : "none")
 
-        @stripe_subscription = ::Stripe::Subscription.update(
+        @api_record = ::Stripe::Subscription.update(
           processor_id,
           {
             cancel_at_period_end: false,
@@ -330,51 +309,37 @@ module Pay
         )
 
         # Validate that swap was successful and handle SCA if needed
-        if (payment_intent = @stripe_subscription.latest_invoice.payment_intent)
-          Pay::Payment.new(payment_intent).validate
+        if (payment_intent_id = @api_record.latest_invoice.payments.first&.payment&.payment_intent)
+          Pay::Payment.from_id(payment_intent_id).validate
         end
 
-        pay_subscription.sync!(object: @stripe_subscription)
+        sync!(object: @api_record)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
-      # Creates a metered billing usage record
-      #
-      # Uses the first subscription_item ID unless `subscription_item_id: "si_1234"` is passed
-      #
-      # create_usage_record(quantity: 4, action: :increment)
-      # create_usage_record(subscription_item_id: "si_1234", quantity: 100, action: :set)
-      def create_usage_record(**options)
-        subscription_item_id = options.delete(:subscription_item_id) || metered_subscription_item&.dig("id")
-        ::Stripe::SubscriptionItem.create_usage_record(subscription_item_id, options, stripe_options)
-      end
-
-      # Returns usage record summaries for a subscription item
-      def usage_record_summaries(**options)
-        subscription_item_id = options.delete(:subscription_item_id) || metered_subscription_item&.dig("id")
-        ::Stripe::SubscriptionItem.list_usage_record_summaries(subscription_item_id, options, stripe_options)
+      def subscription_items
+        stripe_object.items
       end
 
       # Returns the first metered subscription item
       def metered_subscription_item
-        subscription_items.find do |subscription_item|
-          subscription_item.dig("price", "recurring", "usage_type") == "metered"
+        subscription_items.auto_paging_each do |subscription_item|
+          return subscription_item if subscription_item.price.try(:recurring).try(:usage_type) == "metered"
         end
       end
 
-      # Returns an upcoming invoice for a subscription
-      def upcoming_invoice(**options)
-        ::Stripe::Invoice.upcoming(options.merge(subscription: processor_id), stripe_options)
+      def preview_invoice(**options)
+        ::Stripe::Invoice.create_preview(options.merge(subscription: processor_id), stripe_options)
       end
 
       # Retries the latest invoice for a Past Due subscription and attempts to pay it
       def retry_failed_payment(payment_intent_id: nil)
-        payment_intent_id ||= subscription.latest_invoice.payment_intent.id
+        payment_intent_id ||= api_record.latest_invoice.payment_intent.id
         payment_intent = ::Stripe::PaymentIntent.retrieve({id: payment_intent_id}, stripe_options)
 
         payment_intent = if payment_intent.status == "requires_payment_method"
-          ::Stripe::PaymentIntent.confirm(payment_intent_id, {payment_method: pay_subscription.customer.default_payment_method.processor_id}, stripe_options)
+          ::Stripe::PaymentIntent.confirm(payment_intent_id, {payment_method: customer.default_payment_method.processor_id}, stripe_options)
         else
           ::Stripe::PaymentIntent.confirm(payment_intent_id, stripe_options)
         end
@@ -390,6 +355,10 @@ module Pay
         end
       end
 
+      def latest_payment
+        api_record(expand: ["latest_invoice.payment_intent"]).latest_invoice.payment_intent
+      end
+
       private
 
       # Options for Stripe requests
@@ -403,3 +372,5 @@ module Pay
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_stripe_subscription, Pay::Stripe::Subscription

data/app/models/pay/subscription.rb

@@ -9,7 +9,7 @@ module Pay
 
     # Scopes
     scope :for_name, ->(name) { where(name: name) }
-    scope :on_trial, -> { where(status: ["trialing", "active"]).where("trial_ends_at > ?", Time.current) }
+    scope :on_trial, -> { where(status: ["on_trial", "trialing", "active"]).where("trial_ends_at > ?", Time.current) }
     scope :canceled, -> { where.not(ends_at: nil) }
     scope :cancelled, -> { canceled }
     scope :on_grace_period, -> { where("#{table_name}.ends_at IS NOT NULL AND #{table_name}.ends_at > ?", Time.current) }
@@ -27,12 +27,6 @@ module Pay
     # Callbacks
     before_destroy :cancel_if_active
 
-    store_accessor :data, :paddle_update_url
-    store_accessor :data, :paddle_cancel_url
-    store_accessor :data, :subscription_items
-
-    attribute :prorate, :boolean, default: true
-
     # Validations
     validates :name, presence: true
     validates :processor_id, presence: true, uniqueness: {scope: :customer_id, case_sensitive: true}
@@ -40,10 +34,8 @@ module Pay
     validates :quantity, presence: true, numericality: {only_integer: true, greater_than_or_equal_to: 0}
     validates :status, presence: true
 
-    delegate_missing_to :payment_processor
-
     # Helper methods for payment processors
-    %w[braintree stripe paddle_billing paddle_classic fake_processor].each do |processor_name|
+    %w[braintree stripe paddle_billing paddle_classic lemon_squeezy fake_processor].each do |processor_name|
       define_method :"#{processor_name}?" do
         customer.processor == processor_name
       end
@@ -51,27 +43,17 @@ module Pay
       scope processor_name, -> { joins(:customer).where(pay_customers: {processor: processor_name}) }
     end
 
+    delegate :owner, to: :customer
+
     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}::Subscription".constantize
-    end
-
-    def payment_processor
-      @payment_processor ||= self.class.pay_processor_for(customer.processor).new(self)
-    end
-
     def sync!(**options)
-      self.class.pay_processor_for(customer.processor).sync(processor_id, **options)
+      self.class.sync(processor_id, **options)
       reload
     end
 
-    def no_prorate
-      self.prorate = false
-    end
-
     def skip_trial
       self.trial_ends_at = nil
     end
@@ -86,10 +68,12 @@ module Pay
 
     # Does not include the last second of the trial
     def on_trial?
+      return false if ended?
       trial_ends_at? && trial_ends_at > Time.current
     end
 
     def trial_ended?
+      return true if ended?
       trial_ends_at? && trial_ends_at <= Time.current
     end
 
@@ -105,6 +89,10 @@ module Pay
       ends_at? && ends_at <= Time.current
     end
 
+    def on_grace_period?
+      ends_at? && ends_at > Time.current
+    end
+
     # If you cancel during a trial, you should still retain access until the end of the trial
     # Otherwise a subscription is active unless it has ended or is currently paused
     # Check the subscription status so we don't accidentally consider "incomplete", "unpaid", or other statuses as active
@@ -129,35 +117,11 @@ module Pay
       past_due? || incomplete?
     end
 
-    def change_quantity(quantity, **options)
-      payment_processor.change_quantity(quantity, **options)
-      update(quantity: quantity)
-    end
-
-    def resume
-      payment_processor.resume
-      update(ends_at: nil, status: :active)
-      self
-    end
-
-    def swap(plan, **options)
-      raise ArgumentError, "plan must be a string. Got `#{plan.inspect}` instead." unless plan.is_a?(String)
-      payment_processor.swap(plan, **options)
-    end
-
     def swap_and_invoice(plan)
       swap(plan)
       customer.invoice!(subscription: processor_id)
     end
 
-    def processor_subscription(**options)
-      payment_processor.subscription(**options)
-    end
-
-    def latest_payment
-      processor_subscription(expand: ["latest_invoice.payment_intent"]).latest_invoice.payment_intent
-    end
-
     private
 
     def cancel_if_active
@@ -167,3 +131,5 @@ module Pay
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_subscription, Pay::Subscription

data/app/models/pay/webhook.rb

@@ -21,6 +21,8 @@ module Pay
         to_recursive_ostruct(event["data"])
       when "paddle_classic"
         to_recursive_ostruct(event)
+      when "lemon_squeezy"
+        Pay::LemonSqueezy.construct_from_webhook_event(event)
       when "stripe"
         ::Stripe::Event.construct_from(event)
       else
@@ -30,7 +32,7 @@ module Pay
 
     def to_recursive_ostruct(obj)
       if obj.is_a?(Hash)
-        OpenStruct.new(obj.map { |key, val| [key, to_recursive_ostruct(val)] }.to_h)
+        ActiveSupport::InheritableOptions.new(obj.map { |key, val| [key.to_sym, to_recursive_ostruct(val)] }.to_h)
       elsif obj.is_a?(Array)
         obj.map { |o| to_recursive_ostruct(o) }
       else # Assumed to be a primitive value
@@ -39,3 +41,5 @@ module Pay
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_webhook, Pay::Webhook

data/app/views/pay/user_mailer/payment_action_required.text.erb

@@ -0,0 +1,9 @@
+Extra confirmation is needed to process your payment
+
+Your <%= Pay.application_name %> subscription requires confirmation to process your payment to continue access.
+
+Confirm your payment: <%= pay.payment_url(params[:payment_intent_id]) %>
+
+If you have any questions, please hit reply and let us know.
+
+— The <%= Pay.application_name %> Team

data/app/views/pay/user_mailer/payment_failed.text.erb

@@ -0,0 +1,9 @@
+Your payment was declined
+
+We were unable to charge your payment method for your <%= Pay.application_name %> subscription. Please update your billing information.
+
+Update billing information: <%= root_url %>
+
+Let us know if you have any questions.
+
+— The <%= Pay.application_name %> Team

data/app/views/pay/user_mailer/receipt.text.erb

@@ -0,0 +1,20 @@
+We received payment for your <%= Pay.application_name %> subscription. Thanks for your business!
+
+Questions? Please reply to this email.
+
+------------------------------------
+RECEIPT - SUBSCRIPTION
+
+<%= Pay.application_name %>
+Amount: <%= params[:pay_charge].amount_with_currency %>
+
+Charged to: <%= params[:pay_charge].charged_to %>
+Transaction ID: <%= params[:pay_charge].id %>
+Date: <%= l params[:pay_charge].created_at %>
+<% if params[:pay_charge].customer.owner.try(:extra_billing_info?) %>
+<%= params[:pay_charge].customer.owner.extra_billing_info %>
+<% end %>
+
+<%= Pay.business_name %>
+<%= Pay.business_address %>
+------------------------------------

data/app/views/pay/user_mailer/refund.text.erb

@@ -0,0 +1,21 @@
+We have processed your <%= Pay.application_name %> refund.
+Please allow up to 7 business days for your refund to appear in your account
+
+Questions? Please reply to this email.
+
+------------------------------------
+RECEIPT - REFUND
+
+<%= Pay.application_name %>
+Amount: <%= params[:pay_charge].amount_refunded_with_currency %>
+
+Refunded to: <%= params[:pay_charge].charged_to %>
+Transaction ID: <%= params[:pay_charge].id %>
+Date: <%= l params[:pay_charge].created_at %>
+<% if params[:pay_charge].customer.owner.try(:extra_billing_info?) %>
+<%= params[:pay_charge].customer.owner.extra_billing_info %>
+<% end %>
+
+<%= Pay.business_name %>
+<%= Pay.business_address %>
+------------------------------------

data/app/views/pay/user_mailer/subscription_renewing.text.erb

@@ -0,0 +1,8 @@
+Your upcoming <%= Pay.application_name %> subscription renewal
+
+This is a friendly reminder that your <%= Pay.application_name %> subscription will renew automatically on <%= l params[:date].to_date, format: :long %>.
+
+You may manage your subscription via your account: <%= root_url %>
+If you have any questions, please hit reply and let us know.
+
+— The <%= Pay.application_name %> Team

data/app/views/pay/user_mailer/subscription_trial_ended.text.erb

@@ -0,0 +1,8 @@
+Your <%= Pay.application_name %> trial has ended
+
+This is just a friendly reminder that your <%= Pay.application_name %> trial has ended.
+
+You may manage your subscription via your account: <%= root_url %>
+If you have any questions, please hit reply and let us know.
+
+— The <%= Pay.application_name %> Team