pay 3.0.22 → 4.0.0

data/lib/pay/braintree/webhooks/subscription_trial_ended.rb

@@ -11,7 +11,7 @@ module Pay
           pay_subscription = Pay::Subscription.find_by_processor_and_id(:braintree, subscription.id)
           return unless pay_subscription.present?
 
-          pay_subscription.update(trial_ends_at: Time.current)
+          pay_subscription.update!(trial_ends_at: Time.current)
         end
       end
     end

data/lib/pay/braintree.rb

@@ -19,6 +19,12 @@ module Pay
 
     extend Env
 
+    def self.enabled?
+      return false unless Pay.enabled_processors.include?(:braintree) && defined?(::Braintree)
+
+      Pay::Engine.version_matches?(required: "~> 4", current: ::Braintree::Version::String) || (raise "[Pay] braintree gem must be version ~> 4")
+    end
+
     def self.setup
       Pay.braintree_gateway = ::Braintree::Gateway.new(
         environment: environment.to_sym,
@@ -26,8 +32,6 @@ module Pay
         public_key: public_key,
         private_key: private_key
       )
-
-      configure_webhooks
     end
 
     def self.public_key

data/lib/pay/currency.rb

@@ -23,9 +23,9 @@ module Pay
 
     def format_amount(amount, **options)
       number_to_currency(
-        amount.to_i / subunit_to_unit.to_f,
+        amount.to_f / subunit_to_unit.to_f,
         {
-          precision: precision,
+          precision: precision + additional_precision(amount),
           unit: unit,
           separator: separator,
           delimiter: delimiter,
@@ -43,6 +43,12 @@ module Pay
       subunit_to_unit.digits.count - 1
     end
 
+    # If amount is 0.8, we want to display $0.008
+    def additional_precision(amount)
+      _, decimals = amount.to_s.split(".")
+      decimals&.length || 0
+    end
+
     def unit
       attributes["unit"]
     end

data/lib/pay/engine.rb

@@ -17,12 +17,30 @@ module Pay
       end
     end
 
+    initializer "pay.webhooks" do
+      Pay::Stripe.configure_webhooks if Pay::Stripe.enabled?
+      Pay::Braintree.configure_webhooks if Pay::Braintree.enabled?
+      Pay::Paddle.configure_webhooks if Pay::Paddle.enabled?
+    end
+
     config.to_prepare do
-      Pay::Stripe.setup if defined? ::Stripe
-      Pay::Braintree.setup if defined? ::Braintree
-      Pay::Paddle.setup if defined? ::PaddlePay
+      Pay::Stripe.setup if Pay::Stripe.enabled?
+      Pay::Braintree.setup if Pay::Braintree.enabled?
+      Pay::Paddle.setup if Pay::Paddle.enabled?
+
+      if defined?(::Receipts::VERSION)
+        if Pay::Engine.version_matches?(required: "~> 2", current: ::Receipts::VERSION)
+          Pay::Charge.include Pay::Receipts
+        else
+          raise "[Pay] receipts gem must be version ~> 2"
+        end
+      end
+    end
 
-      Pay::Charge.include Pay::Receipts if defined? ::Receipts::Receipt
+    # Determines if a gem version matches requirements
+    # Used for verifying that dependencies are correct
+    def version_matches?(current:, required:)
+      Gem::Dependency.new("gem", required).match? "gem", current
     end
   end
 end

data/lib/pay/fake_processor/billable.rb

@@ -31,8 +31,8 @@ module Pay
           processor_id: NanoId.generate,
           amount: amount,
           data: {
-            kind: :card,
-            type: :fake,
+            payment_method_type: :card,
+            brand: "Fake",
             last4: 1234,
             exp_month: Date.today.month,
             exp_year: Date.today.year
@@ -44,7 +44,6 @@ module Pay
       def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
         # Make to generate a processor_id
         customer
-
         attributes = options.merge(
           processor_id: NanoId.generate,
           name: name,
@@ -52,6 +51,11 @@ module Pay
           status: :active,
           quantity: options.fetch(:quantity, 1)
         )
+
+        if (trial_period_days = attributes.delete(:trial_period_days))
+          attributes[:trial_ends_at] = trial_period_days.to_i.days.from_now
+        end
+
         pay_customer.subscriptions.create!(attributes)
       end
 
@@ -59,10 +63,10 @@ module Pay
         # Make to generate a processor_id
         customer
 
-        pay_customer.payment_methods.create!(
+        pay_payment_method = pay_customer.payment_methods.create!(
           processor_id: NanoId.generate,
           default: default,
-          type: :fake,
+          type: :card,
           data: {
             brand: "Fake",
             last4: 1234,
@@ -70,10 +74,9 @@ module Pay
             exp_year: Date.today.year
           }
         )
-      end
 
-      def update_email!
-        # pass
+        pay_customer.reload_default_payment_method if default
+        pay_payment_method
       end
 
       def processor_subscription(subscription_id, options = {})

data/lib/pay/fake_processor/subscription.rb

@@ -25,7 +25,7 @@ module Pay
 
       # With trial, sets end to trial end (mimicing Stripe)
       # Without trial, sets can ends_at to end of month
-      def cancel
+      def cancel(**options)
         if pay_subscription.on_trial?
           pay_subscription.update(ends_at: pay_subscription.trial_ends_at)
         else
@@ -33,8 +33,13 @@ module Pay
         end
       end
 
-      def cancel_now!
-        pay_subscription.update(ends_at: Time.current, status: :canceled)
+      def cancel_now!(**options)
+        ends_at = Time.current
+        pay_subscription.update(
+          status: :canceled,
+          trial_ends_at: (ends_at if pay_subscription.trial_ends_at?),
+          ends_at: ends_at
+        )
       end
 
       def on_grace_period?
@@ -57,6 +62,9 @@ module Pay
 
       def swap(plan)
       end
+
+      def change_quantity(quantity)
+      end
     end
   end
 end

data/lib/pay/paddle/billable.rb

@@ -53,10 +53,6 @@ module Pay
         Pay::Paddle::PaymentMethod.sync(self)
       end
 
-      def update_email!
-        # pass
-      end
-
       def trial_end_date(subscription)
         return unless subscription.state == "trialing"
         Time.zone.parse(subscription.next_payment[:date]).end_of_day

data/lib/pay/paddle/subscription.rb

@@ -74,7 +74,7 @@ module Pay
         raise Pay::Paddle::Error, e
       end
 
-      def cancel
+      def cancel(**options)
         ends_at = if on_trial?
           trial_ends_at
         elsif paused?
@@ -92,7 +92,7 @@ module Pay
         raise Pay::Paddle::Error, e
       end
 
-      def cancel_now!
+      def cancel_now!(**options)
         PaddlePay::Subscription::User.cancel(processor_id)
         pay_subscription.update(status: :canceled, ends_at: Time.current)
 

data/lib/pay/paddle/webhooks/signature_verifier.rb

@@ -8,11 +8,15 @@ module Pay
       class SignatureVerifier
         def initialize(data)
           @data = data
+          @public_key_file = Pay::Paddle.public_key_file
+          @public_key = Pay::Paddle.public_key
           @public_key_base64 = Pay::Paddle.public_key_base64
         end
 
         def verify
           data = @data
+          public_key = @public_key if @public_key
+          public_key = File.read(@public_key_file) if @public_key_file
           public_key = Base64.decode64(@public_key_base64) if @public_key_base64
           return false unless data && data["p_signature"] && public_key
 
@@ -59,53 +63,53 @@ module Pay
         def serialize(var, assoc = false)
           s = ""
           case var
-            when Array
-              s << "a:#{var.size}:{"
-              if assoc && var.first.is_a?(Array) && (var.first.size == 2)
-                var.each do |k, v|
-                  s << serialize(k, assoc) << serialize(v, assoc)
-                end
-              else
-                var.each_with_index do |v, i|
-                  s << "i:#{i};#{serialize(v, assoc)}"
-                end
-              end
-              s << "}"
-            when Hash
-              s << "a:#{var.size}:{"
+          when Array
+            s << "a:#{var.size}:{"
+            if assoc && var.first.is_a?(Array) && (var.first.size == 2)
               var.each do |k, v|
-                s << "#{serialize(k, assoc)}#{serialize(v, assoc)}"
+                s << serialize(k, assoc) << serialize(v, assoc)
               end
-              s << "}"
-            when Struct
+            else
+              var.each_with_index do |v, i|
+                s << "i:#{i};#{serialize(v, assoc)}"
+              end
+            end
+            s << "}"
+          when Hash
+            s << "a:#{var.size}:{"
+            var.each do |k, v|
+              s << "#{serialize(k, assoc)}#{serialize(v, assoc)}"
+            end
+            s << "}"
+          when Struct
+            # encode as Object with same name
+            s << "O:#{var.class.to_s.bytesize}:\"#{var.class.to_s.downcase}\":#{var.members.length}:{"
+            var.members.each do |member|
+              s << "#{serialize(member, assoc)}#{serialize(var[member], assoc)}"
+            end
+            s << "}"
+          when String, Symbol
+            s << "s:#{var.to_s.bytesize}:\"#{var}\";"
+          when Integer
+            s << "i:#{var};"
+          when Float
+            s << "d:#{var};"
+          when NilClass
+            s << "N;"
+          when FalseClass, TrueClass
+            s << "b:#{var ? 1 : 0};"
+          else
+            if var.respond_to?(:to_assoc)
+              v = var.to_assoc
               # encode as Object with same name
-              s << "O:#{var.class.to_s.bytesize}:\"#{var.class.to_s.downcase}\":#{var.members.length}:{"
-              var.members.each do |member|
-                s << "#{serialize(member, assoc)}#{serialize(var[member], assoc)}"
+              s << "O:#{var.class.to_s.bytesize}:\"#{var.class.to_s.downcase}\":#{v.length}:{"
+              v.each do |k, v|
+                s << "#{serialize(k.to_s, assoc)}#{serialize(v, assoc)}"
               end
               s << "}"
-            when String, Symbol
-              s << "s:#{var.to_s.bytesize}:\"#{var}\";"
-            when Integer
-              s << "i:#{var};"
-            when Float
-              s << "d:#{var};"
-            when NilClass
-              s << "N;"
-            when FalseClass, TrueClass
-              s << "b:#{var ? 1 : 0};"
             else
-              if var.respond_to?(:to_assoc)
-                v = var.to_assoc
-                # encode as Object with same name
-                s << "O:#{var.class.to_s.bytesize}:\"#{var.class.to_s.downcase}\":#{v.length}:{"
-                v.each do |k, v|
-                  s << "#{serialize(k.to_s, assoc)}#{serialize(v, assoc)}"
-                end
-                s << "}"
-              else
-                raise TypeError, "Unable to serialize type #{var.class}"
-              end
+              raise TypeError, "Unable to serialize type #{var.class}"
+            end
           end
           s
         end

data/lib/pay/paddle/webhooks/subscription_cancelled.rb

@@ -9,8 +9,13 @@ module Pay
           return if pay_subscription.nil?
 
           # User canceled subscriptions have an ends_at
-          # Automatically canceled subscriptions need this value set
-          pay_subscription.update!(ends_at: Time.zone.parse(event.cancellation_effective_date)) if pay_subscription.ends_at.blank? && event.cancellation_effective_date.present?
+          # Automatically cancelled subscriptions need this value set
+          ends_at = Time.zone.parse(event.cancellation_effective_date)
+          pay_subscription.update!(
+            status: :canceled,
+            trial_ends_at: (ends_at if pay_subscription.trial_ends_at?),
+            ends_at: ends_at
+          )
 
           # Paddle doesn't allow reusing customers, so we should remove their payment methods
           Pay::PaymentMethod.where(customer_id: pay_subscription.customer_id).destroy_all

data/lib/pay/paddle/webhooks/subscription_payment_refunded.rb

@@ -6,10 +6,10 @@ module Pay
           pay_charge = Pay::Charge.find_by_processor_and_id(:paddle, event.subscription_payment_id)
           return unless pay_charge.present?
 
-          pay_charge.update(amount_refunded: (event.gross_refund.to_f * 100).to_i)
+          pay_charge.update!(amount_refunded: (event.gross_refund.to_f * 100).to_i)
 
-          if Pay.send_emails
-            Pay::UserMailer.with(pay_customer: pay_charge.customer, charge: pay_charge).refund.deliver_later
+          if Pay.send_email?(:refund, pay_charge)
+            Pay::UserMailer.with(pay_customer: pay_charge.customer, pay_charge: pay_charge).refund.deliver_later
           end
         end
       end

data/lib/pay/paddle/webhooks/subscription_payment_succeeded.rb

@@ -17,8 +17,8 @@ module Pay
 
           return if pay_customer.charges.where(processor_id: event.subscription_payment_id).any?
 
-          charge = create_charge(pay_customer, event)
-          notify_user(charge)
+          pay_charge = create_charge(pay_customer, event)
+          notify_user(pay_charge)
         end
 
         def create_charge(pay_customer, event)
@@ -33,18 +33,18 @@ module Pay
             metadata: Pay::Paddle.parse_passthrough(event.passthrough).except("owner_sgid")
           }.merge(payment_method_details)
 
-          charge = pay_customer.charges.find_or_initialize_by(processor_id: event.subscription_payment_id)
-          charge.update!(attributes)
+          pay_charge = pay_customer.charges.find_or_initialize_by(processor_id: event.subscription_payment_id)
+          pay_charge.update!(attributes)
 
           # Update customer's payment method
           Pay::Paddle::PaymentMethod.sync(pay_customer: pay_customer, attributes: payment_method_details)
 
-          charge
+          pay_charge
         end
 
         def notify_user(pay_charge)
-          if Pay.send_emails
-            Pay::UserMailer.with(pay_customer: pay_charge.customer, charge: pay_charge).receipt.deliver_later
+          if Pay.send_email?(:receipt, pay_charge)
+            Pay::UserMailer.with(pay_customer: pay_charge.customer, pay_charge: pay_charge).receipt.deliver_later
           end
         end
       end

data/lib/pay/paddle/webhooks/subscription_updated.rb

@@ -3,33 +3,33 @@ module Pay
     module Webhooks
       class SubscriptionUpdated
         def call(event)
-          subscription = Pay::Subscription.find_by_processor_and_id(:paddle, event["subscription_id"])
+          pay_subscription = Pay::Subscription.find_by_processor_and_id(:paddle, event["subscription_id"])
 
-          return if subscription.nil?
+          return if pay_subscription.nil?
 
           case event["status"]
           when "deleted"
-            subscription.status = "canceled"
-            subscription.ends_at = Time.zone.parse(event["next_bill_date"]) || Time.current if subscription.ends_at.blank?
+            pay_subscription.status = "canceled"
+            pay_subscription.ends_at = Time.zone.parse(event["next_bill_date"]) || Time.current if pay_subscription.ends_at.blank?
           when "trialing"
-            subscription.status = "trialing"
-            subscription.trial_ends_at = Time.zone.parse(event["next_bill_date"])
+            pay_subscription.status = "trialing"
+            pay_subscription.trial_ends_at = Time.zone.parse(event["next_bill_date"])
           when "active"
-            subscription.status = "active"
-            subscription.paddle_paused_from = Time.zone.parse(event["paused_from"]) if event["paused_from"].present?
+            pay_subscription.status = "active"
+            pay_subscription.paddle_paused_from = Time.zone.parse(event["paused_from"]) if event["paused_from"].present?
           else
-            subscription.status = event["status"]
+            pay_subscription.status = event["status"]
           end
 
-          subscription.quantity = event["new_quantity"]
-          subscription.processor_plan = event["subscription_plan_id"]
-          subscription.paddle_update_url = event["update_url"]
-          subscription.paddle_cancel_url = event["cancel_url"]
+          pay_subscription.quantity = event["new_quantity"]
+          pay_subscription.processor_plan = event["subscription_plan_id"]
+          pay_subscription.paddle_update_url = event["update_url"]
+          pay_subscription.paddle_cancel_url = event["cancel_url"]
 
           # If user was on trial, their subscription ends at the end of the trial
-          subscription.ends_at = subscription.trial_ends_at if subscription.on_trial?
+          pay_subscription.ends_at = pay_subscription.trial_ends_at if pay_subscription.on_trial?
 
-          subscription.save!
+          pay_subscription.save!
         end
       end
     end

data/lib/pay/paddle.rb

@@ -17,12 +17,16 @@ module Pay
 
     extend Env
 
+    def self.enabled?
+      return false unless Pay.enabled_processors.include?(:paddle) && defined?(::PaddlePay)
+
+      Pay::Engine.version_matches?(required: "~> 0.2", current: ::PaddlePay::VERSION) || (raise "[Pay] paddle gem must be version ~> 0.2")
+    end
+
     def self.setup
       ::PaddlePay.config.vendor_id = vendor_id
       ::PaddlePay.config.vendor_auth_code = vendor_auth_code
       ::PaddlePay.config.environment = environment
-
-      configure_webhooks
     end
 
     def self.vendor_id
@@ -37,6 +41,14 @@ module Pay
       find_value_by_name(:paddle, :environment) || "production"
     end
 
+    def self.public_key
+      find_value_by_name(:paddle, :public_key)
+    end
+
+    def self.public_key_file
+      find_value_by_name(:paddle, :public_key_file)
+    end
+
     def self.public_key_base64
       find_value_by_name(:paddle, :public_key_base64)
     end

data/lib/pay/receipts.rb

@@ -13,27 +13,102 @@ module Pay
       receipt_pdf.render
     end
 
-    def receipt_pdf(**options)
-      line_items = [
+    def receipt_details
+      [
+        [I18n.t("pay.receipt.number"), receipt_number],
         [I18n.t("pay.receipt.date"), I18n.l(created_at, format: :long)],
-        [I18n.t("pay.receipt.account_billed"), "#{customer.customer_name} (#{customer.email})"],
-        [I18n.t("pay.receipt.product"), product],
-        [I18n.t("pay.receipt.amount"), Pay::Currency.format(amount, currency: currency)],
-        [I18n.t("pay.receipt.charged_to"), charged_to]
+        [I18n.t("pay.receipt.payment_method"), charged_to]
+      ]
+    end
+
+    def pdf_line_items
+      items = [
+        [
+          "<b>#{I18n.t("pay.line_items.description")}</b>",
+          "<b>#{I18n.t("pay.line_items.quantity")}</b>",
+          "<b>#{I18n.t("pay.line_items.unit_price")}</b>",
+          "<b>#{I18n.t("pay.line_items.amount")}</b>"
+        ]
       ]
-      line_items << [I18n.t("pay.receipt.additional_info"), customer.owner.extra_billing_info] if customer.owner.try(:extra_billing_info?)
-      line_items << [I18n.t("pay.receipt.refunded"), Pay::Currency.format(amount_refunded, currency: currency)] if refunded?
+
+      # Unit price is stored with the line item
+      # Negative amounts shouldn't display quantity
+      # Sort by line_items by period_end? oldest to newest
+      if line_items.any?
+        line_items.each do |li|
+          items << [li["description"], li["quantity"], Pay::Currency.format(li["unit_amount"], currency: currency), Pay::Currency.format(li["amount"], currency: currency)]
+
+          Array.wrap(li["discounts"]).each do |discount_id|
+            if (discount = total_discount_amounts.find { |d| d.dig("discount", "id") == discount_id })
+              items << [discount_description(discount), nil, nil, Pay::Currency.format(-discount["amount"], currency: currency)]
+            end
+          end
+        end
+      else
+        items << [product, 1, Pay::Currency.format(amount, currency: currency), Pay::Currency.format(amount, currency: currency)]
+      end
+
+      # If no subtotal, we will display the total
+      items << [nil, nil, I18n.t("pay.line_items.subtotal"), Pay::Currency.format(subtotal || amount, currency: currency)]
+
+      # Discounts on the invoice
+      Array.wrap(discounts).each do |discount_id|
+        if (discount = total_discount_amounts.find { |d| d.dig("discount", "id") == discount_id })
+          items << [nil, nil, discount_description(discount), Pay::Currency.format(-discount["amount"], currency: currency)]
+        end
+      end
+
+      # Tax rates
+      Array.wrap(total_tax_amounts).each do |tax_amount|
+        items << [nil, nil, tax_description(tax_amount), Pay::Currency.format(tax, currency: currency)]
+      end
+
+      items << [nil, nil, I18n.t("pay.line_items.total"), Pay::Currency.format(amount, currency: currency)]
+      items
+    end
+
+    def discount_description(discount)
+      coupon = discount.dig("discount", "coupon")
+      name = coupon.dig("name")
+
+      if (percent = coupon["percent_off"])
+        I18n.t("pay.line_items.percent_discount", name: name, percent: ActiveSupport::NumberHelper.number_to_rounded(percent, strip_insignificant_zeros: true))
+      else
+        I18n.t("pay.line_items.amount_discount", name: name, amount: Pay::Currency.format(coupon["amount_off"], currency: coupon["currency"]))
+      end
+    end
+
+    def tax_description(tax_amount)
+      tax_rate = tax_amount["tax_rate"]
+      percent = "#{ActiveSupport::NumberHelper.number_to_rounded(tax_rate["percentage"], strip_insignificant_zeros: true)}%"
+      percent += " inclusive" if tax_rate["inclusive"]
+      "#{tax_rate["display_name"]} - #{tax_rate["jurisdiction"]} (#{percent})"
+    end
+
+    def receipt_pdf(**options)
+      receipt_line_items = pdf_line_items
+
+      # Include total paid
+      receipt_line_items << [nil, nil, I18n.t("pay.receipt.amount_paid"), Pay::Currency.format(amount, currency: currency)]
+
+      if refunded?
+        receipt_line_items << [nil, nil, I18n.t("pay.receipt.refunded_on"), Pay::Currency.format(amount_refunded, currency: currency)]
+      end
 
       defaults = {
-        id: id,
-        product: product,
+        details: receipt_details,
+        recipient: [
+          customer.customer_name,
+          customer.email,
+          customer.owner.try(:extra_billing_info)
+        ],
         company: {
           name: Pay.business_name,
           address: Pay.business_address,
           email: Pay.support_email,
           logo: Pay.business_logo
         },
-        line_items: line_items
+        line_items: receipt_line_items
       }
 
       ::Receipts::Receipt.new(defaults.deep_merge(options))
@@ -47,41 +122,40 @@ module Pay
       invoice_pdf.render
     end
 
-    def invoice_pdf(**options)
-      bill_to = [customer.owner.name]
-      bill_to += [customer.owner.extra_billing_info] if customer.owner.try(:extra_billing_info?)
-      bill_to += [nil, customer.owner.email]
-
-      total = Pay::Currency.format(amount, currency: currency)
-
-      line_items = [
-        ["<b>#{I18n.t("pay.invoice.product")}</b>", nil, "<b>#{I18n.t("pay.invoice.amount")}</b>"],
-        [product, nil, total],
-        [nil, I18n.t("pay.invoice.subtotal"), total],
-        [nil, I18n.t("pay.invoice.total"), total]
+    def invoice_details
+      [
+        [I18n.t("pay.invoice.number"), invoice_number],
+        [I18n.t("pay.invoice.date"), I18n.l(created_at, format: :long)],
+        [I18n.t("pay.invoice.payment_method"), charged_to]
       ]
+    end
 
+    def invoice_pdf(**options)
       defaults = {
-        id: id,
-        issue_date: I18n.l(created_at, format: :long),
-        due_date: I18n.l(created_at, format: :long),
-        status: "<b><color rgb='#5eba7d'>#{I18n.t("pay.receipt.paid").upcase}</color></b>",
-        bill_to: bill_to,
-        product: product,
+        details: invoice_details,
+        recipient: [
+          customer.customer_name,
+          customer.email,
+          customer.owner.try(:extra_billing_info)
+        ],
         company: {
           name: Pay.business_name,
           address: Pay.business_address,
           email: Pay.support_email,
           logo: Pay.business_logo
         },
-        line_items: line_items
+        line_items: pdf_line_items
       }
 
       ::Receipts::Invoice.new(defaults.deep_merge(options))
     end
 
-    def line_items
-      line_items
+    def invoice_number
+      id
+    end
+
+    def receipt_number
+      invoice_number
     end
   end
 end