effective_orders 2.2.4 → 3.0.0

data/app/models/effective/order_item.rb

@@ -2,34 +2,32 @@ module Effective
   class OrderItem < ActiveRecord::Base
     self.table_name = EffectiveOrders.order_items_table_name.to_s
 
-    belongs_to :order
-    belongs_to :purchasable, :polymorphic => true
-    belongs_to :seller, :class_name => 'User'
+    belongs_to :order, class_name: 'Effective::Order'
+    belongs_to :purchasable, polymorphic: true
+    belongs_to :seller, class_name: 'User'
 
-    delegate :purchased_download_url, :to => :purchasable
-    delegate :purchased?, :declined?, :to => :order
+    delegate :purchased_download_url, to: :purchasable
+    delegate :purchased?, :declined?, to: :order
 
-    # structure do
-    #   title                 :string
-    #   quantity              :integer
-    #   price                 :integer, default: 0
-    #   tax_exempt            :boolean
-    #
-    #   timestamps
-    # end
+    # Attributes
+    # title                 :string
+    # quantity              :integer
+    # price                 :integer, default: 0
+    # tax_exempt            :boolean
+    # timestamps
 
     validates :purchasable, associated: true, presence: true
     accepts_nested_attributes_for :purchasable, allow_destroy: false, reject_if: :all_blank, update_only: true
 
     validates :title, presence: true
     validates :quantity, presence: true, numericality: { greater_than: 0 }
-    validates :price, numericality: true
+    validates :price, presence: true
     validates :tax_exempt, inclusion: { in: [true, false] }
 
-    validates :seller_id, presence: true, if: Proc.new { |order_item| EffectiveOrders.stripe_connect_enabled }
+    validates :seller_id, presence: true, if: -> { EffectiveOrders.stripe_connect_enabled }
 
-    scope :sold, -> { joins(:order).where(:orders => {:purchase_state => EffectiveOrders::PURCHASED}) }
-    scope :sold_by, lambda { |user| sold().where(:seller_id => user.try(:id)) }
+    scope :sold, -> { joins(:order).where(orders: { purchase_state: EffectiveOrders::PURCHASED }) }
+    scope :sold_by, lambda { |user| sold().where(seller_id: user.id) }
 
     def to_s
       (quantity || 0) > 1 ? "#{quantity}x #{title}" : title
@@ -57,8 +55,7 @@ module Effective
       elsif value.kind_of?(String) && !value.include?('.') # Looks like an integer
         super
       else # Could be Float, BigDecimal, or String like 9.99
-        ActiveSupport::Deprecation.warn('order_item.price= was passed a non-integer. Expecting an Integer representing the number of cents.  Continuing with (price * 100.0).round(0).to_i conversion') unless EffectiveOrders.silence_deprecation_warnings
-        super((value.to_f * 100.0).to_i)
+        raise 'expected price to be an Integer representing the number of cents.'
       end
     end
 
@@ -66,13 +63,13 @@ module Effective
     # And is the Customer representing who is selling the product
     # This is really only used for StripeConnect
     def seller
-      @seller ||= Effective::Customer.for_user(purchasable.try(:seller))
+      @seller ||= Effective::Customer.for_buyer(purchasable.seller)
     end
 
     def stripe_connect_application_fee
       @stripe_connect_application_fee ||= (
         self.instance_exec(self, &EffectiveOrders.stripe_connect_application_fee_method).to_i.tap do |fee|
-          raise ArgumentError.new("expected EffectiveOrders.stripe_connect_application_fee_method to return a value between 0 and the order_item total (#{self.total}).  Received #{fee}.") if (fee > total || fee < 0)
+          raise "expected EffectiveOrders.stripe_connect_application_fee_method to return a value between 0 and the order_item total (#{self.total}). Received #{fee}." if (fee > total || fee < 0)
         end
       )
     end

data/app/models/effective/product.rb

@@ -4,16 +4,16 @@ module Effective
 
     acts_as_purchasable
 
-    # structure do
-    #   title         :string
-    #   price         :integer, default: 0
-    #   tax_exempt    :boolean, default: false
+    # Attributes
+    # title         :string
+    # price         :integer, default: 0
+    # tax_exempt    :boolean, default: false
     #
-    #   timestamps
-    # end
+    # timestamps
 
     validates :title, presence: true
-    validates :price, numericality: { greater_than: 0 }
+    validates :price, presence: true
+    validates :tax_exempt, inclusion: { in: [true, false] }
 
     def to_s
       self[:title] || 'New Product'

data/app/models/effective/providers/ccbill_postback.rb

@@ -20,7 +20,7 @@ class Effective::Providers::CcbillPostback
 
   def denial?
     # denialId is for subscriptions only
-    [:reasonForDeclineCode, :reasonForDecline, :denialId].any? {|key| params[key].present?}
+    [:reasonForDeclineCode, :reasonForDecline, :denialId].any? { |key| params[key].present? }
   end
 
   def order_details

data/app/models/effective/providers/stripe_charge.rb

@@ -1,34 +1,23 @@
 # This is an object for the stripe charge form
 module Effective::Providers
   class StripeCharge
-    extend ActiveModel::Naming
-    include ActiveModel::Conversion
-    include ActiveModel::Validations
-    include ActiveRecord::Reflection
+    include ActiveModel::Model
 
-    attr_accessor :effective_order_id, :order, :token # For our form
+    attr_accessor :effective_order_id, :order, :stripe_token # For our form
 
-    validates_presence_of :effective_order_id, :token
-
-    def initialize(params = {})
-      if params.kind_of?(Effective::Order)
-        @order = params
-        @effective_order_id = params.to_param
-      else
-        params.each { |k, v| self.send("#{k}=", v) if self.respond_to?("#{k}=") }
-      end
-    end
+    validates :effective_order_id, presence: true
+    validates :stripe_token, presence: true
 
     def persisted?
       false
     end
 
-    def order_items
-      order.order_items.reject { |order_item| order_item.purchasable.kind_of?(Effective::Subscription) }
+    def effective_order_id
+      @effective_order_id || (order.to_param if order)
     end
 
-    def subscriptions
-      order.order_items.select { |order_item| order_item.purchasable.kind_of?(Effective::Subscription) }.map(&:purchasable)
+    def order_items
+      order.order_items if order
     end
 
   end

data/app/models/effective/subscripter.rb

@@ -0,0 +1,230 @@
+# Form object to select a plan, and build the correct subscription and customer
+
+module Effective
+  class Subscripter
+    include ActiveModel::Model
+
+    attr_accessor :user, :subscribable, :customer
+    attr_accessor :stripe_plan_id, :stripe_token
+
+    validates :user, presence: true
+    validates :subscribable, presence: true, if: -> { stripe_plan_id }
+    validates :stripe_plan_id, inclusion: { allow_blank: true, in: EffectiveOrders.stripe_plans.keys, message: 'unknown plan' }
+
+    validate(if: -> { stripe_plan_id && plan && subscribable }) do
+      if plan[:amount] > 0 && stripe_token.blank? && token_required?
+        self.errors.add(:stripe_token, 'updated payment card required')
+        customer.errors.add(:stripe_token, 'updated payment card required')
+      end
+    end
+
+    validate(if: -> { subscribable }) do
+      subscribable.errors.add(:subscripter, errors.messages.values.flatten.to_sentence) if self.errors.present?
+    end
+
+    def customer
+      @customer ||= Effective::Customer.deep.where(user: user).first_or_initialize
+    end
+
+    def current_plan
+      return nil unless subscribable
+      subscribable.subscription.blank? ? EffectiveOrders.stripe_plans['trial'] : subscribable.subscription.plan
+    end
+
+    def plan
+      EffectiveOrders.stripe_plans[stripe_plan_id]
+    end
+
+    def token_required?
+      customer.token_required?
+    end
+
+    def save!
+      return true if (plan == current_plan) && stripe_token.blank?  # No work to do
+
+      raise 'is invalid' unless valid?
+
+      begin
+        build! && sync! && customer.save!
+      rescue => e
+        reload!
+
+        self.errors.add(:base, e.message)
+        raise e
+      end
+    end
+
+    def subscribe!(stripe_plan_id)
+      self.stripe_plan_id = stripe_plan_id
+      save!
+    end
+
+    def destroy!
+      return true unless subscription && subscription.persisted? && customer.stripe_subscription.present?
+
+      raise 'is invalid' unless valid?
+
+      subscription.destroy!
+      customer.subscriptions.reload
+
+      sync! && customer.save!
+    end
+
+    def reload!
+      @stripe_token = nil
+      @stripe_plan_id = nil
+      @customer = nil
+      @subscription = nil
+    end
+
+    private
+
+    def subscription
+      return nil unless subscribable
+      @subscription ||= (
+        customer.subscriptions.find { |sub| sub.subscribable == subscribable } ||
+        customer.subscriptions.build(subscribable: subscribable, customer: customer)
+      )
+    end
+
+    def build!
+      # Check for an existing customer created within the last hour with this email
+      # This catches an edge case in which a stripe customer is created twice when a first time customer is using a declined card
+      if customer.stripe_customer.blank?
+        Rails.logger.info "STRIPE CUSTOMER CHECK FOR EXISTING: #{user.email}"
+
+        customers = Stripe::Customer.list(created: { gt: (user.created_at - 1.hour).to_i } ).data
+
+        if (existing = customers.find { |cus| cus.email == user.email && (cus.metadata || {})[:user_id] == user.id.to_s })
+          customer.stripe_customer = existing
+          customer.stripe_customer_id = existing.id
+        end
+      end
+
+      # Create customer
+      if customer.stripe_customer.blank?
+        Rails.logger.info "STRIPE CUSTOMER CREATE: #{user.email}"
+        customer.stripe_customer = Stripe::Customer.create(email: user.email, description: user.to_s, metadata: { user_id: user.id })
+        customer.stripe_customer_id = customer.stripe_customer.id
+      end
+
+      # Update stripe customer card
+      if stripe_token.present?
+        Rails.logger.info "STRIPE CUSTOMER SOURCE UPDATE #{stripe_token}"
+        customer.stripe_customer.source = stripe_token
+        customer.stripe_customer.save
+
+        if customer.stripe_customer.default_source.present?
+          card = customer.stripe_customer.sources.retrieve(customer.stripe_customer.default_source)
+          customer.active_card = "**** **** **** #{card.last4} #{card.brand} #{card.exp_month}/#{card.exp_year}"
+        end
+      end
+
+      # Assign stripe plan
+      if plan
+        subscription.stripe_plan_id = plan[:id]
+
+        # Ensure stripe subscription exists
+        if customer.stripe_subscription.blank?
+          Rails.logger.info "STRIPE SUBSCRIPTION CREATE: #{items(metadata: false)}"
+          customer.stripe_subscription = Stripe::Subscription.create(customer: customer.stripe_customer_id, items: items(metadata: false), metadata: metadata)
+          customer.stripe_subscription_id = customer.stripe_subscription.id
+        end
+      end
+
+      true
+    end
+
+    def sync!
+      return true unless plan && customer.stripe_subscription
+
+      Rails.logger.info "STRIPE SUBSCRIPTION SYNC: #{customer.stripe_subscription_id} #{items}"
+
+      if items.length == 0
+        customer.stripe_subscription.delete
+        customer.stripe_subscription_id = nil
+        customer.status = nil
+        return true
+      end
+
+      # Update stripe subscription items
+      customer.stripe_subscription.items.each do |stripe_item|
+        item = items.find { |item| item[:plan] == stripe_item['plan']['id'] }
+
+        next if item.blank? || item[:quantity] == stripe_item['quantity']
+
+        stripe_item.quantity = item[:quantity]
+        stripe_item.metadata = item[:metadata]
+
+        Rails.logger.info " -> UPDATE: #{item[:plan]}"
+        stripe_item.save
+      end
+
+      # Create stripe subscription items
+      items.each do |item|
+        next if customer.stripe_subscription.items.find { |stripe_item| item[:plan] == stripe_item['plan']['id'] }
+
+        Rails.logger.info " -> CREATE: #{item[:plan]}"
+        customer.stripe_subscription.items.create(plan: item[:plan], quantity: item[:quantity], metadata: item[:metadata])
+      end
+
+      # Delete stripe subscription items
+      customer.stripe_subscription.items.each do |stripe_item|
+        next if items.find { |item| item[:plan] == stripe_item['plan']['id'] }
+
+        Rails.logger.info " -> DELETE: #{stripe_item['plan']['id']}"
+        stripe_item.delete
+      end
+
+      # Update metadata
+      if customer.stripe_subscription.metadata.to_h != metadata
+        Rails.logger.info " -> METATADA: #{metadata}"
+        customer.stripe_subscription.metadata = metadata
+        customer.stripe_subscription.save
+      end
+
+      # When upgrading a plan, invoice immediately.
+      if current_plan && current_plan[:id] != 'trial' && plan[:amount] > current_plan[:amount]
+        Rails.logger.info " -> INVOICE GENERATED"
+        Stripe::Invoice.create(customer: customer.stripe_customer_id).pay rescue false
+      end
+
+      # Sync status
+      customer.status = customer.stripe_subscription.status
+
+      true
+    end
+
+    private
+
+    def items(metadata: true)
+      customer.subscriptions.group_by { |sub| sub.stripe_plan_id }.map do |plan, subscriptions|
+        if metadata
+          { plan: plan, quantity: subscriptions.length, metadata: metadata(subscriptions: subscriptions) }
+        else
+          { plan: plan, quantity: subscriptions.length }
+        end
+      end
+    end
+
+    # The stripe metadata limit is 500 characters
+    def metadata(subscriptions: nil)
+      retval = { user_id: user.id.to_s, user: user.to_s.truncate(500) }
+
+      (subscriptions || customer.subscriptions).group_by { |sub| sub.subscribable_type }.each do |subscribable_type, subs|
+        subs = subs.sort
+
+        if subs.length == 1
+          retval[subscribable_type.downcase + '_id'] = subs.map { |sub| sub.subscribable.id }.join(',')
+          retval[subscribable_type.downcase] = subs.map { |sub| sub.subscribable.to_s }.join(',').truncate(500)
+        else
+          retval[subscribable_type.downcase + '_ids'] = subs.map { |sub| sub.subscribable.id }.join(',')
+          retval[subscribable_type.downcase.pluralize] = subs.map { |sub| sub.subscribable.to_s }.join(',').truncate(500)
+        end
+      end
+
+      retval
+    end
+
+  end
+end

data/app/models/effective/subscription.rb

@@ -1,98 +1,49 @@
+# This links the acts_as_subscribable_buyer (customer) to the acts_as_subscribable (subscribable)
+
 module Effective
   class Subscription < ActiveRecord::Base
-    include EffectiveStripeHelper
-
     self.table_name = EffectiveOrders.subscriptions_table_name.to_s
 
-    acts_as_purchasable
+    belongs_to :customer, class_name: 'Effective::Customer', counter_cache: true
+    belongs_to :subscribable, polymorphic: true
 
-    belongs_to :customer
-
-    # structure do
-    #   stripe_plan_id          :string  # This will be 'Weekly' or something like that
-    #   stripe_subscription_id  :string
-    #   stripe_coupon_id        :string
+    # Attributes
+    # stripe_plan_id          :string  # This will be 'bronze' or something like that
+    # status                  :string
     #
-    #   title                   :string
-    #   price                   :integer, default: 0
+    # name                    :string
+    # price                   :integer, default: 0
     #
-    #   timestamps
-    # end
-
-    delegate :user, :user_id, :to => :customer
-
-    validates :stripe_plan_id, presence: true
-    validates :title, presence: true
-    validates :price, numericality: { greater_than: 0 }
-
-    validates :customer, presence: true
-    validates :customer_id, uniqueness: { scope: [:stripe_plan_id] }  # Can only be on each plan once.
-
-    before_validation do
-      self.errors.add(:stripe_plan_id, "is an invalid Plan") if stripe_plan_id.present? && stripe_plan.blank?
-      self.errors.add(:stripe_coupon_id, "is an invalid Coupon") if stripe_coupon_id.present? && stripe_coupon.blank?
-    end
-
-    def tax_exempt
-      true
-    end
-
-    def stripe_plan_id=(plan_id)
-      unless self[:stripe_plan_id] == plan_id
-        self[:stripe_plan_id] = plan_id
-        @stripe_plan = nil   # Remove any memoization
+    # timestamps
 
-        assign_price_and_title()
-      end
+    before_validation(if: -> { plan && (stripe_plan_id_changed? || new_record?) }) do
+      self.name = "#{plan[:name]} #{plan[:description]}"
+      self.price = plan[:amount]
     end
 
-    def stripe_coupon_id=(coupon_id)
-      unless self[:stripe_coupon_id] == coupon_id
-        self[:stripe_coupon_id] = coupon_id
-        @stripe_coupon = nil   # Remove any memoization
+    validates :customer, presence: true
+    validates :subscribable, presence: true
 
-        assign_price_and_title()
-      end
-    end
+    validates :stripe_plan_id, presence: true, inclusion: { in: EffectiveOrders.stripe_plans.except('trial').keys }
+    validates :status, presence: true, inclusion: { in: %w(active past_due) }
 
-    def stripe_plan
-      if stripe_plan_id.present?
-        @stripe_plan ||= (Stripe::Plan.retrieve(stripe_plan_id) rescue nil)
-      end
-    end
+    validates :name, presence: true
+    validates :price, numericality: { greater_than_or_equal_to: 0, only_integer: true }
 
-    def stripe_coupon
-      if stripe_coupon_id.present?
-        @stripe_coupon ||= (Stripe::Coupon.retrieve(stripe_coupon_id) rescue nil)
-      end
+    def to_s
+      name.presence || 'New Subscription'
     end
 
-    def stripe_subscription
-      if stripe_subscription_id.present?
-        @stripe_subscription ||= (customer.stripe_customer.subscriptions.retrieve(stripe_subscription_id) rescue nil)
-      end
+    def plan
+      EffectiveOrders.stripe_plans[stripe_plan_id]
     end
 
-    private
-
-    def assign_price_and_title
-      if stripe_plan
-        if stripe_coupon
-          self.price = price_with_coupon(stripe_plan.amount, stripe_coupon)
-          self.title = stripe_plan_description(stripe_plan) + '<br>Coupon Code: ' + stripe_coupon_description(stripe_coupon)
-        else
-          self.title = stripe_plan_description(stripe_plan)
-          self.price = stripe_plan.amount
-        end
-      end
+    def active?
+      status == 'active'
     end
 
-    def price_with_coupon(amount, coupon)
-      if coupon.percent_off.present?
-        (amount * (coupon.percent_off.to_i / 100.0)).round(0).to_i
-      else
-        [0, amount - coupon.amount_off].max
-      end
+    def <=>(other)
+      (name || '') <=> (other.try(:name) || '')
     end
 
   end