effective_orders 4.5.0

data/app/models/concerns/acts_as_purchasable.rb

@@ -0,0 +1,118 @@
+module ActsAsPurchasable
+  extend ActiveSupport::Concern
+
+  module Base
+    def acts_as_purchasable(*options)
+      @acts_as_purchasable = options || []
+
+      # if table_exists?
+      #   instance = new()
+      #   raise 'must respond_to price' unless instance.respond_to?(:price)
+      #   raise 'must respond_to purchased_order_id' unless instance.respond_to?(:purchased_order_id)
+
+      #   if defined?(EffectiveQbSync)
+      #     raise 'must respond to qb_item_name' unless instance.respond_to?(:qb_item_name)
+      #   end
+      # end
+
+      include ::ActsAsPurchasable
+    end
+  end
+
+  included do
+    belongs_to :purchased_order, class_name: 'Effective::Order', optional: true # Set when purchased
+
+    has_many :cart_items, as: :purchasable, dependent: :delete_all, class_name: 'Effective::CartItem'
+
+    has_many :order_items, as: :purchasable, class_name: 'Effective::OrderItem'
+    has_many :orders, -> { order(:id) }, through: :order_items, class_name: 'Effective::Order'
+
+    has_many :purchased_orders, -> { where(state: EffectiveOrders::PURCHASED).order(:purchased_at) },
+      through: :order_items, class_name: 'Effective::Order', source: :order
+
+    # Database max integer value is 2147483647.  So let's round that down and use a max/min of $20 million (2000000000)
+    validates :price, presence: true
+    validates :price, numericality: { less_than_or_equal_to: 2000000000, message: 'maximum price is $20,000,000' }
+    validates :price, numericality: { greater_than_or_equal_to: -2000000000, message: 'minimum price is -$20,000,000' }
+
+    validates :tax_exempt, inclusion: { in: [true, false] }
+
+    with_options(if: -> { quantity_enabled? }) do
+      validates :quantity_purchased, numericality: { allow_nil: true }
+      validates :quantity_max, numericality: { allow_nil: true }
+      validates_with Effective::SoldOutValidator, on: :create
+    end
+
+    scope :purchased, -> { where.not(purchased_order_id: nil) }
+    scope :not_purchased, -> { where(purchased_order_id: nil) }
+
+    # scope :purchased, -> { joins(order_items: :order).where(orders: {state: EffectiveOrders::PURCHASED}).distinct }
+    # scope :not_purchased, -> { where('id NOT IN (?)', purchased.pluck(:id).presence || [0]) }
+    scope :purchased_by, lambda { |user| joins(order_items: :order).where(orders: { user_id: user.try(:id), state: EffectiveOrders::PURCHASED }).distinct }
+    scope :not_purchased_by, lambda { |user| where('id NOT IN (?)', purchased_by(user).pluck(:id).presence || [0]) }
+  end
+
+  module ClassMethods
+    def before_purchase(&block)
+      send :define_method, :before_purchase do |order, order_item| self.instance_exec(order, order_item, &block) end
+    end
+
+    def after_purchase(&block)
+      send :define_method, :after_purchase do |order, order_item| self.instance_exec(order, order_item, &block) end
+    end
+
+    def after_decline(&block)
+      send :define_method, :after_decline do |order, order_item| self.instance_exec(order, order_item, &block) end
+    end
+  end
+
+  # Regular instance methods
+
+  # If I have a column type of Integer, and I'm passed a non-Integer, convert it here
+  def price=(value)
+    if value.kind_of?(Integer)
+      super
+    elsif value.kind_of?(String) && !value.include?('.') # Looks like an integer
+      super
+    else
+      raise 'expected price to be an Integer representing the number of cents.'
+    end
+  end
+
+  def purchasable_name
+    to_s
+  end
+
+  def tax_exempt
+    self[:tax_exempt] || false
+  end
+
+  def purchased?
+    purchased_order_id.present?
+  end
+
+  def purchased_at
+    purchased_order.try(:purchased_at)
+  end
+
+  def purchased_by?(user)
+    purchased_orders.any? { |order| order.user_id == user.id }
+  end
+
+  def purchased_download_url # Override me if this is a digital purchase.
+    false
+  end
+
+  def quantity_enabled?
+    false
+  end
+
+  def quantity_remaining
+    quantity_max - quantity_purchased if quantity_enabled?
+  end
+
+  def sold_out?
+    quantity_enabled? ? (quantity_remaining <= 0) : false
+  end
+
+end

data/app/models/concerns/acts_as_subscribable.rb

@@ -0,0 +1,90 @@
+module ActsAsSubscribable
+  extend ActiveSupport::Concern
+
+  mattr_accessor :descendants
+
+  module Base
+    def acts_as_subscribable(*options)
+      @acts_as_subscribable = options || []
+
+      # if table_exists?
+      #   instance = new()
+      #   raise 'must respond to trialing_until' unless instance.respond_to?(:trialing_until) || !EffectiveOrders.trial?
+      #   raise 'must respond to subscription_status' unless instance.respond_to?(:subscription_status)
+      # end
+
+      include ::ActsAsSubscribable
+      (ActsAsSubscribable.descendants ||= []) << self
+    end
+  end
+
+  included do
+    has_one :subscription, as: :subscribable, class_name: 'Effective::Subscription', inverse_of: :subscribable
+    has_one :customer, through: :subscription, class_name: 'Effective::Customer'
+
+    before_validation(if: -> { EffectiveOrders.trial? && trialing_until.blank? }) do
+      self.trialing_until = (Time.zone.now + EffectiveOrders.trial.fetch(:length)).beginning_of_day
+    end
+
+    before_destroy(if: -> { subscribed? }) do
+      raise :abort unless (subscripter.destroy! rescue false)
+    end
+
+    if EffectiveOrders.trial?
+      validates :trialing_until, presence: true
+    end
+
+    validates :subscription_status, inclusion: { allow_nil: true, in: EffectiveOrders::STATUSES.keys }
+
+    scope :trialing, -> { where(subscription_status: nil).where('trialing_until > ?', Time.zone.now) }
+    scope :trial_past_due, -> { where(subscription_status: nil).where('trialing_until < ?', Time.zone.now) }
+    scope :not_trialing, -> { where.not(subscription_status: nil) }
+
+    scope :subscribed, -> { where(subscription_status: EffectiveOrders::ACTIVE) }
+    scope :subscription_past_due, -> { where(subscription_status: EffectiveOrders::PAST_DUE) }
+    scope :not_subscribed, -> { where(subscription_status: nil) }
+  end
+
+  module ClassMethods
+  end
+
+  def subscripter
+    @_effective_subscripter ||= begin
+      Effective::Subscripter.new(subscribable: self, user: subscribable_buyer, quantity: subscription&.quantity, stripe_plan_id: subscription&.stripe_plan_id)
+    end
+  end
+
+  def subscribed?(stripe_plan_id = nil)
+    return false if subscription_status.blank?
+    stripe_plan_id ? (subscription&.stripe_plan_id == stripe_plan_id) : true
+  end
+
+  def subscription_active?
+    subscribed? && subscription_status == EffectiveOrders::ACTIVE
+  end
+
+  def subscription_past_due?
+    subscribed? && subscription_status == EffectiveOrders::PAST_DUE
+  end
+
+  def trialing?
+    subscription_status.blank?
+  end
+
+  def trial_active?
+    trialing? && trialing_until > Time.zone.now
+  end
+
+  def trial_past_due?
+    trialing? && trialing_until < Time.zone.now
+  end
+
+  def subscribable_buyer
+    raise 'acts_as_subscribable object requires the subscribable_buyer method be defined to return the User buying this item.'
+  end
+
+  def subscribable_quantity_used
+    raise 'acts_as_subscribable object requires the subscribable_quantity_used method be defined to determine how many are in use.'
+  end
+
+end

data/app/models/concerns/acts_as_subscribable_buyer.rb

@@ -0,0 +1,49 @@
+module ActsAsSubscribableBuyer
+  extend ActiveSupport::Concern
+
+  module Base
+    def acts_as_subscribable_buyer(*options)
+      include ::ActsAsSubscribableBuyer
+    end
+  end
+
+  included do
+    has_one :customer, class_name: 'Effective::Customer'
+
+    before_save(if: -> { persisted? && email_changed? && customer.present? }) do
+      Rails.logger.info "[STRIPE] update customer: #{customer.stripe_customer_id}"
+      customer.stripe_customer.email = email
+      customer.stripe_customer.description = to_s
+      throw :abort unless (customer.stripe_customer.save rescue false)
+    end
+  end
+
+  module ClassMethods
+    def after_invoice_payment_succeeded(&block)
+      send :define_method, :after_invoice_payment_succeeded do |event| self.instance_exec(event, &block) end
+    end
+
+    def after_invoice_payment_failed(&block)
+      send :define_method, :after_invoice_payment_failed do |event| self.instance_exec(event, &block) end
+    end
+
+    def after_customer_subscription_created(&block)
+      send :define_method, :after_customer_subscription_created do |event| self.instance_exec(event, &block) end
+    end
+
+    def after_customer_subscription_updated(&block)
+      send :define_method, :after_customer_subscription_updated do |event| self.instance_exec(event, &block) end
+    end
+
+    def after_customer_subscription_deleted(&block)
+      send :define_method, :after_customer_subscription_deleted do |event| self.instance_exec(event, &block) end
+    end
+
+    def after_customer_updated(&block)
+      send :define_method, :after_customer_updated do |event| self.instance_exec(event, &block) end
+    end
+
+  end
+
+end
+

data/app/models/effective/access_denied.rb

@@ -0,0 +1,17 @@
+unless defined?(Effective::AccessDenied)
+  module Effective
+    class AccessDenied < StandardError
+      attr_reader :action, :subject
+
+      def initialize(message = nil, action = nil, subject = nil)
+        @message = message
+        @action = action
+        @subject = subject
+      end
+
+      def to_s
+        @message || I18n.t(:'unauthorized.default', :default => 'Access Denied')
+      end
+    end
+  end
+end

data/app/models/effective/cart.rb

@@ -0,0 +1,88 @@
+module Effective
+  class Cart < ActiveRecord::Base
+    self.table_name = EffectiveOrders.carts_table_name.to_s
+
+    belongs_to :user, optional: true    # Optional. We want non-logged-in users to have carts too.
+    has_many :cart_items, -> { order(:id) }, dependent: :delete_all, class_name: 'Effective::CartItem'
+
+    accepts_nested_attributes_for :cart_items
+
+    # Attributes
+    # cart_items_count        :integer
+    # timestamps
+
+    scope :deep, -> { includes(cart_items: :purchasable) }
+
+    # cart.add(@product, unique: -> (a, b) { a.kind_of?(Product) && b.kind_of?(Product) && a.category == b.category })
+    # cart.add(@product, unique: :category)
+    # cart.add(@product, unique: false) # Add as many as you want
+    def add(item, quantity: 1, unique: true)
+      raise 'expecting an acts_as_purchasable object' unless item.kind_of?(ActsAsPurchasable)
+
+      existing = (
+        if unique.kind_of?(Proc)
+          cart_items.find { |cart_item| instance_exec(item, cart_item.purchasable, &unique) }
+        elsif unique.kind_of?(Symbol) || (unique.kind_of?(String) && unique != 'true')
+          raise "expected item to respond to unique #{unique}" unless item.respond_to?(unique)
+          cart_items.find { |cart_item| cart_item.purchasable.respond_to?(unique) && item.send(unique) == cart_item.purchasable.send(unique) }
+        elsif unique.present?
+          find(item)
+        end
+      )
+
+      if existing
+        if unique || (existing.unique.present?)
+          existing.assign_attributes(purchasable: item, quantity: quantity, unique: existing.unique)
+        else
+          existing.quantity = existing.quantity + quantity
+        end
+      end
+
+      if item.quantity_enabled? && (existing ? existing.quantity : quantity) > item.quantity_remaining
+        raise EffectiveOrders::SoldOutException, "#{item.purchasable_name} is sold out"
+      end
+
+      existing ||= cart_items.build(purchasable: item, quantity: quantity, unique: (unique.to_s unless unique.kind_of?(Proc)))
+      save!
+    end
+
+    def clear!
+      cart_items.each { |cart_item| cart_item.mark_for_destruction }
+      cart_items.present? ? save! : true
+    end
+
+    def remove(item)
+      find(item).try(:mark_for_destruction)
+      save!
+    end
+
+    def includes?(item)
+      find(item).present?
+    end
+
+    def find(item)
+      cart_items.find { |cart_item| cart_item == item || cart_item.purchasable == item }
+    end
+
+    def purchasables
+      cart_items.map { |cart_item| cart_item.purchasable }
+    end
+
+    def size
+      cart_items_count || cart_items.length
+    end
+
+    def present?
+      size > 0
+    end
+
+    def blank?
+      size <= 0
+    end
+
+    def subtotal
+      cart_items.map { |ci| ci.subtotal }.sum
+    end
+
+  end
+end

data/app/models/effective/cart_item.rb

@@ -0,0 +1,40 @@
+module Effective
+  class CartItem < ActiveRecord::Base
+    self.table_name = EffectiveOrders.cart_items_table_name.to_s
+
+    belongs_to :cart, counter_cache: true, class_name: 'Effective::Cart'
+    belongs_to :purchasable, polymorphic: true
+
+    # Attributes
+    # quantity    :integer
+    # timestamps
+
+    validates :purchasable, presence: true
+    validates :quantity, presence: true
+
+    def to_s
+      name || 'New Cart Item'
+    end
+
+    def name
+      purchasable&.purchasable_name
+    end
+
+    def price
+      if (purchasable.price || 0).kind_of?(Integer)
+        purchasable.price || 0
+      else
+        raise 'expected price to be an Integer representing the number of cents.'
+      end
+    end
+
+    def tax_exempt
+      purchasable&.tax_exempt || false
+    end
+
+    def subtotal
+      price * quantity
+    end
+
+  end
+end

data/app/models/effective/customer.rb

@@ -0,0 +1,92 @@
+module Effective
+  class Customer < ActiveRecord::Base
+    self.table_name = EffectiveOrders.customers_table_name.to_s
+
+    attr_accessor :stripe_customer
+
+    belongs_to :user
+    has_many :subscriptions, -> { includes(:subscribable) }, class_name: 'Effective::Subscription', foreign_key: 'customer_id'
+    accepts_nested_attributes_for :subscriptions
+
+    # Attributes
+    # stripe_customer_id            :string  # cus_xja7acoa03
+    # payment_method_id             :string  # Last payment method used
+    # active_card                   :string  # **** **** **** 4242 Visa 05/12
+
+    # timestamps
+
+    scope :deep, -> { includes(subscriptions: :subscribable) }
+
+    validates :user, presence: true
+    validates :stripe_customer_id, presence: true
+
+    def self.for_user(user)
+      Effective::Customer.where(user: user).first_or_initialize
+    end
+
+    def to_s
+      user.to_s.presence || 'New Customer'
+    end
+
+    def email
+      user.email if user
+    end
+
+    def create_stripe_customer!
+      return if stripe_customer.present?
+      raise('expected a user') unless user.present?
+
+      Rails.logger.info "[STRIPE] create customer: #{user.email}"
+
+      self.stripe_customer = Stripe::Customer.create(email: user.email, description: user.to_s, metadata: { user_id: user.id })
+      self.stripe_customer_id = stripe_customer.id
+
+      save!
+    end
+
+    def stripe_customer
+      @stripe_customer ||= if stripe_customer_id.present?
+        Rails.logger.info "[STRIPE] get customer: #{stripe_customer_id}"
+        ::Stripe::Customer.retrieve(stripe_customer_id)
+      end
+    end
+
+    def invoices
+      @invoices ||= if stripe_customer_id.present?
+        Rails.logger.info "[STRIPE] list invoices: #{stripe_customer_id}"
+        ::Stripe::Invoice.list(customer: stripe_customer_id) rescue nil
+      end
+    end
+
+    def upcoming_invoice
+      @upcoming_invoice ||= if stripe_customer_id.present?
+        Rails.logger.info "[STRIPE] get upcoming invoice: #{stripe_customer_id}"
+        ::Stripe::Invoice.upcoming(customer: stripe_customer_id) rescue nil
+      end
+    end
+
+    def token_required?
+      active_card.blank? || past_due?
+    end
+
+    def past_due?
+      subscriptions.any? { |subscription| subscription.past_due? }
+    end
+
+    def active?
+      subscriptions.present? && subscriptions.all? { |subscription| subscription.active? }
+    end
+
+    def payment_status
+      if past_due?
+        'We ran into an error processing your last payment. Please update or confirm your card details to continue.'
+      elsif active?
+        "Your payment is in good standing. Thanks so much for your support!"
+      elsif active_card.blank?
+        'No credit card on file. Please add a card.'
+      else
+        'Please update or confirm your card details to continue.'
+      end.html_safe
+    end
+  end
+end