solidus_subscriptions 1.0.0.rc1

data/app/decorators/models/solidus_subscriptions/spree/variant/auto_delete_from_subscriptions.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SolidusSubscriptions
+  module Spree
+    module Variant
+      module AutoDeleteFromSubscriptions
+        def self.prepended(base)
+          base.after_discard(:remove_from_subscriptions)
+          base.after_destroy(:remove_from_subscriptions)
+        end
+
+        def remove_from_subscriptions
+          SolidusSubscriptions::LineItem.where(subscribable: self).delete_all
+        end
+      end
+    end
+  end
+end
+
+Spree::Variant.prepend(SolidusSubscriptions::Spree::Variant::AutoDeleteFromSubscriptions)

data/app/decorators/models/solidus_subscriptions/spree/variant/variant_pretty_name.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SolidusSubscriptions
+  module Spree
+    module Variant
+      module VariantPrettyName
+        def pretty_name
+          name = product.name
+          name += " - #{options_text}" if options_text.present?
+          name
+        end
+      end
+    end
+  end
+end
+
+Spree::Variant.prepend(SolidusSubscriptions::Spree::Variant::VariantPrettyName)

data/app/decorators/models/solidus_subscriptions/spree/wallet_payment_source/report_default_change_to_subscriptions.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SolidusSubscriptions
+  module Spree
+    module WalletPaymentSource
+      module ReportDefaultChangeToSubscriptions
+        def self.prepended(base)
+          base.after_save :report_default_change_to_subscriptions
+        end
+
+        private
+
+        def report_default_change_to_subscriptions
+          return if !previous_changes.key?('default') || !default?
+
+          user.subscriptions.with_default_payment_source.each do |subscription|
+            ::Spree::Event.fire(
+              'solidus_subscriptions.subscription_payment_method_changed',
+              subscription: subscription,
+            )
+          end
+        end
+      end
+    end
+  end
+end
+
+Spree::WalletPaymentSource.prepend(SolidusSubscriptions::Spree::WalletPaymentSource::ReportDefaultChangeToSubscriptions)

data/app/jobs/solidus_subscriptions/process_installment_job.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SolidusSubscriptions
+  class ProcessInstallmentJob < ApplicationJob
+    queue_as { SolidusSubscriptions.configuration.processing_queue }
+
+    def perform(installment)
+      Checkout.new(installment).process
+    rescue StandardError => e
+      SolidusSubscriptions.configuration.processing_error_handler&.call(e)
+    end
+  end
+end

data/app/jobs/solidus_subscriptions/process_subscription_job.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SolidusSubscriptions
+  class ProcessSubscriptionJob < ApplicationJob
+    queue_as { SolidusSubscriptions.configuration.processing_queue }
+
+    def perform(subscription)
+      ActiveRecord::Base.transaction do
+        if SolidusSubscriptions.configuration.clear_past_installments
+          subscription.installments.unfulfilled.actionable.each do |installment|
+            installment.update!(actionable_date: nil)
+          end
+        end
+
+        if subscription.actionable?
+          subscription.successive_skip_count = 0
+          subscription.advance_actionable_date
+
+          subscription.installments.create!(actionable_date: Time.zone.now)
+        end
+
+        subscription.cancel! if subscription.pending_cancellation?
+        subscription.deactivate! if subscription.can_be_deactivated?
+
+        subscription.installments.actionable.find_each do |installment|
+          SolidusSubscriptions::ProcessInstallmentJob.perform_later(installment)
+        end
+      end
+    end
+  end
+end

data/app/models/solidus_subscriptions/installment.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+# This class represents a single iteration of a subscription. It is fulfilled
+# by a completed order and maintains an association which tracks all attempts
+# successful or otherwise at fulfilling this installment
+module SolidusSubscriptions
+  class Installment < ApplicationRecord
+    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
+      where.not(id: Installment.fulfilled).distinct
+    end)
+
+    scope :with_active_subscription, (lambda do
+      joins(:subscription).where.not(Subscription.table_name => { state: "canceled" })
+    end)
+
+    scope :actionable, (lambda do
+      unfulfilled.where("#{table_name}.actionable_date <= ?", Time.zone.today)
+    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.exists?(success: true)
+    end
+
+    # Returns the state of this fulfillment
+    #
+    # @return [Symbol] :fulfilled/:unfulfilled
+    def state
+      fulfilled? ? :fulfilled : :unfulfilled
+    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)
+      details.create!(
+        success: false,
+        order: order,
+        message: I18n.t('solidus_subscriptions.installment_details.payment_failed')
+      )
+
+      if subscription.maximum_reprocessing_time_reached? && !subscription.canceled?
+        subscription.force_cancel!
+        update!(actionable_date: nil)
+      else
+        advance_actionable_date!
+      end
+    end
+
+    private
+
+    def advance_actionable_date!
+      update!(actionable_date: next_actionable_date)
+    end
+
+    def next_actionable_date
+      return if SolidusSubscriptions.configuration.reprocessing_interval.nil?
+
+      (DateTime.current + SolidusSubscriptions.configuration.reprocessing_interval).beginning_of_minute
+    end
+  end
+end

data/app/models/solidus_subscriptions/installment_detail.rb

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

data/app/models/solidus_subscriptions/interval.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# This module is intended to be included into any active record
+# model which needs to be aware of how intervals are 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,42 @@
+# frozen_string_literal: true
+
+# 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 < ApplicationRecord
+    include Interval
+
+    belongs_to(
+      :spree_line_item,
+      class_name: '::Spree::LineItem',
+      inverse_of: :subscription_line_items,
+      optional: true,
+    )
+    has_one :order, through: :spree_line_item, class_name: '::Spree::Order'
+    belongs_to(
+      :subscription,
+      class_name: 'SolidusSubscriptions::Subscription',
+      inverse_of: :line_items,
+      optional: true
+    )
+    belongs_to :subscribable, class_name: "::#{SolidusSubscriptions.configuration.subscribable_class}"
+
+    validates :subscribable_id, presence: true
+    validates :quantity, numericality: { greater_than: 0 }
+    validates :interval_length, numericality: { greater_than: 0 }, unless: -> { subscription }
+  end
+end

data/app/models/solidus_subscriptions/promotion/rules/subscription_creation_order.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SolidusSubscriptions
+  module Promotion
+    module Rules
+      class SubscriptionCreationOrder < ::Spree::PromotionRule
+        # Promotion can be applied to an entire order. Will only be true
+        # for Spree::Order
+        #
+        # @param promotable [Object] Any object which could have this
+        #   promotion rule applied to it.
+        #
+        # @return [Boolean]
+        def applicable?(promotable)
+          promotable.is_a? ::Spree::Order
+        end
+
+        # An order is eligible if it contains a line item with an associates
+        # subscription_line_item.  This rule applies to order and so its eligibility
+        # will always be considered against an order. Will only return true for
+        # orders containing Spree::Line item with associated subscription_line_items
+        #
+        # @param order [Spree::Order] The order which could have this rule applied
+        #   to it.
+        #
+        # @return [Boolean]
+        def eligible?(order, **_options)
+          order.subscription_line_items.any?
+        end
+
+        # Certain actions create adjustments on line items. In this case, only
+        # line items with associated subscription_line_items are eligible to be
+        # adjusted. Will only return true # if :line_item has an associated
+        # subscription.
+        #
+        # @param line_item [Spree::LineItem] The line item which could be adjusted
+        #   by the promotion.
+        def actionable?(line_item)
+          line_item.subscription_line_items.present?
+        end
+      end
+    end
+  end
+end

data/app/models/solidus_subscriptions/promotion/rules/subscription_installment_order.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SolidusSubscriptions
+  module Promotion
+    module Rules
+      class SubscriptionInstallmentOrder < ::Spree::PromotionRule
+        # Promotion can be applied to an entire order. Will only be true
+        # for Spree::Order
+        #
+        # @param promotable [Object] Any object which could have this
+        #   promotion rule applied to it.
+        #
+        # @return [Boolean]
+        def applicable?(promotable)
+          promotable.is_a? ::Spree::Order
+        end
+
+        # An order is eligible if it fulfills a subscription Installment. Will only
+        # return true if the order fulfills one or more Installments
+        #
+        # @param order [Spree::Order] The order which could have this rule applied
+        #   to it.
+        #
+        # @return [Boolean]
+        def eligible?(order, **_options)
+          order.subscription_order?
+        end
+      end
+    end
+  end
+end

data/app/models/solidus_subscriptions/subscription.rb

@@ -0,0 +1,392 @@
+# frozen_string_literal: true
+
+# The subscription class is responsible for grouping together the
+# information required for the system to place a subscriptions order on
+# behalf of a specific user.
+module SolidusSubscriptions
+  class Subscription < ApplicationRecord
+    include Interval
+
+    PROCESSING_STATES = [:pending, :failed, :success].freeze
+
+    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'
+    has_many :installment_details, class_name: 'SolidusSubscriptions::InstallmentDetail', through: :installments, source: :details
+    has_many :events, class_name: 'SolidusSubscriptions::SubscriptionEvent'
+    has_many :orders, class_name: '::Spree::Order', inverse_of: :subscription
+    belongs_to :store, class_name: '::Spree::Store'
+    belongs_to :shipping_address, class_name: '::Spree::Address', optional: true
+    belongs_to :billing_address, class_name: '::Spree::Address', optional: true
+    belongs_to :payment_method, class_name: '::Spree::PaymentMethod', optional: true
+    belongs_to :payment_source, polymorphic: true, optional: true
+
+    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 }
+    validates :payment_method, presence: true, if: -> { payment_source }
+    validates :payment_source, presence: true, if: -> { payment_method&.source_required? }
+    validates :currency, inclusion: { in: ::Money::Currency.all.map(&:iso_code) }
+
+    validate :validate_payment_source_ownership
+
+    accepts_nested_attributes_for :shipping_address
+    accepts_nested_attributes_for :billing_address
+    accepts_nested_attributes_for :line_items, allow_destroy: true, reject_if: ->(p) { p[:quantity].blank? }
+
+    before_validation :set_payment_method
+    before_validation :set_currency
+    before_create :generate_guest_token
+    after_create :emit_event_for_creation
+    before_update :update_actionable_date_if_interval_changed
+    after_update :emit_events_for_update
+
+    # 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.today).
+        where.not(state: ["canceled", "inactive"])
+    end)
+
+    # Find subscriptions based on their processing state. This state is not a
+    # model attribute.
+    #
+    # @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, "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)
+
+    scope :with_default_payment_source, (lambda do
+      where(payment_method: nil, payment_source: nil)
+    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
+
+      event :force_cancel do
+        transition [:active, :pending_cancellation] => :canceled
+        transition inactive: :inactive
+        transition canceled: :canceled
+      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
+      after_transition do: :emit_event_for_transition
+    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 overridden 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. Subscriptions
+    # pending cancellation will still be processed.
+    def can_be_canceled?
+      return true if actionable_date.nil?
+
+      cancel_by = actionable_date - SolidusSubscriptions.configuration.minimum_cancellation_notice
+      cancel_by.future? || cancel_by.today?
+    end
+
+    def skip(check_skip_limits: true)
+      if check_skip_limits
+        check_successive_skips_exceeded
+        check_total_skips_exceeded
+
+        return if errors.any?
+      end
+
+      increment(:skip_count)
+      increment(:successive_skip_count)
+      save!
+
+      advance_actionable_date.tap do
+        events.create!(event_type: 'subscription_skipped')
+      end
+    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
+    # the subscription 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? && end_date && actionable_date && actionable_date > 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.today
+
+      new_date + interval
+    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
+
+    # The state of the last attempt to process an installment associated to
+    # this subscription
+    #
+    # @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
+
+    def payment_method_to_use
+      payment_method || user.wallet.default_wallet_payment_source&.payment_source&.payment_method
+    end
+
+    def payment_source_to_use
+      if payment_method
+        payment_source
+      else
+        user.wallet.default_wallet_payment_source&.payment_source
+      end
+    end
+
+    def shipping_address_to_use
+      shipping_address || user.ship_address
+    end
+
+    def billing_address_to_use
+      billing_address || user.bill_address
+    end
+
+    def failing_since
+      failing_details = installment_details.failed.order('solidus_subscriptions_installment_details.created_at ASC')
+
+      last_successful_detail = installment_details
+                               .succeeded
+                               .order('solidus_subscriptions_installment_details.created_at DESC')
+                               .first
+      if last_successful_detail
+        failing_details = failing_details.where(
+          'solidus_subscriptions_installment_details.created_at > ?',
+          last_successful_detail.created_at,
+        )
+      end
+
+      first_failing_detail = failing_details.first
+
+      first_failing_detail&.created_at
+    end
+
+    def maximum_reprocessing_time_reached?
+      return false unless SolidusSubscriptions.configuration.maximum_reprocessing_time
+      return false unless failing_since
+
+      Time.zone.now > (failing_since + SolidusSubscriptions.configuration.maximum_reprocessing_time)
+    end
+
+    def actionable?
+      actionable_date && actionable_date <= Time.zone.today && ["canceled", "inactive"].exclude?(state)
+    end
+
+    private
+
+    def validate_payment_source_ownership
+      return if payment_source.blank?
+
+      if payment_source.respond_to?(:user_id) &&
+         payment_source.user_id != user_id
+        errors.add(:payment_source, :not_owned_by_user)
+      end
+    end
+
+    def check_successive_skips_exceeded
+      return unless SolidusSubscriptions.configuration.maximum_successive_skips
+
+      if successive_skip_count >= SolidusSubscriptions.configuration.maximum_successive_skips
+        errors.add(:successive_skip_count, :exceeded)
+      end
+    end
+
+    def check_total_skips_exceeded
+      return unless SolidusSubscriptions.configuration.maximum_total_skips
+
+      if skip_count >= SolidusSubscriptions.configuration.maximum_total_skips
+        errors.add(:skip_count, :exceeded)
+      end
+    end
+
+    def update_actionable_date_if_interval_changed
+      if persisted? && (interval_length_previously_changed? || interval_units_previously_changed?)
+        base_date = if installments.any?
+                      installments.last.created_at
+                    else
+                      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
+
+        self.actionable_date = new_date
+      end
+    end
+
+    def set_payment_method
+      if payment_source
+        self.payment_method = payment_source.payment_method
+      end
+    end
+
+    def set_currency
+      self.currency ||= ::Spree::Config[:currency]
+    end
+
+    def generate_guest_token
+      self.guest_token ||= loop do
+        random_token = SecureRandom.urlsafe_base64(nil, false)
+        break random_token unless self.class.exists?(guest_token: random_token)
+      end
+    end
+
+    def emit_event_for_creation
+      ::Spree::Event.fire(
+        'solidus_subscriptions.subscription_created',
+        subscription: self,
+      )
+    end
+
+    def emit_event_for_transition
+      event_type = {
+        active: 'subscription_activated',
+        canceled: 'subscription_canceled',
+        pending_cancellation: 'subscription_canceled',
+        inactive: 'subscription_ended',
+      }[state.to_sym]
+
+      ::Spree::Event.fire(
+        "solidus_subscriptions.#{event_type}",
+        subscription: self,
+      )
+    end
+
+    def emit_events_for_update
+      if previous_changes.key?('interval_length') || previous_changes.key?('interval_units')
+        ::Spree::Event.fire(
+          'solidus_subscriptions.subscription_frequency_changed',
+          subscription: self,
+        )
+      end
+
+      if previous_changes.key?('shipping_address_id')
+        ::Spree::Event.fire(
+          'solidus_subscriptions.subscription_shipping_address_changed',
+          subscription: self,
+        )
+      end
+
+      if previous_changes.key?('billing_address_id')
+        ::Spree::Event.fire(
+          'solidus_subscriptions.subscription_billing_address_changed',
+          subscription: self,
+        )
+      end
+
+      if previous_changes.key?('payment_source_id') || previous_changes.key?('payment_source_type') || previous_changes.key?('payment_method_id')
+        ::Spree::Event.fire(
+          'solidus_subscriptions.subscription_payment_method_changed',
+          subscription: self,
+        )
+      end
+    end
+  end
+end