solidus_subscriptions-alpha 0.0.1

data/app/models/solidus_subscriptions/interval.rb

@@ -0,0 +1,24 @@
+# This module is intended to be included into any active record
+# modle which needs to be aware of how intervals and stored and
+# calculated in the db.
+#
+# Base models must have the following fields: interval_length (integer) and interval_units (integer)
+module SolidusSubscriptions
+  module Interval
+    def self.included(base)
+      base.enum interval_units: {
+        day: 0,
+        week: 1,
+        month: 2,
+        year: 3
+      }
+    end
+
+    # Calculates the number of seconds in the interval.
+    #
+    # @return [Integer] The number of seconds.
+    def interval
+      ActiveSupport::Duration.new(interval_length, { interval_units.pluralize.to_sym => interval_length })
+    end
+  end
+end

data/app/models/solidus_subscriptions/line_item.rb

@@ -0,0 +1,98 @@
+# The LineItem class is responsible for associating Line items to subscriptions.  # It tracks the following values:
+#
+# [Spree::LineItem] :spree_line_item The spree object which created this instance
+#
+# [SolidusSubscription::Subscription] :subscription The object responsible for
+#   grouping all information needed to create new subscription orders together
+#
+# [Integer] :subscribable_id The id of the object to be added to new subscription
+#   orders when they are placed
+#
+# [Integer] :quantity How many units of the subscribable should be included in
+#   future orders
+#
+# [Integer] :interval How often subscription orders should be placed
+#
+# [Integer] :installments How many subscription orders should be placed
+module SolidusSubscriptions
+  class LineItem < ActiveRecord::Base
+    include Interval
+
+    belongs_to :spree_line_item, class_name: 'Spree::LineItem', inverse_of: :subscription_line_items
+    has_one :order, through: :spree_line_item, class_name: 'Spree::Order'
+    belongs_to(
+      :subscription,
+      class_name: 'SolidusSubscriptions::Subscription',
+      inverse_of: :line_items
+    )
+
+    validates :subscribable_id, presence: :true
+    validates :quantity, numericality: { greater_than: 0 }
+    validates :interval_length, numericality: { greater_than: 0 }, unless: -> { subscription }
+
+    before_update :update_actionable_date_if_interval_changed
+
+    def next_actionable_date
+      dummy_subscription.next_actionable_date
+    end
+
+    def as_json(**options)
+      options[:methods] ||= [:dummy_line_item, :next_actionable_date]
+      super(options)
+    end
+
+    # Get a placeholder line item for calculating the values of future
+    # subscription orders. It is frozen and cannot be saved
+    def dummy_line_item
+      li = LineItemBuilder.new([self]).spree_line_items.first
+      return unless li
+
+      li.order = dummy_order
+      li.validate
+      li.freeze
+    end
+
+    def interval
+      subscription.try!(:interval) || super
+    end
+
+    private
+
+    # Get a placeholder order for calculating the values of future
+    # subscription orders. It is a frozen duplicate of the current order and
+    # cannot be saved
+    def dummy_order
+      order = spree_line_item ? spree_line_item.order.dup : Spree::Order.create
+      order.ship_address = subscription.shipping_address || subscription.user.ship_address if subscription
+
+      order.freeze
+    end
+
+    # A place holder for calculating dynamic values needed to display in the cart
+    # it is frozen and cannot be saved
+    def dummy_subscription
+      Subscription.new(line_items: [dup], interval_length: interval_length, interval_units: interval_units).freeze
+    end
+
+    def update_actionable_date_if_interval_changed
+      if persisted? && subscription && (interval_length_changed? || interval_units_changed?)
+        base_date = if subscription.installments.any?
+          subscription.installments.last.created_at
+        else
+          subscription.created_at
+        end
+
+        new_date = interval.since(base_date)
+
+        if new_date < Time.zone.now
+          # if the chosen base time plus the new interval is in the past, set
+          # the actionable_date to be now to avoid confusion and possible
+          # mis-processing.
+          new_date = Time.zone.now
+        end
+
+        subscription.actionable_date = new_date
+      end
+    end
+  end
+end

data/app/models/solidus_subscriptions/line_item_builder.rb

@@ -0,0 +1,44 @@
+# This class is responsible for taking SubscriptionLineItems and building
+# them into Spree::LineItems which can be added to an order
+module SolidusSubscriptions
+  class LineItemBuilder
+    attr_reader :subscription_line_items
+
+    # Get a new instance of a LineItemBuilder
+    #
+    # @param subscription_line_items[Array<SolidusSubscriptions::LineItem>] The
+    #   subscription line item to be converted into a Spree::LineItem
+    #
+    # @return [SolidusSubscriptions::LineItemBuilder]
+    def initialize(subscription_line_items)
+      @subscription_line_items = subscription_line_items
+    end
+
+    # Get a new (unpersisted) Spree::LineItem which matches the details of
+    # :subscription_line_item
+    #
+    # @return [Array<Spree::LineItem>]
+    def spree_line_items
+      line_items = subscription_line_items.map do |subscription_line_item|
+        variant = subscribables.fetch(subscription_line_item.subscribable_id)
+
+        raise UnsubscribableError.new(variant) unless variant.subscribable?
+        next unless variant.can_supply?(subscription_line_item.quantity)
+
+        Spree::LineItem.new(variant: variant, quantity: subscription_line_item.quantity)
+      end
+
+      # Either all line items for an installment are fullfilled or none are
+      line_items.all? ? line_items : []
+    end
+
+    private
+
+    def subscribables
+      return @subscribables if @subscribables
+
+      ids = subscription_line_items.map(&:subscribable_id)
+      @subscribables ||= Spree::Variant.find(ids).index_by(&:id)
+    end
+  end
+end

data/app/models/solidus_subscriptions/order_builder.rb

@@ -0,0 +1,40 @@
+# This class is responsible for adding line items to order without going
+# through order contents.
+module SolidusSubscriptions
+  class OrderBuilder
+    attr_reader :order
+
+    # Get a new instance of a OrderBuilder
+    #
+    # @param order [Spree::Order] The order to be built
+    #
+    # @return [SolidusSubscriptions::OrderBuilder]
+    def initialize(order)
+      @order = order
+    end
+
+    # Add line items for to an order. If the order already
+    # has a line item for a given variant_id, update the quantity. Otherwise
+    # add the line item to the order.
+    #
+    # @param items [Array<Spree::LineItem>] The order to add the line item to
+    # @return [Array<Spree::LineItem] The collection that was passed in
+    def add_line_items(items)
+      items.map { |item| add_item_to_order(item) }
+    end
+
+    private
+
+    def add_item_to_order(new_item)
+      line_item = order.line_items.detect do |li|
+        li.variant_id == new_item.variant_id
+      end
+
+      if line_item
+        line_item.increment!(:quantity, new_item.quantity)
+      else
+        order.line_items << new_item
+      end
+    end
+  end
+end

data/app/models/solidus_subscriptions/out_of_stock_dispatcher.rb

@@ -0,0 +1,19 @@
+# This service class is intented to provide callback behaviour to handle
+# the case where an installment cannot be processed due to lack of stock.
+module SolidusSubscriptions
+  class OutOfStockDispatcher < Dispatcher
+    def dispatch
+      installments.each(&:out_of_stock)
+      super
+    end
+
+    private
+
+    def message
+      "
+      The following installments cannot be fulfilled due to lack of stock:
+      #{installments.map(&:id).join(', ')}.
+      "
+    end
+  end
+end

data/app/models/solidus_subscriptions/payment_failed_dispatcher.rb

@@ -0,0 +1,23 @@
+# This service class is intented to provide callback behaviour to handle
+# the case where a subscription order cannot be processed because a payment
+# failed
+module SolidusSubscriptions
+  class PaymentFailedDispatcher < Dispatcher
+    def dispatch
+      order.touch :completed_at
+      order.cancel!
+
+      installments.each { |i| i.payment_failed!(order) }
+      super
+    end
+
+    private
+
+    def message
+      "
+      The following installments could not be processed due to payment
+      authorization failure: #{installments.map(&:id).join(', ')}
+      "
+    end
+  end
+end

data/app/models/solidus_subscriptions/subscription.rb

@@ -0,0 +1,217 @@
+# The subscription class is responsable for grouping together the
+# information required for the system to place a subscriptions order on
+# behalf of a specific user.
+module SolidusSubscriptions
+  class Subscription < ActiveRecord::Base
+    include Interval
+
+    PROCESSING_STATES = [:pending, :failed, :success]
+
+    belongs_to :user, class_name: Spree.user_class
+    has_many :line_items, class_name: 'SolidusSubscriptions::LineItem', inverse_of: :subscription
+    has_many :installments, class_name: 'SolidusSubscriptions::Installment'
+    belongs_to :store, class_name: 'Spree::Store'
+    belongs_to :shipping_address, class_name: 'Spree::Address'
+
+    validates :user, presence: :true
+    validates :skip_count, :successive_skip_count, presence: true, numericality: { greater_than_or_equal_to: 0 }
+    validates :interval_length, numericality: { greater_than: 0 }
+
+    accepts_nested_attributes_for :shipping_address
+    accepts_nested_attributes_for :line_items, allow_destroy: true
+
+    # The following methods are delegated to the associated
+    # SolidusSubscriptions::LineItem
+    #
+    # :quantity, :subscribable_id
+    delegate :quantity, :subscribable_id, to: :line_item
+
+    # Find all subscriptions that are "actionable"; that is, ones that have an
+    # actionable_date in the past and are not invalid or canceled.
+    scope :actionable, (lambda do
+      where("#{table_name}.actionable_date <= ?", Time.zone.now).
+        where.not(state: ["canceled", "inactive"])
+    end)
+
+    # Find subscriptions based on their processing state. This state is not a
+    # model attrubute.
+    #
+    # @param state [Symbol] One of :pending, :success, or failed
+    #
+    # pending: New subscriptions, never been processed
+    # failed: Subscriptions which failed to be processed on the last attempt
+    # success: Subscriptions which were successfully processed on the last attempt
+    scope :in_processing_state, (lambda do |state|
+      case state.to_sym
+      when :success
+        fulfilled.joins(:installments)
+      when :failed
+        fulfilled_ids = fulfilled.pluck(:id)
+        where.not(id: fulfilled_ids)
+      when :pending
+        includes(:installments).where(solidus_subscriptions_installments: { id: nil })
+      else
+        raise ArgumentError.new("state must be one of: :success, :failed, :pending")
+      end
+    end)
+
+    scope :fulfilled, (lambda do
+      unfulfilled_ids = unfulfilled.pluck(:id)
+      where.not(id: unfulfilled_ids)
+    end)
+
+    scope :unfulfilled, (lambda do
+      joins(:installments).merge(Installment.unfulfilled)
+    end)
+
+    def self.ransackable_scopes(_auth_object = nil)
+      [:in_processing_state]
+    end
+
+    def self.processing_states
+      PROCESSING_STATES
+    end
+
+    # The subscription state determines the behaviours around when it is
+    # processed. Here is a brief description of the states and how they affect
+    # the subscription.
+    #
+    # [active] Default state when created. Subscription can be processed
+    # [canceled] The user has ended their subscription. Subscription will not
+    #   be processed.
+    # [pending_cancellation] The user has ended their subscription, but the
+    #   conditions for canceling the subscription have not been met. Subscription
+    #   will continue to be processed until the subscription is canceled and
+    #   the conditions are met.
+    # [inactive] The number of installments has been fulfilled. The subscription
+    #   will no longer be processed
+    state_machine :state, initial: :active do
+      event :cancel do
+        transition [:active, :pending_cancellation] => :canceled,
+          if: ->(subscription) { subscription.can_be_canceled? }
+
+        transition active: :pending_cancellation
+      end
+
+      after_transition to: :canceled, do: :advance_actionable_date
+
+      event :deactivate do
+        transition active: :inactive,
+          if: ->(subscription) { subscription.can_be_deactivated? }
+      end
+
+      event :activate do
+        transition any - [:active] => :active
+      end
+
+      after_transition to: :active, do: :advance_actionable_date
+    end
+
+    # This method determines if a subscription may be canceled. Canceled
+    # subcriptions will not be processed. By default subscriptions may always be
+    # canceled. If this method is overriden to return false, the subscription
+    # will be moved to the :pending_cancellation state until it is canceled
+    # again and this condition is true.
+    #
+    # USE CASE: Subscriptions can only be canceled more than 10 days before they
+    # are processed. Override this method to be:
+    #
+    # def can_be_canceled?
+    #   return true if actionable_date.nil?
+    #   (actionable_date - 10.days.from_now.to_date) > 0
+    # end
+    #
+    # If a user cancels this subscription less than 10 days before it will
+    # be processed the subscription will be bumped into the
+    # :pending_cancellation state instead of being canceled. Susbcriptions
+    # pending cancellation will still be processed.
+    def can_be_canceled?
+      return true if actionable_date.nil?
+      (actionable_date - Config.minimum_cancellation_notice).future?
+    end
+
+    def skip
+      check_successive_skips_exceeded
+      check_total_skips_exceeded
+
+      return if errors.any?
+
+      advance_actionable_date
+    end
+
+    # This method determines if a subscription can be deactivated. A deactivated
+    # subscription will not be processed. By default a subscription can be
+    # deactivated if the end_date defined on
+    # subscription_line_item is less than the current date
+    # In this case the subscription has been fulfilled and
+    # should not be processed again. Subscriptions without an end_date
+    # value cannot be deactivated.
+    def can_be_deactivated?
+      active? && line_item.end_date && actionable_date > line_item.end_date
+    end
+
+    # Get the date after the current actionable_date where this subscription
+    # will be actionable again
+    #
+    # @return [Date] The current actionable_date plus 1 interval. The next
+    #   date after the current actionable_date this subscription will be
+    #   eligible to be processed.
+    def next_actionable_date
+      return nil unless active?
+      new_date = (actionable_date || Time.zone.now)
+      (new_date + interval).beginning_of_minute
+    end
+
+    # Advance the actionable date to the next_actionable_date value. Will modify
+    # the record.
+    #
+    # @return [Date] The next date after the current actionable_date this
+    # subscription will be eligible to be processed.
+    def advance_actionable_date
+      update! actionable_date: next_actionable_date
+      actionable_date
+    end
+
+    # Get the builder for the subscription_line_item. This will be an
+    # object that can generate the appropriate line item for the subscribable
+    # object
+    #
+    # @return [SolidusSubscriptions::LineItemBuilder]
+    def line_item_builder
+      LineItemBuilder.new(line_items)
+    end
+
+    # The state of the last attempt to process an installment associated to
+    # this subscrtipion
+    #
+    # @return [String] pending if the no installments have been processed,
+    #   failed if the last installment has not been fulfilled and, success
+    #   if the last installment was fulfilled.
+    def processing_state
+      return 'pending' if installments.empty?
+      installments.last.fulfilled? ? 'success' : 'failed'
+    end
+
+    private
+
+    def check_successive_skips_exceeded
+      return unless Config.maximum_successive_skips
+
+      if successive_skip_count >= Config.maximum_successive_skips
+        errors.add(:successive_skip_count, :exceeded)
+      end
+    end
+
+    def check_total_skips_exceeded
+      return unless Config.maximum_total_skips
+
+      if skip_count >= Config.maximum_total_skips
+        errors.add(:skip_count, :exceeded)
+      end
+    end
+
+    def line_item
+      line_items.first
+    end
+  end
+end