reji 1.0.0

data/lib/generators/reji/install/templates/reji.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+Reji.configure do |config|
+  # Stripe Keys
+  #
+  # The Stripe publishable key and secret key give you access to Stripe's
+  # API. The "publishable" key is typically used when interacting with
+  # Stripe.js while the "secret" key accesses private API endpoints.
+  config.key = ENV['STRIPE_KEY']
+  config.secret = ENV['STRIPE_SECRET']
+
+  # Stripe Webhooks
+  #
+  # Your Stripe webhook secret is used to prevent unauthorized requests to
+  # your Stripe webhook handling controllers. The tolerance setting will
+  # check the drift between the current time and the signed request's.
+  config.webhook = {
+    :secret => ENV['STRIPE_WEBHOOK_SECRET'],
+    :tolerance => ENV['STRIPE_WEBHOOK_TOLERANCE'] || 300,
+  }
+
+  # Reji Model
+  #
+  # This is the model in your application that includes the Billable concern
+  # provided by Reji. It will serve as the primary model you use while
+  # interacting with Reji related methods, subscriptions, and so on.
+  config.model = ENV['REJI_MODEL'] || 'User'
+  config.model_id = ENV['REJI_MODEL_ID'] || 'user_id'
+
+  # Currency
+  #
+  # This is the default currency that will be used when generating charges
+  # from your application. Of course, you are welcome to use any of the
+  # various world currencies that are currently supported via Stripe.
+  config.currency = ENV['REJI_CURRENCY'] || 'usd'
+end

data/lib/reji.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'stripe'
+require 'money'
+
+require 'reji/engine'
+require 'reji/configuration'
+
+require 'reji/concerns/manages_customer'
+require 'reji/concerns/manages_invoices'
+require 'reji/concerns/manages_payment_methods'
+require 'reji/concerns/manages_subscriptions'
+require 'reji/concerns/performs_charges'
+require 'reji/concerns/interacts_with_payment_behavior'
+require 'reji/concerns/prorates'
+
+require 'reji/billable'
+require 'reji/errors'
+require 'reji/invoice'
+require 'reji/invoice_line_item'
+require 'reji/payment'
+require 'reji/payment_method'
+require 'reji/subscription'
+require 'reji/subscription_builder'
+require 'reji/subscription_item'
+require 'reji/tax'
+
+module Reji
+  # The Stripe API version.
+  STRIPE_VERSION = '2020-08-27'
+
+  # Indicates if Reji will mark past due subscriptions as inactive.
+  @@deactivate_past_due = true
+
+  class << self
+    attr_accessor :deactivate_past_due
+  end
+
+  # Get the billable entity instance by Stripe ID.
+  def self.find_billable(stripe_id)
+    return if stripe_id.nil?
+
+    model = @configuration.model
+    model.constantize.where(stripe_id: stripe_id).first
+  end
+
+  # Get the default Stripe API options.
+  def self.stripe_options(options = {})
+    {
+      :api_key => Reji.configuration.secret,
+      :stripe_version => Reji::STRIPE_VERSION,
+    }.merge(options)
+  end
+
+  # Format the given amount into a displayable currency.
+  def self.format_amount(amount, currency = nil)
+    currency = 'usd' if currency.nil?
+
+    Money.rounding_mode = BigDecimal::ROUND_HALF_EVEN
+    Money.locale_backend = :i18n
+
+    money = Money.new(amount, Money::Currency.new(currency.upcase))
+
+    money.format
+  end
+
+  # Configure to maintain past due subscriptions as active.
+  def self.keep_past_due_subscriptions_active
+    @@deactivate_past_due = false
+
+    self
+  end
+end
+
+Stripe.set_app_info('Rails Reji')

data/lib/reji/billable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Reji
+  module Billable
+    extend ActiveSupport::Concern
+
+    include Reji::ManagesCustomer
+    include Reji::ManagesInvoices
+    include Reji::ManagesPaymentMethods
+    include Reji::ManagesSubscriptions
+    include Reji::PerformsCharges
+  end
+end

data/lib/reji/concerns/interacts_with_payment_behavior.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Reji
+  module InteractsWithPaymentBehavior
+    extend ActiveSupport::Concern
+
+    # Allow subscription changes even if payment fails.
+    def allow_payment_failures
+      @payment_behavior = 'allow_incomplete'
+
+      self
+    end
+
+    # Set any subscription change as pending until payment is successful.
+    def pending_if_payment_fails
+      @payment_behavior = 'pending_if_incomplete'
+
+      self
+    end
+
+    # Prevent any subscription change if payment is unsuccessful.
+    def error_if_payment_fails
+      @payment_behavior = 'error_if_incomplete'
+
+      self
+    end
+
+    # Determine the payment behavior when updating the subscription.
+    def payment_behavior
+      @payment_behavior ||= 'allow_incomplete'
+    end
+  end
+end

data/lib/reji/concerns/manages_customer.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Reji
+  module ManagesCustomer
+    extend ActiveSupport::Concern
+
+    # Determine if the entity has a Stripe customer ID.
+    def has_stripe_id
+      ! self.stripe_id.nil?
+    end
+
+    # Create a Stripe customer for the given model.
+    def create_as_stripe_customer(options = {})
+      raise Reji::CustomerAlreadyCreatedError.exists(self) if self.has_stripe_id
+
+      if ! options.key?('email') && self.stripe_email
+        options[:email] = self.stripe_email
+      end
+
+      # Here we will create the customer instance on Stripe and store the ID of the
+      # user from Stripe. This ID will correspond with the Stripe user instances
+      # and allow us to retrieve users from Stripe later when we need to work.
+      customer = Stripe::Customer.create(
+        options, self.stripe_options
+      )
+
+      self.update({:stripe_id => customer.id})
+
+      customer
+    end
+
+    # Update the underlying Stripe customer information for the model.
+    def update_stripe_customer(options = {})
+      Stripe::Customer.update(
+        self.stripe_id, options, self.stripe_options
+      )
+    end
+
+    # Get the Stripe customer instance for the current user or create one.
+    def create_or_get_stripe_customer(options = {})
+      return self.as_stripe_customer if self.has_stripe_id
+
+      self.create_as_stripe_customer(options)
+    end
+
+    # Get the Stripe customer for the model.
+    def as_stripe_customer
+      self.assert_customer_exists
+
+      Stripe::Customer.retrieve(self.stripe_id, self.stripe_options)
+    end
+
+    # Get the email address used to create the customer in Stripe.
+    def stripe_email
+      self.email
+    end
+
+    # Apply a coupon to the billable entity.
+    def apply_coupon(coupon)
+      self.assert_customer_exists
+
+      customer = self.as_stripe_customer
+
+      customer.coupon = coupon
+
+      customer.save
+    end
+
+    # Get the Stripe supported currency used by the entity.
+    def preferred_currency
+      Reji.configuration.currency
+    end
+
+    # Get the Stripe billing portal for this customer.
+    def billing_portal_url(return_url = nil)
+      self.assert_customer_exists
+
+      session = Stripe::BillingPortal::Session.create({
+        :customer => self.stripe_id,
+        :return_url => return_url || '/',
+      }, self.stripe_options)
+
+      session.url
+    end
+
+    # Determine if the customer is not exempted from taxes.
+    def is_not_tax_exempt
+      self.as_stripe_customer.tax_exempt == 'none'
+    end
+
+    # Determine if the customer is exempted from taxes.
+    def is_tax_exempt
+      self.as_stripe_customer.tax_exempt == 'exempt'
+    end
+
+    # Determine if reverse charge applies to the customer.
+    def reverse_charge_applies
+      self.as_stripe_customer.tax_exempt == 'reverse'
+    end
+
+    # Get the default Stripe API options for the current Billable model.
+    def stripe_options(options = {})
+      Reji.stripe_options(options)
+    end
+
+    protected
+
+    # Determine if the entity has a Stripe customer ID and throw an exception if not.
+    def assert_customer_exists
+      raise Reji::InvalidCustomerError.not_yet_created(self) unless self.has_stripe_id
+    end
+  end
+end

data/lib/reji/concerns/manages_invoices.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Reji
+  module ManagesInvoices
+    extend ActiveSupport::Concern
+
+    # Add an invoice item to the customer's upcoming invoice.
+    def tab(description, amount, options = {})
+      self.assert_customer_exists
+
+      options = {
+        :customer => self.stripe_id,
+        :amount => amount,
+        :currency => self.preferred_currency,
+        :description => description,
+      }.merge(options)
+
+      Stripe::InvoiceItem.create(options, self.stripe_options)
+    end
+
+    # Invoice the customer for the given amount and generate an invoice immediately.
+    def invoice_for(description, amount, tab_options = {}, invoice_options = {})
+      self.tab(description, amount, tab_options)
+
+      self.invoice(invoice_options)
+    end
+
+    # Invoice the billable entity outside of the regular billing cycle.
+    def invoice(options = {})
+      self.assert_customer_exists
+
+      parameters = options.merge({:customer => self.stripe_id})
+
+      begin
+        stripe_invoice = Stripe::Invoice.create(parameters, self.stripe_options)
+
+        if stripe_invoice.collection_method == 'charge_automatically'
+          stripe_invoice = stripe_invoice.pay
+        else
+          stripe_invoice = stripe_invoice.send_invoice
+        end
+
+        Invoice.new(self, stripe_invoice)
+      rescue Stripe::InvalidRequestError => e
+        false
+      rescue Stripe::CardError => e
+        payment = Payment.new(
+          Stripe::PaymentIntent.retrieve(
+            {:id => stripe_invoice.payment_intent, :expand => ['invoice.subscription']},
+            self.stripe_options
+          )
+        )
+
+        payment.validate
+      end
+    end
+
+    # Get the entity's upcoming invoice.
+    def upcoming_invoice
+      return unless self.has_stripe_id
+
+      begin
+        stripe_invoice = Stripe::Invoice.upcoming({:customer => self.stripe_id}, self.stripe_options)
+
+        Invoice.new(self, stripe_invoice)
+      rescue Stripe::InvalidRequestError => e
+        #
+      end
+    end
+
+    # Find an invoice by ID.
+    def find_invoice(id)
+      stripe_invoice = nil
+
+      begin
+        stripe_invoice = Stripe::Invoice.retrieve(id, self.stripe_options)
+      rescue => e
+        #
+      end
+
+      stripe_invoice ? Invoice.new(self, stripe_invoice) : nil
+    end
+
+    # Find an invoice or throw a 404 or 403 error.
+    def find_invoice_or_fail(id)
+      begin
+        invoice = self.find_invoice(id)
+      rescue InvalidInvoiceError => e
+        raise Reji::AccessDeniedHttpError.new(e.message)
+      end
+
+      raise ActiveRecord::RecordNotFound if invoice.nil?
+
+      invoice
+    end
+
+    # Create an invoice download response.
+    def download_invoice(id, data, filename = nil)
+      invoice = self.find_invoice_or_fail(id)
+
+      filename ? invoice.download_as(filename, data) : invoice.download(data)
+    end
+
+    # Get a collection of the entity's invoices.
+    def invoices(include_pending = false, parameters = {})
+      return [] unless self.has_stripe_id
+
+      invoices = []
+
+      parameters = {:limit => 24}.merge(parameters)
+
+      stripe_invoices = Stripe::Invoice.list(
+        {:customer => self.stripe_id}.merge(parameters),
+        self.stripe_options
+      )
+
+      # Here we will loop through the Stripe invoices and create our own custom Invoice
+      # instances that have more helper methods and are generally more convenient to
+      # work with than the plain Stripe objects are. Then, we'll return the array.
+      unless stripe_invoices.nil?
+        stripe_invoices.data.each do |invoice|
+          if invoice.paid || include_pending
+            invoices << Invoice.new(self, invoice)
+          end
+        end
+      end
+
+      invoices
+    end
+
+    # Get an array of the entity's invoices.
+    def invoices_include_pending(parameters = {})
+      self.invoices(true, parameters)
+    end
+  end
+end

data/lib/reji/concerns/manages_payment_methods.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module Reji
+  module ManagesPaymentMethods
+    extend ActiveSupport::Concern
+
+    # Create a new SetupIntent instance.
+    def create_setup_intent(options = {})
+      Stripe::SetupIntent.create(options, self.stripe_options)
+    end
+
+    # Determines if the customer currently has a default payment method.
+    def has_default_payment_method
+      ! self.card_brand.blank?
+    end
+
+    # Determines if the customer currently has at least one payment method.
+    def has_payment_method
+      ! self.payment_methods.empty?
+    end
+
+    # Get a collection of the entity's payment methods.
+    def payment_methods(parameters = {})
+      return [] unless self.has_stripe_id
+
+      parameters = {:limit => 24}.merge(parameters)
+
+      # "type" is temporarily required by Stripe...
+      payment_methods = Stripe::PaymentMethod.list(
+        {customer: self.stripe_id, type: 'card'}.merge(parameters),
+        self.stripe_options
+      )
+
+      payment_methods.data.map { |payment_method| PaymentMethod.new(self, payment_method) }
+    end
+
+    # Add a payment method to the customer.
+    def add_payment_method(payment_method)
+      self.assert_customer_exists
+
+      stripe_payment_method = self.resolve_stripe_payment_method(payment_method)
+
+      if stripe_payment_method.customer != self.stripe_id
+        stripe_payment_method = stripe_payment_method.attach(
+          {:customer => self.stripe_id}, self.stripe_options
+        )
+      end
+
+      PaymentMethod.new(self, stripe_payment_method)
+    end
+
+    # Remove a payment method from the customer.
+    def remove_payment_method(payment_method)
+      self.assert_customer_exists
+
+      stripe_payment_method = self.resolve_stripe_payment_method(payment_method)
+
+      return if stripe_payment_method.customer != self.stripe_id
+
+      customer = self.as_stripe_customer
+
+      default_payment_method = customer.invoice_settings.default_payment_method
+
+      stripe_payment_method.detach({}, self.stripe_options)
+
+      # If the payment method was the default payment method, we'll remove it manually...
+      if stripe_payment_method.id == default_payment_method
+        self.update({
+          :card_brand => nil,
+          :card_last_four => nil,
+        })
+      end
+    end
+
+    # Get the default payment method for the entity.
+    def default_payment_method
+      return unless self.has_stripe_id
+
+      customer = Stripe::Customer.retrieve({
+        :id => self.stripe_id,
+        :expand => [
+          'invoice_settings.default_payment_method',
+          'default_source',
+        ]
+      }, self.stripe_options)
+
+      if customer.invoice_settings.default_payment_method
+        return PaymentMethod.new(
+          self,
+          customer.invoice_settings.default_payment_method
+        )
+      end
+
+      # If we can't find a payment method, try to return a legacy source...
+      customer.default_source
+    end
+
+    # Update customer's default payment method.
+    def update_default_payment_method(payment_method)
+      self.assert_customer_exists
+
+      customer = self.as_stripe_customer
+
+      stripe_payment_method = self.resolve_stripe_payment_method(payment_method)
+
+      # If the customer already has the payment method as their default, we can bail out
+      # of the call now. We don't need to keep adding the same payment method to this
+      # model's account every single time we go through this specific process call.
+      return if stripe_payment_method.id == customer.invoice_settings.default_payment_method
+
+      payment_method = self.add_payment_method(stripe_payment_method)
+
+      customer.invoice_settings = {:default_payment_method => payment_method.id}
+
+      customer.save
+
+      # Next we will get the default payment method for this user so we can update the
+      # payment method details on the record in the database. This will allow us to
+      # show that information on the front-end when updating the payment methods.
+      self.fill_payment_method_details(payment_method)
+      self.save
+
+      payment_method
+    end
+
+    # Synchronises the customer's default payment method from Stripe back into the database.
+    def update_default_payment_method_from_stripe
+      default_payment_method = self.default_payment_method
+
+      if default_payment_method
+        if default_payment_method.instance_of? PaymentMethod
+          self.fill_payment_method_details(
+            default_payment_method.as_stripe_payment_method
+          ).save
+        else
+          self.fill_source_details(default_payment_method).save
+        end
+      else
+        self.update({
+          :card_brand => nil,
+          :card_last_four => nil,
+        })
+      end
+
+      self
+    end
+
+    # Deletes the entity's payment methods.
+    def delete_payment_methods
+      self.payment_methods.each { |payment_method| payment_method.delete }
+
+      self.update_default_payment_method_from_stripe
+    end
+
+    # Find a PaymentMethod by ID.
+    def find_payment_method(payment_method)
+      stripe_payment_method = nil
+
+      begin
+        stripe_payment_method = self.resolve_stripe_payment_method(payment_method)
+      rescue => e
+        #
+      end
+
+      stripe_payment_method ? PaymentMethod.new(self, stripe_payment_method) : nil
+    end
+
+    protected
+
+    # Fills the model's properties with the payment method from Stripe.
+    def fill_payment_method_details(payment_method)
+      if payment_method.type == 'card'
+        self.card_brand = payment_method.card.brand
+        self.card_last_four = payment_method.card.last4
+      end
+
+      payment_method
+    end
+
+    # Fills the model's properties with the source from Stripe.
+    def fill_source_details(source)
+      if source.instance_of? Stripe::Card
+        self.card_brand = source.brand
+        self.card_last_four = source.last4
+      elsif source.instance_of? Stripe::BankAccount
+        self.card_brand = 'Bank Account'
+        self.card_last_four = source.last4
+      end
+
+      self
+    end
+
+    # Resolve a PaymentMethod ID to a Stripe PaymentMethod object.
+    def resolve_stripe_payment_method(payment_method)
+      return payment_method if payment_method.instance_of? Stripe::PaymentMethod
+
+      Stripe::PaymentMethod.retrieve(
+        payment_method, self.stripe_options
+      )
+    end
+  end
+end