solidus_subscriptions-alpha 0.0.1

data/app/decorators/spree/orders/after_create.rb

@@ -0,0 +1,15 @@
+module Spree
+  module Orders
+    module AfterCreate
+      def ensure_line_items_present
+        super unless subscription_order?
+      end
+
+      def send_cancel_email
+        super unless subscription_order?
+      end
+    end
+
+    Order.prepend(AfterCreate)
+  end
+end

data/app/decorators/spree/orders/finalize_creates_subscriptions.rb

@@ -0,0 +1,19 @@
+# Once an order is finalized its subscriptions line items should be converted
+# into active subscritptions. This hooks into Spree::Order#finalize! and
+# passes all subscription_line_items present on the order to the Subscription
+# generator which will build and persist the subscriptions
+module Spree
+  module Orders
+    module FinalizeCreatesSubscriptions
+      def finalize!
+        SolidusSubscriptions::SubscriptionGenerator.group(subscription_line_items).each do |line_items|
+          SolidusSubscriptions::SubscriptionGenerator.activate(line_items)
+        end
+
+        super
+      end
+    end
+  end
+end
+
+Spree::Order.prepend Spree::Orders::FinalizeCreatesSubscriptions

data/app/decorators/spree/orders/subscription_line_items_association.rb

@@ -0,0 +1,15 @@
+# Spree::Orders may contain many subscription_line_items. When the order is
+# finalized these subscription_line_items are converted into subscritpions.
+# The order needs to be able to get a list of associated subscription_line_items
+# to be able to populate the full subscriptions.
+module Spree
+  module Orders
+    module SubscriptionLineItemsAssociation
+      def self.prepended(base)
+        base.has_many :subscription_line_items, through: :line_items
+      end
+    end
+  end
+end
+
+Spree::Order.prepend Spree::Orders::SubscriptionLineItemsAssociation

data/app/decorators/spree/users/have_many_subscriptions.rb

@@ -0,0 +1,18 @@
+# Spree::Users maintain a list of the subscriptions associated with them
+module Spree
+  module Users
+    module HaveManySubscritptions
+      def self.prepended(base)
+        base.has_many(
+          :subscriptions,
+          class_name: 'SolidusSubscriptions::Subscription',
+          foreign_key: 'user_id'
+        )
+
+        base.accepts_nested_attributes_for :subscriptions
+      end
+    end
+  end
+end
+
+Spree.user_class.prepend(Spree::Users::HaveManySubscritptions)

data/app/decorators/spree/variant_pretty_name.rb

@@ -0,0 +1,13 @@
+module Spree
+  module Variants
+    module VariantPrettyName
+      def pretty_name
+        name = product.name
+        name += " - #{options_text}" if options_text.present?
+        name
+      end
+    end
+  end
+end
+
+Spree::Variant.prepend Spree::Variants::VariantPrettyName

data/app/jobs/solidus_subscriptions/process_installments_job.rb

@@ -0,0 +1,22 @@
+# This job is responsible for creating a consolidated installment from a
+# list of installments and processing it.
+
+module SolidusSubscriptions
+  class ProcessInstallmentsJob < ActiveJob::Base
+     queue_as Config.processing_queue
+
+     # Process a collection of installments
+     #
+     # @param installment_ids [Array<Integer>] The ids of the
+     #   installments to be processed together and fulfilled by the same order
+     #
+     # @return [Spree::Order] The order which fulfills the list of installments
+     def perform(installment_ids)
+       return if installment_ids.empty?
+
+       installments = SolidusSubscriptions::Installment.where(id: installment_ids).
+         includes(subscription: [:line_items, :user])
+       Checkout.new(installments).process
+     end
+  end
+end

data/app/models/solidus_subscriptions/checkout.rb

@@ -0,0 +1,137 @@
+# This class takes a collection of installments and populates a new spree
+# order with the correct contents based on the subscriptions associated to the
+# intallments. This is to group together subscriptions being
+# processed on the same day for a specific user
+module SolidusSubscriptions
+  class Checkout
+    # @return [Array<Installment>] The collection of installments to be used
+    #   when generating a new order
+    attr_reader :installments
+
+    delegate :user, to: :subscription
+
+    # Get a new instance of a Checkout
+    #
+    # @param installments [Array<Installment>] The collection of installments
+    # to be used when generating a new order
+    def initialize(installments)
+      @installments = installments
+      raise UserMismatchError.new(installments) if different_owners?
+    end
+
+    # Generate a new Spree::Order based on the information associated to the
+    # installments
+    #
+    # @return [Spree::Order]
+    def process
+      populate
+
+      # Installments are removed and set for future processing if they are
+      # out of stock. If there are no line items left there is nothing to do
+      return if installments.empty?
+
+      if checkout
+        Config.success_dispatcher_class.new(installments, order).dispatch
+        return order
+      end
+
+      # A new order will only have 1 payment that we created
+      if order.payments.any?(&:failed?)
+        Config.payment_failed_dispatcher_class.new(installments, order).dispatch
+        installments.clear
+        nil
+      end
+    ensure
+      # Any installments that failed to be processed will be reprocessed
+      unfulfilled_installments = installments.select(&:unfulfilled?)
+      if unfulfilled_installments.any?
+        Config.failure_dispatcher_class.
+          new(unfulfilled_installments, order).dispatch
+      end
+    end
+
+    # The order fulfilling the consolidated installment
+    #
+    # @return [Spree::Order]
+    def order
+      @order ||= Spree::Order.create(
+        user: user,
+        email: user.email,
+        store: subscription.store || Spree::Store.default,
+        subscription_order: true
+      )
+    end
+
+    private
+
+    def checkout
+      order.update!
+      apply_promotions
+
+      order.checkout_steps[0...-1].each do
+        order.ship_address = ship_address if order.state == "address"
+        create_payment if order.state == "payment"
+        order.next!
+      end
+
+      # Do this as a separate "quiet" transition so that it returns true or
+      # false rather than raising a failed transition error
+      order.complete
+    end
+
+    def populate
+      unfulfilled_installments = []
+
+      order_line_items = installments.flat_map do |installment|
+        line_items = installment.line_item_builder.spree_line_items
+
+        unfulfilled_installments.push(installment) if line_items.empty?
+
+        line_items
+      end
+
+      # Remove installments which had no stock from the active list
+      # They will be reprocessed later
+      @installments -= unfulfilled_installments
+      if unfulfilled_installments.any?
+        Config.out_of_stock_dispatcher_class.new(unfulfilled_installments).dispatch
+      end
+
+      return if installments.empty?
+      order_builder.add_line_items(order_line_items)
+    end
+
+    def order_builder
+      @order_builder ||= OrderBuilder.new(order)
+    end
+
+    def subscription
+      installments.first.subscription
+    end
+
+    def ship_address
+      subscription.shipping_address || user.ship_address
+    end
+
+    def active_card
+      user.credit_cards.default.last
+    end
+
+    def create_payment
+      order.payments.create(
+        source: active_card,
+        amount: order.total,
+        payment_method: Config.default_gateway
+      )
+    end
+
+    def apply_promotions
+      Spree::PromotionHandler::Cart.new(order).activate
+      order.updater.update # reload totals
+    end
+
+    def different_owners?
+      installments.map { |i| i.subscription.user }.uniq.length > 1
+    end
+  end
+end

data/app/models/solidus_subscriptions/dispatcher.rb

@@ -0,0 +1,32 @@
+module SolidusSubscriptions
+  class Dispatcher
+    attr_reader :installments, :order
+
+    # Get a new instance of the FailureDispatcher
+    #
+    # @param installments [Array<SolidusSubscriptions::Installment>] The
+    #   installments which have failed to be fulfilled
+    #
+    # @return [SolidusSubscriptions::FailureDispatcher]
+    def initialize(installments, order = nil)
+      @installments = installments
+      @order = order
+    end
+
+    def dispatch
+      notify
+    end
+
+    private
+
+    def notify
+      Rails.logger.tagged('Event') do
+        Rails.logger.info message.squish.tr("\n", ' ')
+      end
+    end
+
+    def message
+      raise 'A message should be set in subclasses of Dispatcher'
+    end
+  end
+end

data/app/models/solidus_subscriptions/failure_dispatcher.rb

@@ -0,0 +1,19 @@
+# A handler for behaviour that should happen after installments are marked as
+# failures
+module SolidusSubscriptions
+  class FailureDispatcher < Dispatcher
+    def dispatch
+      order.touch :completed_at
+      order.cancel!
+      installments.each { |i| i.failed!(order) }
+      super
+    end
+
+    def message
+      "
+      Something went wrong processing installments: #{installments.map(&:id).join(', ')}.
+      They have been marked for reprocessing.
+      "
+    end
+  end
+end

data/app/models/solidus_subscriptions/installment.rb

@@ -0,0 +1,126 @@
+# This class represents a single iteration of a subscription. It is fulfulled
+# by a conmpleted order and maintains an association which tracks all attempts
+# successful or othewise at fulfulling this installment
+module SolidusSubscriptions
+  class Installment < ActiveRecord::Base
+    has_many :details, class_name: 'SolidusSubscriptions::InstallmentDetail'
+    belongs_to(
+      :subscription,
+      class_name: 'SolidusSubscriptions::Subscription',
+      inverse_of: :installments
+    )
+
+    validates :subscription, presence: true
+
+    scope :fulfilled, (lambda do
+      joins(:details).where(InstallmentDetail.table_name => { success: true }).distinct
+    end)
+
+    scope :unfulfilled, (lambda do
+      fulfilled_ids = fulfilled.pluck(:id)
+      where.not(id: fulfilled_ids).distinct
+    end)
+
+    scope :actionable, (lambda do
+      unfulfilled.where("#{table_name}.actionable_date <= ?", Time.zone.now)
+    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
+      subscription.line_item_builder
+    end
+
+    # Mark this installment as out of stock.
+    #
+    # @return [SolidusSubscriptions::InstallmentDetail] The record of the failed
+    #   processing attempt
+    def out_of_stock
+      advance_actionable_date!
+
+      details.create!(
+        success: false,
+        message: I18n.t('solidus_subscriptions.installment_details.out_of_stock')
+      )
+    end
+
+    # Mark this installment as a success
+    #
+    # @param order [Spree::Order] The order generated for this processing
+    #   attempt
+    #
+    # @return [SolidusSubscriptions::InstallmentDetail] The record of the
+    #   successful processing attempt
+    def success!(order)
+      update!(actionable_date: nil)
+
+      details.create!(
+        success: true,
+        order: order,
+        message: I18n.t('solidus_subscriptions.installment_details.success')
+      )
+    end
+
+    # Mark this installment as a failure
+    #
+    # @param order [Spree::Order] The order generated for this processing
+    #   attempt
+    #
+    # @return [SolidusSubscriptions::InstallmentDetail] The record of the
+    #   failed processing attempt
+    def failed!(order)
+      advance_actionable_date!
+
+      details.create!(
+        success: false,
+        order: order,
+        message: I18n.t('solidus_subscriptions.installment_details.failed')
+      )
+    end
+
+    # Does this installment still need to be fulfilled by a completed order
+    #
+    # @return [Boolean]
+    def unfulfilled?
+      !fulfilled?
+    end
+
+    # Had this installment been fulfilled by a completed order
+    #
+    # @return [Boolean]
+    def fulfilled?
+      details.where(success: true).exists?
+    end
+
+    # Mark this installment as having a failed payment
+    #
+    # @param order [Spree::Order] The order generated for this processing
+    #   attempt
+    #
+    # @return [SolidusSubscriptions::InstallmentDetail] The record of the
+    #   failed processing attempt
+    def payment_failed!(order)
+      advance_actionable_date!
+
+      details.create!(
+        success: false,
+        order: order,
+        message: I18n.t('solidus_subscriptions.installment_details.payment_failed')
+      )
+    end
+
+    private
+
+    def advance_actionable_date!
+      update!(actionable_date: next_actionable_date)
+    end
+
+    def next_actionable_date
+      return if Config.reprocessing_interval.nil?
+      (DateTime.current + Config.reprocessing_interval).beginning_of_minute
+    end
+  end
+end

data/app/models/solidus_subscriptions/installment_detail.rb

@@ -0,0 +1,23 @@
+# This class represents a single attempt to fulfill an installment. It will
+# indicate the result of that attept.
+module SolidusSubscriptions
+  class InstallmentDetail < ActiveRecord::Base
+    belongs_to(
+      :installment,
+      class_name: 'SolidusSubscriptions::Installment',
+      inverse_of: :details
+    )
+
+    belongs_to(:order, class_name: 'Spree::Order')
+
+    validates :installment, presence: true
+    alias_attribute :successful, :success
+
+    # Was the attempt at fulfilling this installment a failure?
+    #
+    # @return [Boolean]
+    def failed?
+      !success
+    end
+  end
+end