reji 1.0.0

data/lib/reji/concerns/manages_subscriptions.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Reji
+  module ManagesSubscriptions
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :subscriptions, -> { order(created_at: :desc) }, class_name: 'Reji::Subscription'
+    end
+
+    # Begin creating a new subscription.
+    def new_subscription(name, plans)
+      SubscriptionBuilder.new(self, name, plans)
+    end
+
+    # Determine if the Stripe model is on trial.
+    def on_trial(name = 'default', plan = nil)
+      return true if name == 'default' && plan.nil? && self.on_generic_trial
+
+      subscription = self.subscription(name)
+
+      return false unless subscription && subscription.on_trial
+
+      plan ? subscription.has_plan(plan) : true
+    end
+
+    # Determine if the Stripe model is on a "generic" trial at the model level.
+    def on_generic_trial
+      !! self.trial_ends_at && self.trial_ends_at.future?
+    end
+
+    # Determine if the Stripe model has a given subscription.
+    def subscribed(name = 'default', plan = nil)
+      subscription = self.subscription(name)
+
+      return false unless subscription && subscription.valid?
+
+      plan ? subscription.has_plan(plan) : true
+    end
+
+    # Get a subscription instance by name.
+    def subscription(name = 'default')
+      self.subscriptions
+        .sort_by { |subscription| subscription.created_at.to_i }
+        .reverse
+        .find { |subscription| subscription.name == name }
+    end
+
+    # Determine if the customer's subscription has an incomplete payment.
+    def has_incomplete_payment(name = 'default')
+      subscription = self.subscription(name)
+
+      subscription ? subscription.has_incomplete_payment : false
+    end
+
+    # Determine if the Stripe model is actively subscribed to one of the given plans.
+    def subscribed_to_plan(plans, name = 'default')
+      subscription = self.subscription(name)
+
+      return false unless subscription && subscription.valid?
+
+      plans = [plans] unless plans.instance_of? Array
+
+      plans.each do |plan|
+        return true if subscription.has_plan(plan)
+      end
+
+      false
+    end
+
+    # Determine if the entity has a valid subscription on the given plan.
+    def on_plan(plan)
+      self.subscriptions.any? { |subscription| subscription.valid && subscription.has_plan(plan) }
+    end
+
+    # Get the tax percentage to apply to the subscription.
+    def tax_percentage
+      0
+    end
+
+    # Get the tax rates to apply to the subscription.
+    def tax_rates
+      {}
+    end
+
+    # Get the tax rates to apply to individual subscription items.
+    def plan_tax_rates
+      {}
+    end
+  end
+end

data/lib/reji/concerns/performs_charges.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Reji
+  module PerformsCharges
+    extend ActiveSupport::Concern
+
+    # Make a "one off" charge on the customer for the given amount.
+    def charge(amount, payment_method, options = {})
+      options = {
+        :confirmation_method => 'automatic',
+        :confirm => true,
+        :currency => self.preferred_currency,
+      }.merge(options)
+
+      options[:amount] = amount
+      options[:payment_method] = payment_method
+      options[:customer] = self.stripe_id if self.has_stripe_id
+
+      payment = Payment.new(
+        Stripe::PaymentIntent.create(options, self.stripe_options)
+      )
+
+      payment.validate
+
+      payment
+    end
+
+    # Refund a customer for a charge.
+    def refund(payment_intent, options = {})
+      Stripe::Refund.create(
+        {:payment_intent => payment_intent}.merge(options),
+        self.stripe_options
+      )
+    end
+  end
+end

data/lib/reji/concerns/prorates.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Reji
+  module Prorates
+    extend ActiveSupport::Concern
+
+    # Indicate that the plan change should not be prorated.
+    def no_prorate
+      @proration_behavior = 'none'
+
+      self
+    end
+
+    # Indicate that the plan change should be prorated.
+    def prorate
+      @proration_behavior = 'create_prorations'
+
+      self
+    end
+
+    # Indicate that the plan change should always be invoiced.
+    def always_invoice
+      @proration_behavior = 'always_invoice'
+    end
+
+    # Set the prorating behavior.
+    def set_proration_behavior(value)
+      @proration_behavior = value
+
+      self
+    end
+
+    # Determine the prorating behavior when updating the subscription.
+    def prorate_behavior
+      @proration_behavior ||= 'create_prorations'
+    end
+  end
+end

data/lib/reji/configuration.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Reji
+  class Configuration
+    # 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.
+    attr_accessor :key
+    attr_accessor :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.
+    attr_accessor :webhook
+
+    # 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.
+    attr_accessor :model
+    attr_accessor :model_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.
+    attr_accessor :currency
+
+    def initialize
+      @key = ENV['STRIPE_KEY']
+      @secret = ENV['STRIPE_SECRET']
+      @webhook = {
+        :secret => ENV['STRIPE_WEBHOOK_SECRET'],
+        :tolerance => ENV['STRIPE_WEBHOOK_TOLERANCE'] || 300,
+      }
+      @model = ENV['REJI_MODEL'] || 'User'
+      @model_id = ENV['REJI_MODEL_ID'] || 'user_id'
+      @currency = ENV['REJI_CURRENCY'] || 'usd'
+    end
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configuration=(config)
+    @configuration = config
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+end

data/lib/reji/engine.rb

@@ -0,0 +1,4 @@
+module Reji
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/reji/errors.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Reji
+  class IncompletePaymentError < StandardError
+    attr_accessor :payment
+
+    def initialize(payment, message = '')
+      super(message)
+
+      @payment = payment
+    end
+  end
+
+  class PaymentActionRequiredError < IncompletePaymentError
+    def self.incomplete(payment)
+      self.new(payment, 'The payment attempt failed because additional action is required before it can be completed.')
+    end
+  end
+
+  class PaymentFailureError < IncompletePaymentError
+    def self.invalid_payment_method(payment)
+      self.new(payment, 'The payment attempt failed because of an invalid payment method.')
+    end
+  end
+
+  class CustomerAlreadyCreatedError < StandardError
+    def self.exists(owner)
+      self.new("#{owner.class.name} is already a Stripe customer with ID #{owner.stripe_id}.")
+    end
+  end
+
+  class InvalidCustomerError < StandardError
+    def self.not_yet_created(owner)
+      self.new("#{owner.class.name} is not a Stripe customer yet. See the create_as_stripe_customer method.")
+    end
+  end
+
+  class InvalidPaymentMethodError < StandardError
+    def self.invalid_owner(payment_method, owner)
+      self.new("The payment method `#{payment_method.id}` does not belong to this customer `#{owner.stripe_id}`.")
+    end
+  end
+
+  class InvalidInvoiceError < StandardError
+    def self.invalid_owner(invoice, owner)
+      self.new("The invoice `#{invoice.id}` does not belong to this customer `#{owner.stripe_id}`.")
+    end
+  end
+
+  class SubscriptionUpdateFailureError < StandardError
+    def self.incomplete_subscription(subscription)
+      self.new("The subscription \"#{subscription.stripe_id}\" cannot be updated because its payment is incomplete.")
+    end
+
+    def self.duplicate_plan(subscription, plan)
+      self.new("The plan \"#{plan}\" is already attached to subscription \"#{subscription.stripe_id}\".")
+    end
+
+    def self.cannot_delete_last_plan(subscription)
+      self.new("The plan on subscription \"#{subscription.stripe_id}\" cannot be removed because it is the last one.")
+    end
+  end
+
+  class AccessDeniedHttpError < StandardError
+  end
+end

data/lib/reji/invoice.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require 'wicked_pdf'
+
+module Reji
+  class Invoice
+    def initialize(owner, invoice)
+      raise Reji::InvalidInvoiceError.invalid_owner(invoice, owner) if owner.stripe_id != invoice.customer
+
+      @owner = owner
+      @invoice = invoice
+      @items = nil
+      @taxes = nil
+    end
+
+    # Get a date for the invoice.
+    def date
+      Time.at(@invoice.created ? @invoice.created : @invoice.date)
+    end
+
+    # Get the total amount that was paid (or will be paid).
+    def total
+      Reji.format_amount(self.raw_total)
+    end
+
+    # Get the raw total amount that was paid (or will be paid).
+    def raw_total
+      @invoice.total + self.raw_starting_balance
+    end
+
+    # Get the total of the invoice (before discounts).
+    def subtotal
+      Reji.format_amount(@invoice[:subtotal])
+    end
+
+    # Determine if the account had a starting balance.
+    def has_starting_balance
+      self.raw_starting_balance < 0
+    end
+
+    # Get the starting balance for the invoice.
+    def starting_balance
+      Reji.format_amount(self.raw_starting_balance)
+    end
+
+    # Get the raw starting balance for the invoice.
+    def raw_starting_balance
+      @invoice[:starting_balance] ? @invoice[:starting_balance] : 0
+    end
+
+    # Determine if the invoice has a discount.
+    def has_discount
+      self.raw_discount > 0
+    end
+
+    # Get the discount amount.
+    def discount
+      self.format_amount(self.raw_discount)
+    end
+
+    # Get the raw discount amount.
+    def raw_discount
+      return 0 unless @invoice.discount
+
+      return (@invoice.subtotal * (self.percent_off / 100)).round.to_i if self.discount_is_percentage
+
+      self.raw_amount_off
+    end
+
+    # Get the coupon code applied to the invoice.
+    def coupon
+      return @invoice[:discount][:coupon][:id] if @invoice[:discount]
+    end
+
+    # Determine if the discount is a percentage.
+    def discount_is_percentage
+      return false unless @invoice[:discount]
+
+      !! @invoice[:discount][:coupon][:percent_off]
+    end
+
+    # Get the discount percentage for the invoice.
+    def percent_off
+      self.coupon ? @invoice[:discount][:coupon][:percent_off] : 0
+    end
+
+    # Get the discount amount for the invoice.
+    def amount_off
+      self.format_amount(self.raw_amount_off)
+    end
+
+    # Get the raw discount amount for the invoice.
+    def raw_amount_off
+      amount_off = @invoice[:discount][:coupon][:amount_off]
+
+      amount_off ? amount_off : 0
+    end
+
+    # Get the total tax amount.
+    def tax
+      self.format_amount(@invoice.tax)
+    end
+
+    # Determine if the invoice has tax applied.
+    def has_tax
+      line_items = self.invoice_items + self.subscriptions
+
+      line_items.any? { |item| item.has_tax_rates }
+    end
+
+    # Get the taxes applied to the invoice.
+    def taxes
+      return @taxes unless @taxes.nil?
+
+      self.refresh_with_expanded_tax_rates
+
+      @taxes = @invoice.total_tax_amounts
+        .sort_by(&:inclusive)
+        .reverse
+        .map { |tax_amount| Tax.new(tax_amount.amount, @invoice.currency, tax_amount.tax_rate) }
+
+      @taxes
+    end
+
+    # Determine if the customer is not exempted from taxes.
+    def is_not_tax_exempt
+      @invoice[:customer_tax_exempt] == 'none'
+    end
+
+    # Determine if the customer is exempted from taxes.
+    def is_tax_exempt
+      @invoice[:customer_tax_exempt] == 'exempt'
+    end
+
+    # Determine if reverse charge applies to the customer.
+    def reverse_charge_applies
+      @invoice[:customer_tax_exempt] == 'reverse'
+    end
+
+    # Get all of the "invoice item" line items.
+    def invoice_items
+      self.invoice_line_items_by_type('invoiceitem')
+    end
+
+    # Get all of the "subscription" line items.
+    def subscriptions
+      self.invoice_line_items_by_type('subscription')
+    end
+
+    # Get all of the invoice items by a given type.
+    def invoice_line_items_by_type(type)
+      if @items.nil?
+        self.refresh_with_expanded_tax_rates
+
+        @items = @invoice.lines.auto_paging_each
+      end
+
+      @items
+        .select { |item| item.type == type }
+        .map { |item| InvoiceLineItem.new(self, item) }
+    end
+
+    # Get the View instance for the invoice.
+    def view(data)
+      ActionController::Base.new.render_to_string(
+        template: 'receipt',
+        locals: data.merge({
+          invoice: self,
+          owner: self.owner,
+          user: self.owner,
+        })
+      )
+    end
+
+    # Capture the invoice as a PDF and return the raw bytes.
+    def pdf(data)
+      WickedPdf.new.pdf_from_string(self.view(data))
+    end
+
+    # Create an invoice download response.
+    def download(data)
+      filename = "#{data[:product]}_#{self.date.month}_#{self.date.year}"
+
+      self.download_as(filename, data)
+    end
+
+    # Create an invoice download response with a specific filename.
+    def download_as(filename, data)
+      {:data => self.pdf(data), :filename => filename}
+    end
+
+    # Void the Stripe invoice.
+    def void(options = {})
+      @invoice = @invoice.void_invoice(options, @owner.stripe_options)
+
+      self
+    end
+
+    # Get the Stripe model instance.
+    def owner
+      @owner
+    end
+
+    # Get the Stripe invoice instance.
+    def as_stripe_invoice
+      @invoice
+    end
+
+    # Dynamically get values from the Stripe invoice.
+    def method_missing(key)
+      @invoice[key]
+    end
+
+    protected
+
+    # Refresh the invoice with expanded TaxRate objects.
+    def refresh_with_expanded_tax_rates
+      if @invoice.id
+        @invoice = Stripe::Invoice.retrieve({
+          :id => @invoice.id,
+          :expand => [
+            'lines.data.tax_amounts.tax_rate',
+            'total_tax_amounts.tax_rate',
+          ],
+        }, @owner.stripe_options)
+      else
+        # If no invoice ID is present then assume this is the customer's upcoming invoice...
+        @invoice = Stripe::Invoice.upcoming({
+          :customer => @owner.stripe_id,
+          :expand => [
+            'lines.data.tax_amounts.tax_rate',
+            'total_tax_amounts.tax_rate',
+          ],
+        }, @owner.stripe_options)
+      end
+    end
+
+    # Format the given amount into a displayable currency.
+    def format_amount(amount)
+      Reji.format_amount(amount, @invoice.currency)
+    end
+  end
+end