solidus_core_devise_token_auth 2.8.0.alpha.0

data/app/models/spree/promotion_code/batch_builder.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+class ::Spree::PromotionCode::BatchBuilder
+  attr_reader :promotion_code_batch, :options
+  delegate :promotion, :number_of_codes, :base_code, to: :promotion_code_batch
+
+  DEFAULT_OPTIONS = {
+    random_code_length: 6,
+    batch_size: 1000,
+    sample_characters: ('a'..'z').to_a + (2..9).to_a.map(&:to_s)
+  }
+
+  [:random_code_length, :batch_size, :sample_characters].each do |attr|
+    define_singleton_method(attr) do
+      Spree::Deprecation.warn "#{name}.#{attr} is deprecated. Use #{name}::DEFAULT_OPTIONS[:#{attr}] instead"
+      DEFAULT_OPTIONS[attr]
+    end
+
+    define_singleton_method(:"#{attr}=") do |val|
+      Spree::Deprecation.warn "#{name}.#{attr}= is deprecated. Use #{name}::DEFAULT_OPTIONS[:#{attr}]= instead"
+      DEFAULT_OPTIONS[attr] = val
+    end
+
+    delegate attr, to: self
+  end
+
+  def initialize(promotion_code_batch, options = {})
+    @promotion_code_batch = promotion_code_batch
+    options.assert_valid_keys(*DEFAULT_OPTIONS.keys)
+    @options = DEFAULT_OPTIONS.merge(options)
+  end
+
+  def build_promotion_codes
+    generate_random_codes
+    promotion_code_batch.update!(state: "completed")
+  rescue StandardError => e
+    promotion_code_batch.update!(
+      error: e.inspect,
+      state: "failed"
+    )
+    raise e
+  end
+
+  private
+
+  def generate_random_codes
+    created_codes = 0
+    batch_size = @options[:batch_size]
+
+    while created_codes < number_of_codes
+      max_codes_to_generate = [batch_size, number_of_codes - created_codes].min
+
+      new_codes = Array.new(max_codes_to_generate) { generate_random_code }.uniq
+      codes_for_current_batch = get_unique_codes(new_codes)
+
+      codes_for_current_batch.each do |value|
+        Spree::PromotionCode.create!(
+          value: value,
+          promotion: promotion,
+          promotion_code_batch: promotion_code_batch
+        )
+      end
+      created_codes += codes_for_current_batch.size
+    end
+  end
+
+  def generate_random_code
+    suffix = Array.new(@options[:random_code_length]) do
+      @options[:sample_characters].sample
+    end.join
+
+    "#{base_code}#{@promotion_code_batch.join_characters}#{suffix}"
+  end
+
+  def get_unique_codes(code_set)
+    code_set - Spree::PromotionCode.where(value: code_set.to_a).pluck(:value)
+  end
+end

data/app/models/spree/promotion_code.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class Spree::PromotionCode < Spree::Base
+  belongs_to :promotion, inverse_of: :codes
+  belongs_to :promotion_code_batch, class_name: "Spree::PromotionCodeBatch"
+  has_many :adjustments
+
+  validates :value, presence: true, uniqueness: { allow_blank: true }
+  validates :promotion, presence: true
+
+  before_save :normalize_code
+
+  self.whitelisted_ransackable_attributes = ['value']
+
+  # Whether the promotion code has exceeded its usage restrictions
+  #
+  # @return true or false
+  def usage_limit_exceeded?
+    if usage_limit
+      usage_count >= usage_limit
+    end
+  end
+
+  # Number of times the code has been used overall
+  #
+  # @return [Integer] usage count
+  def usage_count
+    adjustments.eligible.
+      joins(:order).
+      merge(Spree::Order.complete).
+      distinct.
+      count(:order_id)
+  end
+
+  def usage_limit
+    promotion.per_code_usage_limit
+  end
+
+  private
+
+  def normalize_code
+    self.value = value.downcase.strip
+  end
+end

data/app/models/spree/promotion_code_batch.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Spree
+  class PromotionCodeBatch < ActiveRecord::Base
+    class CantProcessStartedBatch < StandardError
+    end
+
+    belongs_to :promotion, class_name: "Spree::Promotion"
+    has_many :promotion_codes, class_name: "Spree::PromotionCode", dependent: :destroy
+
+    validates :number_of_codes, numericality: { greater_than: 0 }
+    validates_presence_of :base_code, :number_of_codes
+
+    def finished?
+      state == "completed"
+    end
+
+    def process
+      if state == "pending"
+        update!(state: "processing")
+        PromotionCodeBatchJob.perform_later(self)
+      else
+        raise CantProcessStartedBatch.new("Batch #{id} already started")
+      end
+    end
+  end
+end

data/app/models/spree/promotion_handler/cart.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Spree
+  module PromotionHandler
+    # Decides which promotion should be activated given the current order context
+    #
+    # By activated it doesn't necessarily mean that the order will have a
+    # discount for every activated promotion. It means that the discount will be
+    # created and might eventually become eligible. The intention here is to
+    # reduce overhead. e.g. a promotion that requires item A to be eligible
+    # shouldn't be eligible unless item A is added to the order.
+    #
+    # It can be used as a wrapper for custom handlers as well. Different
+    # applications might have completely different requirements to make
+    # the promotions system accurate and performant. Here they can plug custom
+    # handler to activate promos as they wish once an item is added to cart
+    class Cart
+      attr_reader :line_item, :order
+      attr_accessor :error, :success
+
+      def initialize(order, line_item = nil)
+        @order, @line_item = order, line_item
+      end
+
+      def activate
+        promotions.each do |promotion|
+          if (line_item && promotion.eligible?(line_item, promotion_code: promotion_code(promotion))) || promotion.eligible?(order, promotion_code: promotion_code(promotion))
+            promotion.activate(line_item: line_item, order: order, promotion_code: promotion_code(promotion))
+          end
+        end
+      end
+
+      private
+
+      def promotions
+        connected_order_promotions | sale_promotions
+      end
+
+      def connected_order_promotions
+        Spree::Promotion.active.includes(:promotion_rules).
+          joins(:order_promotions).
+          where(spree_orders_promotions: { order_id: order.id }).readonly(false).to_a
+      end
+
+      def sale_promotions
+        Spree::Promotion.where(apply_automatically: true).active.includes(:promotion_rules)
+      end
+
+      def promotion_code(promotion)
+        order_promotion = Spree::OrderPromotion.where(order: order, promotion: promotion).first
+        order_promotion.present? ? order_promotion.promotion_code : nil
+      end
+    end
+  end
+end

data/app/models/spree/promotion_handler/coupon.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Spree
+  module PromotionHandler
+    class Coupon
+      attr_reader :order, :coupon_code
+      attr_accessor :error, :success, :status_code
+
+      def initialize(order)
+        @order = order
+        @coupon_code = order.coupon_code && order.coupon_code.downcase
+      end
+
+      def apply
+        if coupon_code.present?
+          if promotion.present? && promotion.actions.exists?
+            handle_present_promotion(promotion)
+          elsif promotion_code && promotion_code.promotion.inactive?
+            set_error_code :coupon_code_expired
+          else
+            set_error_code :coupon_code_not_found
+          end
+        end
+
+        self
+      end
+
+      def set_success_code(status_code)
+        @status_code = status_code
+        @success = I18n.t(status_code, scope: 'spree')
+      end
+
+      def set_error_code(status_code)
+        @status_code = status_code
+        @error = I18n.t(status_code, scope: 'spree')
+      end
+
+      def promotion
+        @promotion ||= begin
+          if promotion_code && promotion_code.promotion.active?
+            promotion_code.promotion
+          end
+        end
+      end
+
+      def successful?
+        success.present? && error.blank?
+      end
+
+      private
+
+      def promotion_code
+        @promotion_code ||= Spree::PromotionCode.where(value: coupon_code).first
+      end
+
+      def handle_present_promotion(promotion)
+        return promotion_usage_limit_exceeded if promotion.usage_limit_exceeded? || promotion_code.usage_limit_exceeded?
+        return promotion_applied if promotion_exists_on_order?(order, promotion)
+        unless promotion.eligible?(order, promotion_code: promotion_code)
+          self.error = promotion.eligibility_errors.full_messages.first unless promotion.eligibility_errors.blank?
+          return (error || ineligible_for_this_order)
+        end
+
+        # If any of the actions for the promotion return `true`,
+        # then result here will also be `true`.
+        result = promotion.activate(order: order, promotion_code: promotion_code)
+        if result
+          order.recalculate
+          set_success_code :coupon_code_applied
+        else
+          set_error_code :coupon_code_unknown_error
+        end
+      end
+
+      def promotion_usage_limit_exceeded
+        set_error_code :coupon_code_max_usage
+      end
+
+      def ineligible_for_this_order
+        set_error_code :coupon_code_not_eligible
+      end
+
+      def promotion_applied
+        set_error_code :coupon_code_already_applied
+      end
+
+      def promotion_exists_on_order?(order, promotion)
+        order.promotions.include? promotion
+      end
+    end
+  end
+end

data/app/models/spree/promotion_handler/free_shipping.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Spree::PromotionHandler
+  FreeShipping = ActiveSupport::Deprecation::DeprecatedConstantProxy.new(
+    'Spree::PromotionHandler::FreeShipping',
+    'Spree::PromotionHandler::Shipping',
+    Spree::Deprecation,
+  )
+end

data/app/models/spree/promotion_handler/page.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Spree
+  module PromotionHandler
+    class Page
+      attr_reader :order, :path
+
+      def initialize(order, path)
+        @order = order
+        @path = path.gsub(/\A\//, '')
+      end
+
+      def activate
+        if promotion && promotion.eligible?(order)
+          promotion.activate(order: order)
+        end
+      end
+
+      private
+
+      def promotion
+        @promotion ||= Spree::Promotion.active.find_by(path: path)
+      end
+    end
+  end
+end

data/app/models/spree/promotion_handler/shipping.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Spree
+  module PromotionHandler
+    # Used for activating promotions with shipping rules
+    class Shipping
+      attr_reader :order
+      attr_accessor :error, :success
+
+      def initialize(order)
+        @order = order
+      end
+
+      def activate
+        connected_promotions.each do |order_promotion|
+          if order_promotion.promotion.eligible?(order)
+            order_promotion.promotion.activate(
+              order: order,
+              promotion_code: order_promotion.promotion_code,
+            )
+          end
+        end
+
+        not_connected_automatic_promotions.each do |promotion|
+          if promotion.eligible?(order)
+            promotion.activate(order: order)
+          end
+        end
+      end
+
+      private
+
+      def not_connected_automatic_promotions
+        automatic_promotions - connected_promotions.map(&:promotion)
+      end
+
+      def automatic_promotions
+        @automatic_promotions ||= active_shipping_promotions.
+          where(apply_automatically: true).
+          to_a.
+          uniq
+      end
+
+      def connected_promotions
+        @connected_promotions ||= order.order_promotions.
+          joins(:promotion).
+          includes(:promotion).
+          merge(active_shipping_promotions).
+          to_a.
+          uniq
+      end
+
+      def active_shipping_promotions
+        Spree::Promotion.all.
+          active.
+          joins(:promotion_actions).
+          merge(Spree::PromotionAction.shipping)
+      end
+    end
+  end
+end

data/app/models/spree/promotion_rule.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Spree
+  # Base class for all promotion rules
+  class PromotionRule < Spree::Base
+    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules
+
+    scope :of_type, ->(t) { where(type: t) }
+
+    validates :promotion, presence: true
+    validate :unique_per_promotion, on: :create
+
+    def self.for(promotable)
+      all.select { |rule| rule.applicable?(promotable) }
+    end
+
+    def applicable?(_promotable)
+      raise NotImplementedError, "applicable? should be implemented in a sub-class of Spree::PromotionRule"
+    end
+
+    def eligible?(_promotable, _options = {})
+      raise NotImplementedError, "eligible? should be implemented in a sub-class of Spree::PromotionRule"
+    end
+
+    # This states if a promotion can be applied to the specified line item
+    # It is true by default, but can be overridden by promotion rules to provide conditions
+    def actionable?(_line_item)
+      true
+    end
+
+    def eligibility_errors
+      @eligibility_errors ||= ActiveModel::Errors.new(self)
+    end
+
+    def to_partial_path
+      "spree/admin/promotions/rules/#{model_name.element}"
+    end
+
+    private
+
+    def unique_per_promotion
+      if Spree::PromotionRule.exists?(promotion_id: promotion_id, type: self.class.name)
+        errors[:base] << "Promotion already contains this rule type"
+      end
+    end
+
+    def eligibility_error_message(key, options = {})
+      I18n.t(key, { scope: [:spree, :eligibility_errors, :messages] }.merge(options))
+    end
+  end
+end

data/app/models/spree/promotion_rule_role.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Spree
+  class PromotionRuleRole < ActiveRecord::Base
+    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
+    belongs_to :role, class_name: 'Spree::Role'
+  end
+end

data/app/models/spree/promotion_rule_store.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Spree
+  class PromotionRuleStore < Spree::Base
+    self.table_name = "spree_promotion_rules_stores"
+
+    belongs_to :promotion_rule, class_name: "Spree::PromotionRule"
+    belongs_to :store, class_name: "Spree::Store"
+  end
+end

data/app/models/spree/promotion_rule_taxon.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Spree
+  class PromotionRuleTaxon < Spree::Base
+    belongs_to :promotion_rule
+    belongs_to :taxon
+  end
+end

data/app/models/spree/promotion_rule_user.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Spree
+  class PromotionRuleUser < Spree::Base
+    self.table_name = 'spree_promotion_rules_users'
+
+    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
+    belongs_to :user, class_name: Spree::UserClassHandle.new
+  end
+end

data/app/models/spree/property.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Spree
+  class Property < Spree::Base
+    has_many :product_properties, dependent: :delete_all, inverse_of: :property
+    has_many :products, through: :product_properties
+
+    validates :name, :presentation, presence: true
+
+    scope :sorted, -> { order(:name) }
+
+    after_touch :touch_all_products
+
+    private
+
+    def touch_all_products
+      products.update_all(updated_at: Time.current)
+    end
+  end
+end

data/app/models/spree/refund.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Spree
+  class Refund < Spree::Base
+    belongs_to :payment, inverse_of: :refunds
+    belongs_to :reason, class_name: 'Spree::RefundReason', foreign_key: :refund_reason_id
+    belongs_to :reimbursement, inverse_of: :refunds
+
+    has_many :log_entries, as: :source
+
+    validates :payment, presence: true
+    validates :reason, presence: true
+    validates :transaction_id, presence: true, on: :update # can't require this on create because the before_create needs to run first
+    validates :amount, presence: true, numericality: { greater_than: 0 }
+
+    validate :amount_is_less_than_or_equal_to_allowed_amount, on: :create
+
+    after_create :perform!
+    after_create :create_log_entry
+
+    scope :non_reimbursement, -> { where(reimbursement_id: nil) }
+
+    delegate :currency, to: :payment
+
+    def money
+      Spree::Money.new(amount, { currency: currency })
+    end
+    alias display_amount money
+
+    class << self
+      def total_amount_reimbursed_for(reimbursement)
+        reimbursement.refunds.to_a.sum(&:amount)
+      end
+    end
+
+    def description
+      payment.payment_method.name
+    end
+
+    private
+
+    # attempts to perform the refund.
+    # raises an error if the refund fails.
+    def perform!
+      return true if transaction_id.present?
+
+      credit_cents = money.cents
+
+      @response = process!(credit_cents)
+
+      self.transaction_id = @response.authorization
+      update_columns(transaction_id: transaction_id)
+      update_order
+    end
+
+    # return an activemerchant response object if successful or else raise an error
+    def process!(credit_cents)
+      response = if payment.payment_method.payment_profiles_supported?
+        payment.payment_method.credit(credit_cents, payment.source, payment.transaction_id, { originator: self })
+      else
+        payment.payment_method.credit(credit_cents, payment.transaction_id, { originator: self })
+      end
+
+      if !response.success?
+        logger.error(I18n.t('spree.gateway_error') + "  #{response.to_yaml}")
+        text = response.params['message'] || response.params['response_reason_text'] || response.message
+        raise Core::GatewayError.new(text)
+      end
+
+      response
+    rescue ActiveMerchant::ConnectionError => e
+      logger.error(I18n.t('spree.gateway_error') + "  #{e.inspect}")
+      raise Core::GatewayError.new(I18n.t('spree.unable_to_connect_to_gateway'))
+    end
+
+    def create_log_entry
+      log_entries.create!(details: @response.to_yaml)
+    end
+
+    def amount_is_less_than_or_equal_to_allowed_amount
+      if payment && amount > payment.credit_allowed
+        errors.add(:amount, :greater_than_allowed)
+      end
+    end
+
+    def update_order
+      payment.order.updater.update
+    end
+  end
+end

data/app/models/spree/refund_reason.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Spree
+  class RefundReason < Spree::Base
+    include Spree::NamedType
+
+    RETURN_PROCESSING_REASON = 'Return processing'
+
+    has_many :refunds
+
+    def self.return_processing_reason
+      find_by!(name: RETURN_PROCESSING_REASON, mutable: false)
+    end
+  end
+end

data/app/models/spree/reimbursement/credit.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Spree
+  class Reimbursement < Spree::Base
+    class Credit < Spree::Base
+      class_attribute :default_creditable_class
+      self.default_creditable_class = Spree::StoreCredit
+
+      belongs_to :reimbursement, inverse_of: :credits
+      belongs_to :creditable, polymorphic: true
+
+      validates :creditable, presence: true
+
+      class << self
+        def total_amount_reimbursed_for(reimbursement)
+          reimbursement.credits.to_a.sum(&:amount)
+        end
+      end
+
+      def description
+        creditable.class.name.demodulize
+      end
+
+      def display_amount
+        Spree::Money.new(amount, { currency: creditable.try(:currency) || "USD" })
+      end
+    end
+  end
+end