effective_orders 2.2.4 → 3.0.0

data/app/models/concerns/acts_as_purchasable.rb

@@ -12,10 +12,14 @@ module ActsAsPurchasable
   end
 
   included do
-    has_many :orders, through: :order_items, class_name: 'Effective::Order'
-    has_many :order_items, as: :purchasable, class_name: 'Effective::OrderItem'
     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(purchase_state: EffectiveOrders::PURCHASED).order(:purchased_at) },
+      through: :order_items, class_name: 'Effective::Order', source: :order
+
     validates_with Effective::SoldOutValidator, on: :create
 
     # Database max integer value is 2147483647.  So let's round that down and use a max/min of $20 million (2000000000)
@@ -24,8 +28,8 @@ module ActsAsPurchasable
     validates :tax_exempt, inclusion: { in: [true, false] }
 
     # These are breaking on the check for quanitty_enabled?.  More research is due
-    validates :quantity_purchased, numericality: {allow_nil: true}, if: proc { |purchasable| (purchasable.quantity_enabled? rescue false) }
-    validates :quantity_max, numericality: {allow_nil: true}, if: proc { |purchasable| (purchasable.quantity_enabled? rescue false) }
+    validates :quantity_purchased, numericality: { allow_nil: true }, if: proc { |purchasable| (purchasable.quantity_enabled? rescue false) }
+    validates :quantity_max, numericality: { allow_nil: true }, if: proc { |purchasable| (purchasable.quantity_enabled? rescue false) }
 
     scope :purchased, -> { joins(order_items: :order).where(orders: {purchase_state: EffectiveOrders::PURCHASED}).distinct }
     scope :purchased_by, lambda { |user| joins(order_items: :order).where(orders: {user_id: user.try(:id), purchase_state: EffectiveOrders::PURCHASED}).distinct }
@@ -37,6 +41,10 @@ module ActsAsPurchasable
   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
@@ -54,16 +62,12 @@ module ActsAsPurchasable
 
   # If I have a column type of Integer, and I'm passed a non-Integer, convert it here
   def price=(value)
-    integer_column = ((column_for_attribute('price').try(:type) rescue nil) == :integer) # Rails built in method to lookup datatype
-
-    if integer_column == false
-      super
-    elsif value.kind_of?(Integer)
+    if value.kind_of?(Integer)
       super
     elsif value.kind_of?(String) && !value.include?('.') # Looks like an integer
       super
-    else # Could be Float, BigDecimal, or String like 9.99
-      super((value.to_f * 100.0).to_i)
+    else
+      raise 'expected price to be an Integer representing the number of cents.'
     end
   end
 
@@ -77,28 +81,24 @@ module ActsAsPurchasable
 
   def seller
     if EffectiveOrders.stripe_connect_enabled
-      raise 'acts_as_purchasable object requires the seller be defined to return the User selling this item.  This is only a requirement when using StripeConnect.'
+      raise 'acts_as_purchasable object requires the seller be defined to return the User selling this item. This is only a requirement when using StripeConnect.'
     end
   end
 
-  def purchased?
-    @is_purchased ||= orders.any? { |order| order.purchased? }
+  def purchased_order
+    @purchased_order ||= purchased_orders.first
   end
 
-  def purchased_at
-    @purchased_at ||= orders.map { |order| order.purchased_at if order.purchased? }.compact.sort.first
+  def purchased?
+    @is_purchased ||= purchased_order.present?
   end
 
   def purchased_by?(user)
-    orders.any? { |order| order.purchased? && order.user_id == user.id }
+    purchased_orders.any? { |order| order.user_id == user.id }
   end
 
-  def purchased_orders
-    orders.select { |order| order.purchased? }
-  end
-
-  def purchased_order
-    purchased_orders.first
+  def purchased_at
+    purchased_order.try(:purchased_at)
   end
 
   def quantity_enabled?
@@ -113,16 +113,6 @@ module ActsAsPurchasable
     quantity_enabled? ? (quantity_remaining == 0) : false
   end
 
-  def purchased!(order = nil, order_item = nil)
-    after_purchase(order, order_item) if self.respond_to?(:after_purchase)
-    save!
-  end
-
-  def declined!(order = nil, order_item = nil)
-    after_decline(order, order_item) if self.respond_to?(:after_decline)
-    save!
-  end
-
   # Override me if this is a digital purchase.
   def purchased_download_url
     false

data/app/models/concerns/acts_as_subscribable.rb

@@ -0,0 +1,68 @@
+module ActsAsSubscribable
+  extend ActiveSupport::Concern
+
+  mattr_accessor :descendants
+
+  module ActiveRecord
+    def acts_as_subscribable(*options)
+      @acts_as_subscribable = options || []
+      include ::ActsAsSubscribable
+      (ActsAsSubscribable.descendants ||= []) << self
+    end
+  end
+
+  included do
+    has_one :subscription, as: :subscribable, class_name: 'Effective::Subscription'
+    has_one :customer, through: :subscription, class_name: 'Effective::Customer'
+
+    validates :subscripter, associated: true
+
+    scope :subscribed, -> { where(id: joins(:subscription)) }  # All resources with a subscription
+    scope :trialing, -> { where.not(id: joins(:subscription)) } # All resources without a subscription
+  end
+
+  module ClassMethods
+  end
+
+  def subscripter
+    @_effective_subscripter ||= Effective::Subscripter.new(subscribable: self, user: buyer)
+  end
+
+  def subscripter=(atts)
+    subscripter.assign_attributes(atts)
+  end
+
+  def subscribed?(stripe_plan_id = nil)
+    case stripe_plan_id
+    when nil
+      subscription.present?  # Subscribed to any subscription?
+    when (EffectiveOrders.stripe_plans['trial'] || {})[:id]
+      subscription.blank? || subscription.new_record? || subscription.stripe_plan_id == stripe_plan_id
+    else
+      subscription && subscription.persisted? && subscription.errors.blank? && subscription.stripe_plan_id == stripe_plan_id
+    end
+  end
+
+  def subscription_active?
+    (trialing? && !trial_expired?) || (subscribed? && subscription.active?)
+  end
+
+  def trialing?
+    !subscribed?
+  end
+
+  def trial_expired?
+    trialing? && Time.zone.now > trial_expires_at
+  end
+
+  def trial_expires_at
+    # The rake task send_trial_expiring_emails depends on this beginning_of_day
+    ((created_at || Time.zone.now) + EffectiveOrders.subscription[:trial_period]).beginning_of_day
+  end
+
+  def buyer
+    raise 'acts_as_subscribable object requires the buyer be defined to return the User buying this item.'
+  end
+
+end
+

data/app/models/concerns/acts_as_subscribable_buyer.rb

@@ -0,0 +1,22 @@
+module ActsAsSubscribableBuyer
+  extend ActiveSupport::Concern
+
+  module ActiveRecord
+    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 CUSTOMER EMAIL UPDATE: #{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
+
+end
+

data/app/models/effective/cart.rb

@@ -2,58 +2,87 @@ module Effective
   class Cart < ActiveRecord::Base
     self.table_name = EffectiveOrders.carts_table_name.to_s
 
-    belongs_to :user    # This is optional.  We want to let non-logged-in people have carts too
-    has_many :cart_items, :inverse_of => :cart, :dependent => :delete_all
+    belongs_to :user    # Optional. We want non-logged-in users to have carts too.
+    has_many :cart_items, -> { includes(:purchasable).order(:updated_at) }, dependent: :delete_all, class_name: 'Effective::CartItem'
 
-    # structure do
-    #   timestamps
-    # end
+    accepts_nested_attributes_for :cart_items
 
-    default_scope -> { includes(:cart_items => :purchasable) }
+    # Attributes
+    # cart_items_count        :integer
+    # timestamps
 
-    def add(item, quantity: 1)
+    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_item = cart_items.where(purchasable_id: item.id, purchasable_type: item.class.name).first
+      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 item.quantity_enabled? && (quantity + (existing_item.quantity rescue 0)) > item.quantity_remaining
-        raise EffectiveOrders::SoldOutException, "#{item.title} is sold out"
-        return
+      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 existing_item.present?
-        existing_item.update_attributes(quantity: existing_item.quantity + quantity)
-      else
-        cart_items.create(cart: self, purchasable_id: item.id, purchasable_type: item.class.name, quantity: quantity)
+      if item.quantity_enabled? && (existing ? existing.quantity : quantity) > item.quantity_remaining
+        raise EffectiveOrders::SoldOutException, "#{item.title} is sold out"
       end
+
+      existing ||= cart_items.build(purchasable: item, quantity: quantity, unique: (unique.to_s if unique.kind_of?(Symbol) || unique.kind_of?(String) || unique == true))
+      save!
+    end
+
+    def clear!
+      cart_items.each { |cart_item| cart_item.mark_for_destruction }
+      save!
     end
-    alias_method :add_to_cart, :add
 
-    def remove(obj)
-      (cart_items.find(cart_item) || cart_item).try(:destroy)
+    def remove(item)
+      find(item).try(:mark_for_destruction)
+      save!
     end
-    alias_method :remove_from_cart, :remove
 
     def includes?(item)
       find(item).present?
     end
 
     def find(item)
-      cart_items.to_a.find { |cart_item| cart_item == item || cart_item.purchasable == 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.size
+      cart_items_count || cart_items.length
+    end
+
+    def present?
+      size > 0
     end
 
-    def empty?
-      size == 0
+    def blank?
+      size <= 0
     end
 
     def subtotal
       cart_items.map { |ci| ci.subtotal }.sum
     end
-    alias_method :total, :subtotal
 
   end
 end

data/app/models/effective/cart_item.rb

@@ -2,26 +2,21 @@ module Effective
   class CartItem < ActiveRecord::Base
     self.table_name = EffectiveOrders.cart_items_table_name.to_s
 
-    belongs_to :cart
-    belongs_to :purchasable, :polymorphic => true
+    belongs_to :cart, counter_cache: true, class_name: 'Effective::Cart'
+    belongs_to :purchasable, polymorphic: true
 
-    # structure do
-    #   quantity    :integer
-    #
-    #   timestamps
-    # end
+    # Attributes
+    # quantity    :integer
+    # timestamps
 
     validates :purchasable, presence: true
     validates :quantity, presence: true
 
-    default_scope -> { order(:updated_at) }
-
     def price
       if (purchasable.price || 0).kind_of?(Integer)
         purchasable.price || 0
       else
-        ActiveSupport::Deprecation.warn('price is a non-integer. It should be an Integer representing the number of cents.  Continuing with (price * 100.0).round(0).to_i conversion') unless EffectiveOrders.silence_deprecation_warnings
-        (purchasable.price * 100.0).round(0).to_i rescue 0
+        raise 'expected price to be an Integer representing the number of cents.'
       end
     end
 
@@ -36,7 +31,6 @@ module Effective
     def subtotal
       price * quantity
     end
-    alias_method :total, :subtotal
 
   end
 end

data/app/models/effective/customer.rb

@@ -2,83 +2,80 @@ module Effective
   class Customer < ActiveRecord::Base
     self.table_name = EffectiveOrders.customers_table_name.to_s
 
-    attr_accessor :token # This is a convenience method so we have a place to store StripeConnect temporary access tokens
+    attr_accessor :stripe_token # This is a convenience method so we have a place to store StripeConnect temporary access tokens
+    attr_accessor :stripe_customer, :stripe_subscription
 
     belongs_to :user
-    has_many :subscriptions, :inverse_of => :customer
+    has_many :subscriptions, class_name: 'Effective::Subscription', foreign_key: 'customer_id'
+    has_many :subscribables, through: :subscriptions, source: :subscribable
 
-    # structure do
-    #   stripe_customer_id            :string  # cus_xja7acoa03
-    #   stripe_active_card            :string  # **** **** **** 4242 Visa 05/12
-    #   stripe_connect_access_token   :string  # If using StripeConnect and this user is a connected Seller
+    accepts_nested_attributes_for :subscriptions
+
+    # Attributes
+    # stripe_customer_id            :string  # cus_xja7acoa03
+    # active_card                   :string  # **** **** **** 4242 Visa 05/12
+
+    # stripe_subscription_id        :string  # Each user gets one stripe subscription object, which can contain many items
+    # status                        :string
+
+    # stripe_connect_access_token   :string  # If using StripeConnect and this user is a connected Seller
     #
-    #   timestamps
-    # end
+    # timestamps
+
+    scope :deep, -> { includes(subscriptions: :subscribable) }
+
+    before_validation do
+      subscriptions.each { |subscription| subscription.status = status }
+    end
 
     validates :user, presence: true
-    validates :user_id, uniqueness: true
+    validates :stripe_customer_id, presence: true
+    validates :status, if: -> { stripe_subscription_id.present? }, inclusion: { in: %w(active past_due) }
 
-    scope :customers, -> { where("#{EffectiveOrders.customers_table_name.to_s}.stripe_customer_id IS NOT NULL") }
+    def self.for_user(user)
+      Effective::Customer.where(user: user).first_or_initialize
+    end
 
-    class << self
-      def for_user(user)
-        if user.present?
-          Effective::Customer.where(:user_id => (user.try(:id) rescue user.to_i)).first_or_create
-        end
-      end
+    def to_s
+      user.to_s.presence || 'New Customer'
     end
 
     def stripe_customer
       @stripe_customer ||= if stripe_customer_id.present?
+        Rails.logger.info "STRIPE CUSTOMER RETRIEVE: #{stripe_customer_id}"
         ::Stripe::Customer.retrieve(stripe_customer_id)
-      else
-        ::Stripe::Customer.create(:email => user.email, :description => user.id.to_s).tap do |stripe_customer|
-          self.update_attributes(:stripe_customer_id => stripe_customer.id)
-        end
       end
     end
 
-    def update_card!(token)
-      if token.present? # Oh, so they want to use a new credit card...
-        if stripe_customer.respond_to?(:cards)
-          stripe_customer.card = token  # This sets the default_card to the new card
-        elsif stripe_customer.respond_to?(:sources)
-          stripe_customer.source = token
-        end
-
-        if stripe_customer.save && default_card.present?
-          card = cards.retrieve(default_card)
-
-          self.stripe_active_card = "**** **** **** #{card.last4} #{card.brand} #{card.exp_month}/#{card.exp_year}"
-          self.save!
-        else
-          raise Exception.new('unable to update stripe customer with new card')
-        end
+    def stripe_subscription
+      @stripe_subscription ||= if stripe_subscription_id.present?
+        Rails.logger.info "STRIPE SUBSCRIPTION RETRIEVE: #{stripe_subscription_id}"
+        ::Stripe::Subscription.retrieve(stripe_subscription_id)
       end
     end
 
-    def is_stripe_connect_seller?
-      stripe_connect_access_token.present?
+    def upcoming_invoice
+      @upcoming_invoice ||= if stripe_customer_id.present? && stripe_subscription_id.present?
+        Rails.logger.info "STRIPE UPCOMING INVOICE RETRIEVE: #{stripe_customer_id}"
+        ::Stripe::Invoice.upcoming(customer: stripe_customer_id) rescue nil
+      end
     end
 
-    private
-
-    def default_card
-      case
-      when stripe_customer.respond_to?(:default_card)
-        stripe_customer.default_card
-      when stripe_customer.respond_to?(:default_source)
-        stripe_customer.default_source
-      end
+    def token_required?
+      active_card.blank? || (active_card.present? && stripe_subscription_id.present? && status != 'active')
     end
 
-    def cards
-      case
-      when stripe_customer.respond_to?(:cards)
-        stripe_customer.cards
-      when stripe_customer.respond_to?(:sources)
-        stripe_customer.sources
-      end
+    def payment_status
+      if status == 'past_due'
+        'We ran into an error processing your last payment. Please update or confirm your card details to continue.'
+      elsif active_card.present? && token_required?
+        'Please update or confirm your card details to continue.'
+      elsif active_card.present?
+        'Thanks for your support! The card we have on file is'
+      else
+        'No credit card on file. Please add a card.'
+      end.html_safe
     end
+
   end
 end