effective_orders 4.5.0

data/app/models/effective/order_item.rb

@@ -0,0 +1,63 @@
+module Effective
+  class OrderItem < ActiveRecord::Base
+    self.table_name = EffectiveOrders.order_items_table_name.to_s
+
+    belongs_to :order, class_name: 'Effective::Order'
+    belongs_to :purchasable, polymorphic: true
+
+    # Attributes
+    # name                  :string
+    # quantity              :integer
+    # price                 :integer, default: 0
+    # tax_exempt            :boolean
+    # timestamps
+
+    validates :purchasable, associated: true, presence: true
+    accepts_nested_attributes_for :purchasable
+
+    validates :name, presence: true
+    validates :quantity, presence: true, numericality: { greater_than: 0 }
+    validates :price, presence: true
+    validates :tax_exempt, inclusion: { in: [true, false] }
+
+    scope :purchased, -> { where(order_id: Effective::Order.purchased) }
+    scope :purchased_by, lambda { |user| where(order_id: Effective::Order.purchased_by(user)) }
+
+    def to_s
+      (quantity || 0) > 1 ? "#{quantity}x #{name}" : name
+    end
+
+    def purchased_download_url
+      purchasable&.purchased_download_url
+    end
+
+    def subtotal
+      price * quantity
+    end
+
+    def quantity
+      self[:quantity] || 1
+    end
+
+    def tax
+      return 0 if tax_exempt?
+      raise 'parent Effective::Order must have a tax_rate to compute order item tax' unless order.try(:tax_rate).present?
+      (subtotal * order.tax_rate / 100.0).round(0).to_i
+    end
+
+    def total
+      return subtotal if tax_exempt?
+      raise 'parent Effective::Order must have a tax_rate to compute order item total' unless order.try(:tax_rate).present?
+      subtotal + tax
+    end
+
+    def price=(value)
+      if value.kind_of?(Integer)
+        super
+      else
+        raise 'expected price to be an Integer representing the number of cents.'
+      end
+    end
+
+  end
+end

data/app/models/effective/product.rb

@@ -0,0 +1,23 @@
+module Effective
+  class Product < ActiveRecord::Base
+    self.table_name = EffectiveOrders.products_table_name.to_s
+
+    acts_as_purchasable
+
+    # Attributes
+    # name          :string
+    # price         :integer, default: 0
+    # tax_exempt    :boolean, default: false
+    #
+    # timestamps
+
+    validates :name, presence: true
+    validates :price, presence: true
+    validates :tax_exempt, inclusion: { in: [true, false] }
+
+    def to_s
+      name || 'New Product'
+    end
+
+  end
+end

data/app/models/effective/sold_out_validator.rb

@@ -0,0 +1,7 @@
+module Effective
+  class SoldOutValidator < ActiveModel::Validator
+    def validate(record)
+      record.errors[:base] << 'sold out' if record.sold_out?
+    end
+  end
+end

data/app/models/effective/subscripter.rb

@@ -0,0 +1,185 @@
+# Form object to select a plan, and build the correct subscription and customer
+
+module Effective
+  class Subscripter
+    include ActiveModel::Model
+
+    attr_accessor :current_user, :user, :subscribable, :customer
+    attr_accessor :subscribable_global_id, :stripe_token, :stripe_plan_id, :quantity
+
+    validates :user, presence: true
+    validates :subscribable, presence: true, if: -> { stripe_plan_id.present? }
+    validates :customer, presence: true
+
+    validates :stripe_plan_id, inclusion: {
+      allow_blank: true,
+      in: EffectiveOrders.stripe_plans.map { |plan| plan[:id] },
+      message: 'unknown plan'
+    }
+
+    validate(if: -> { stripe_plan_id && plan && plan[:amount] > 0 }) do
+      self.errors.add(:stripe_token, 'updated payment card required') if stripe_token.blank? && token_required?
+    end
+
+    validate(if: -> { stripe_plan_id && subscribable }) do
+      quantity_used = [subscribable.subscribable_quantity_used, 0].max
+      self.errors.add(:quantity, "must be #{quantity_used} or greater") unless quantity >= quantity_used
+    end
+
+    def to_s
+      'Your Plan'
+    end
+
+    def customer
+      @customer ||= Effective::Customer.deep.where(user: user).first_or_initialize
+    end
+
+    def current_user=(user)
+      @user = user
+    end
+
+    def subscribable_global_id
+      subscribable&.to_global_id
+    end
+
+    def subscribable_global_id=(global_id)
+      @subscribable = GlobalID::Locator.locate(global_id)
+    end
+
+    def plan
+      EffectiveOrders.stripe_plans.find { |plan| plan[:id] == stripe_plan_id }
+    end
+
+    def quantity=(value)
+      @quantity = (value.to_i if value)
+    end
+
+    def token_required?
+      customer.token_required?
+    end
+
+    def save!
+      raise 'is invalid' unless valid?
+
+      create_customer!
+      create_stripe_token!
+      save_subscription!
+      true
+    end
+
+    def destroy!
+      subscription = subscribable.subscription
+      return true if subscription.blank?
+
+      Rails.logger.info " -> [STRIPE] delete subscription"
+      subscription.stripe_subscription.delete
+      subscription.destroy!
+    end
+
+    protected
+
+    def create_customer!
+      customer.create_stripe_customer!
+    end
+
+    # Update stripe customer card
+    def create_stripe_token!
+      return if stripe_token.blank?
+
+      Rails.logger.info "[STRIPE] update source: #{stripe_token}"
+      customer.stripe_customer.source = stripe_token
+      customer.stripe_customer.save
+
+      return if customer.stripe_customer.default_source.blank?
+
+      card = customer.stripe_customer.sources.retrieve(customer.stripe_customer.default_source)
+      customer.active_card = "**** **** **** #{card.last4} #{card.brand} #{card.exp_month}/#{card.exp_year}"
+      customer.save!
+    end
+
+    def save_subscription!
+      return unless plan.present?
+
+      subscription.assign_attributes(stripe_plan_id: stripe_plan_id, quantity: quantity)
+
+      cancel_subscription!
+      create_subscription! || update_subscription!
+      true
+    end
+
+    def cancel_subscription!
+      return false unless subscription.persisted? && subscription.stripe_plan_id_changed?
+
+      item = items.first
+      stripe_item = subscription.stripe_subscription.items.first
+
+      return false unless stripe_item.present? && item[:plan] != stripe_item['plan']['id']
+
+      Rails.logger.info " -> [STRIPE] cancel plan: #{stripe_item['plan']['id']}"
+      subscription.stripe_subscription.delete
+      subscription.assign_attributes(stripe_subscription: nil, stripe_subscription_id: nil)
+
+      true
+    end
+
+    def create_subscription!
+      return false unless subscription.stripe_subscription.blank?
+
+      Rails.logger.info "[STRIPE] create subscription: #{items}"
+      stripe_subscription = Stripe::Subscription.create(customer: customer.stripe_customer_id, items: items, metadata: metadata)
+
+      subscription.update!(
+        stripe_subscription: stripe_subscription,
+        stripe_subscription_id: stripe_subscription.id,
+        status: stripe_subscription.status,
+        name: stripe_subscription.plan.nickname,
+        interval: stripe_subscription.plan.interval,
+        quantity: quantity
+      )
+    end
+
+    def update_subscription!
+      return false unless subscription.stripe_subscription.present?
+
+      stripe_item = subscription.stripe_subscription.items.first
+      item = items.first
+
+      return false unless stripe_item.present? && item[:plan] == stripe_item['plan']['id']
+      return false unless item[:quantity] != subscription.stripe_subscription.quantity
+
+      Rails.logger.info " -> [STRIPE] update plan: #{item[:plan]}"
+      stripe_item.quantity = item[:quantity]
+      stripe_item.save
+
+      subscription.update!(status: subscription.stripe_subscription.status)
+
+      # Invoice immediately
+      Rails.logger.info " -> [STRIPE] generate invoice"
+      Stripe::Invoice.create(customer: customer.stripe_customer_id).pay
+
+      true
+    end
+
+    private
+
+    def subscription
+      return nil unless subscribable
+      customer.subscriptions.find { |sub| sub.subscribable == subscribable } || customer.subscriptions.build(subscribable: subscribable, customer: customer)
+    end
+
+    def items
+      [{ plan: subscription.stripe_plan_id, quantity: subscription.quantity }]
+    end
+
+    # The stripe metadata limit is 500 characters
+    def metadata
+      {
+        :user_id => user.id.to_s,
+        :user => user.to_s.truncate(500),
+        (subscription.subscribable_type.downcase + '_id').to_sym => subscription.subscribable.id.to_s,
+        subscription.subscribable_type.downcase.to_sym => subscription.subscribable.to_s
+      }
+    end
+
+  end
+end

data/app/models/effective/subscription.rb

@@ -0,0 +1,95 @@
+module Effective
+  class Subscription < ActiveRecord::Base
+    self.table_name = EffectiveOrders.subscriptions_table_name.to_s
+
+    attr_accessor :stripe_subscription
+
+    belongs_to :customer, class_name: 'Effective::Customer', counter_cache: true
+    belongs_to :subscribable, polymorphic: true
+
+    # Attributes
+    # stripe_plan_id            :string
+    # stripe_subscription_id    :string
+    # name                      :string
+    # description               :string
+    # interval                  :string
+    # quantity                  :integer
+    #
+    # status                    :string
+    #
+    # timestamps
+
+    before_validation(if: -> { plan && (stripe_plan_id_changed? || new_record?) }) do
+      self.name = plan[:name]
+      self.description = plan[:description]
+    end
+
+    after_save do
+      subscribable.subscription_name = name if subscribable.respond_to?(:subscription_name=)
+      subscribable.subscription_description = description if subscribable.respond_to?(:subscription_description=)
+      subscribable.subscription_interval = interval if subscribable.respond_to?(:subscription_interval=)
+      subscribable.subscription_quantity = quantity if subscribable.respond_to?(:subscription_quantity=)
+      subscribable.subscription_status = status if subscribable.respond_to?(:subscription_status=)
+      subscribable.save!(validate: false)
+    end
+
+    after_destroy do
+      subscribable.subscription_name = nil if subscribable.respond_to?(:subscription_name=)
+      subscribable.subscription_description = nil if subscribable.respond_to?(:subscription_description=)
+      subscribable.subscription_interval = nil if subscribable.respond_to?(:subscription_interval=)
+      subscribable.subscription_quantity = nil if subscribable.respond_to?(:subscription_quantity=)
+      subscribable.subscription_status = nil if subscribable.respond_to?(:subscription_status=)
+      subscribable.save!(validate: false)
+    end
+
+    validates :customer, presence: true
+    validates :subscribable, presence: true
+
+    validates :stripe_plan_id, presence: true
+    validates :stripe_plan_id, inclusion: { in: EffectiveOrders.stripe_plans.map { |plan| plan[:id] } }
+
+    validates :stripe_subscription_id, presence: true
+
+    validates :name, presence: true
+    validates :interval, presence: true
+    validates :quantity, presence: true, numericality: { greater_than: 0 }
+
+    validates :status, inclusion: { in: EffectiveOrders::STATUSES.keys }
+
+    before_validation do
+      self.name ||= EffectiveOrders.stripe_plans.find { |plan| plan[:id] == stripe_plan_id }&[:name] || 'Subscribed Plan'
+    end
+
+    def to_s
+      name || 'New Subscription'
+    end
+
+    def plan
+      EffectiveOrders.stripe_plans.find { |plan| plan[:id] == stripe_plan_id }
+    end
+
+    def stripe_subscription
+      @stripe_subscription ||= if stripe_subscription_id.present?
+        Rails.logger.info "[STRIPE] get subscription: #{stripe_subscription_id}"
+        ::Stripe::Subscription.retrieve(stripe_subscription_id)
+      end
+    end
+
+    def <=>(other)
+      name.to_s <=> other&.name.to_s
+    end
+
+    def active?
+      status == 'active'
+    end
+
+    def past_due?
+      status == 'past_due'
+    end
+
+    def canceled?
+      status == 'canceled'
+    end
+
+  end
+end

data/app/models/effective/tax_rate_calculator.rb

@@ -0,0 +1,48 @@
+module Effective
+  class TaxRateCalculator
+    attr_reader :order, :country_code, :state_code
+
+    RATES = {
+      'CA' => {         # Canada
+        'AB' => 5.00,   # Alberta
+        'BC' => 5.00,   # British Columbia
+        'MB' => 5.00,   # Manitoba
+        'NB' => 15.0,   # New Brunswick
+        'NL' => 15.0,   # Newfoundland and Labrador
+        'NT' => 5.00,   # Northwest Territories
+        'NS' => 15.0,   # Nova Scotia
+        'ON' => 13.0,   # Ontario
+        'PE' => 15.0,   # Prince Edward Island
+        'QC' => 5.00,   # Quebec
+        'SK' => 5.00,   # Saskatchewan
+        'YT' => 5.00,   # Yukon Territory
+        'NU' => 5.00    # Nunavut
+      }
+    }
+
+    def initialize(order: nil, country_code: nil, state_code: nil)
+      @order = order
+      @country_code = country_code
+      @state_code = state_code
+
+      raise 'expected an order, or a country and state code' unless (order || country_code)
+      raise 'expected an order OR a country and state code. Not both.' if (order && country_code)
+    end
+
+    def tax_rate
+      country = country_code || (order.billing_address.country_code if order.billing_address.present?)
+      state = state_code || (order.billing_address.state_code if order.billing_address.present?)
+
+      rate = RATES[country]
+      return rate if rate.kind_of?(Numeric)
+      return unknown_tax_rate() if rate.nil?
+
+      rate[state].presence || unknown_tax_rate()
+    end
+
+    def unknown_tax_rate
+      (order && order.skip_buyer_validations?) ? nil : 0
+    end
+
+  end
+end

data/app/views/admin/customers/_actions.html.haml

@@ -0,0 +1,2 @@
+= dropdown(variation: :dropleft) do
+  = dropdown_link_to 'Manage',  "https://dashboard.stripe.com/#{'test/' if Rails.env.development?}customers/#{customer.stripe_customer_id}"

data/app/views/admin/customers/index.html.haml

@@ -0,0 +1,6 @@
+%h1.effective-admin-heading= @page_title
+
+%p.text-right.effective-admin-actions
+  = link_to 'Stripe Customers', "https://dashboard.stripe.com/#{'test/' if Rails.env.development?}customers", class: 'btn btn-primary'
+
+= render_datatable(@datatable)

data/app/views/admin/customers/show.html.haml

@@ -0,0 +1,6 @@
+%h1.effective-admin-heading= @page_title
+
+%p.text-right.effective-admin-actions
+  = link_to 'Stripe Customer', "https://dashboard.stripe.com/#{'test/' if Rails.env.development?}customers/#{@customer.stripe_customer_id}", class: 'btn btn-primary'
+
+= render 'effective/customers/customer', customer: @customer

data/app/views/admin/order_items/index.html.haml

@@ -0,0 +1,3 @@
+%h1.effective-admin-heading= @page_title
+
+= render_datatable(@datatable)