solidus_core 1.0.0.pre

data/app/models/spree/promotion/rules/user.rb

@@ -0,0 +1,30 @@
+module Spree
+  class Promotion
+    module Rules
+      class User < PromotionRule
+        belongs_to :user, class_name: "::#{Spree.user_class.to_s}"
+
+        has_and_belongs_to_many :users, class_name: "::#{Spree.user_class.to_s}",
+          join_table: 'spree_promotion_rules_users',
+          foreign_key: 'promotion_rule_id',
+          association_foreign_key: :user_id
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, options = {})
+          users.include?(order.user)
+        end
+
+        def user_ids_string
+          user_ids.join(',')
+        end
+
+        def user_ids_string=(s)
+          self.user_ids = s.to_s.split(',').map(&:strip)
+        end
+      end
+    end
+  end
+end

data/app/models/spree/promotion/rules/user_logged_in.rb

@@ -0,0 +1,18 @@
+module Spree
+  class Promotion
+    module Rules
+      class UserLoggedIn < PromotionRule
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, options = {})
+          unless order.user.present?
+            eligibility_errors.add(:base, eligibility_error_message(:no_user_specified))
+          end
+          eligibility_errors.empty?
+        end
+      end
+    end
+  end
+end

data/app/models/spree/promotion_action.rb

@@ -0,0 +1,23 @@
+module Spree
+  # Base class for all types of promotion action.
+  #
+  # PromotionActions perform the necessary tasks when a promotion is activated
+  # by an event and determined to be eligible.
+  class PromotionAction < Spree::Base
+    acts_as_paranoid
+
+    belongs_to :promotion, class_name: 'Spree::Promotion'
+
+    scope :of_type, ->(t) { where(type: t) }
+
+    # Updates the state of the order or performs some other action depending on
+    # the subclass options will contain the payload from the event that
+    # activated the promotion. This will include the key :user which allows
+    # user based actions to be performed in addition to actions on the order
+    #
+    # @note This method should be overriden in subclassses.
+    def perform(options = {})
+      raise 'perform should be implemented in a sub-class of PromotionAction'
+    end
+  end
+end

data/app/models/spree/promotion_builder.rb

@@ -0,0 +1,55 @@
+class Spree::PromotionBuilder
+  include ActiveModel::Model
+
+  attr_reader :promotion
+  attr_accessor :base_code, :number_of_codes, :user
+
+  validates :number_of_codes,
+    numericality: { only_integer: true, greater_than: 0 },
+    allow_nil: true
+
+  validate :promotion_validity
+
+  class_attribute :code_builder_class
+  self.code_builder_class = ::Spree::PromotionCode::CodeBuilder
+
+  # @param promotion_attrs [Hash] The desired attributes for the newly promotion
+  # @param attributes [Hash] The desired attributes for this builder
+  # @param user [Spree::User] The user who triggered this promotion build
+  def initialize(attributes={}, promotion_attributes={})
+    @promotion = Spree::Promotion.new(promotion_attributes)
+    super(attributes)
+  end
+
+  def perform
+    if can_build_codes?
+      @promotion.codes = code_builder.build_promotion_codes
+    end
+
+    return false unless valid?
+
+    @promotion.save
+  end
+
+  def number_of_codes= value
+    @number_of_codes = value.presence.try(:to_i)
+  end
+
+  private
+
+  def promotion_validity
+    if !@promotion.valid?
+      @promotion.errors.each do |attribute, error|
+        errors[attribute].push error
+      end
+    end
+  end
+
+  def can_build_codes?
+    @base_code && @number_of_codes
+  end
+
+  def code_builder
+    self.class.code_builder_class.new(@promotion, @base_code, @number_of_codes)
+  end
+end

data/app/models/spree/promotion_category.rb

@@ -0,0 +1,6 @@
+module Spree
+  class PromotionCategory < Spree::Base
+    validates_presence_of :name
+    has_many :promotions
+  end
+end

data/app/models/spree/promotion_chooser.rb

@@ -0,0 +1,30 @@
+module Spree
+  class PromotionChooser
+    def initialize(adjustments)
+      @adjustments = adjustments
+    end
+
+    # Picks the best promotion from this set of adjustments, all others are
+    # marked as ineligible.
+    #
+    # @return [BigDecimal] The amount of the best adjustment
+    def update
+      if best_promotion_adjustment
+        @adjustments.select(&:eligible?).each do |adjustment|
+          next if adjustment == best_promotion_adjustment
+          adjustment.update_columns(eligible: false)
+        end
+        best_promotion_adjustment.amount
+      else
+        BigDecimal.new('0')
+      end
+    end
+
+    # @return The best promotion from this set of adjustments.
+    def best_promotion_adjustment
+      @best_promotion_adjustment ||= @adjustments.select(&:eligible?).min_by do |a|
+        [a.amount, -a.id]
+      end
+    end
+  end
+end

data/app/models/spree/promotion_code.rb

@@ -0,0 +1,39 @@
+class Spree::PromotionCode < ActiveRecord::Base
+  belongs_to :promotion, inverse_of: :codes
+  has_many :adjustments
+
+  validates :value, presence: true, uniqueness: true
+  validates :promotion, presence: true
+
+  before_save :downcase_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 downcase_value
+    self.value = value.downcase
+  end
+end

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

@@ -0,0 +1,62 @@
+# A class responsible for building PromotionCodes
+class ::Spree::PromotionCode::CodeBuilder
+  attr_reader :promotion, :num_codes, :base_code
+
+  class_attribute :random_code_length
+  self.random_code_length = 6
+
+  # Requres a +promotion+, +base_code+ and +num_codes+
+  #
+  # +promotion+ Must be a Spree::Promotion.
+  # +base_code+ Must be a String.
+  # +num_codes+ Must be a positive integer greater than zero.
+  def initialize promotion, base_code, num_codes
+    @base_code = base_code
+    @num_codes = num_codes
+    @promotion = promotion
+  end
+
+  # Builds and returns an array of Spree::PromotionCode's
+  def build_promotion_codes
+    codes.map do |code|
+      promotion.codes.build(value: code)
+    end
+  end
+
+  private
+
+  def codes
+    if num_codes > 1
+      generate_random_codes
+    else
+      [base_code]
+    end
+  end
+
+  def generate_random_codes
+    valid_codes = Set.new
+
+    while valid_codes.size < num_codes do
+      new_codes = num_codes.times.map { generate_random_code }.to_set
+      valid_codes += get_unique_codes(new_codes)
+    end
+
+    valid_codes.to_a.take(num_codes)
+  end
+
+  def generate_random_code
+    suffix = Array.new(self.class.random_code_length) do
+      sample_characters.sample
+    end.join
+
+    "#{@base_code}_#{suffix}"
+  end
+
+  def sample_characters
+    @sample_characters ||= ('a'..'z').to_a
+  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_handler/cart.rb

@@ -0,0 +1,65 @@
+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
+          Promotion.active.includes(:promotion_rules).
+            joins(:order_promotions).
+            where(spree_orders_promotions: { order_id: order.id }).readonly(false).to_a
+        end
+
+        def sale_promotions
+          promo_table = Promotion.arel_table
+          code_table  = PromotionCode.arel_table
+
+          promotion_code_join = promo_table.join(code_table, Arel::Nodes::OuterJoin).on(
+            promo_table[:id].eq(code_table[:promotion_id])
+          ).join_sources
+
+          Promotion.active.includes(:promotion_rules).
+            joins(promotion_code_join).
+            where(
+              code_table[:value].eq(nil).and(
+                promo_table[:path].eq(nil)
+              )
+            ).distinct
+        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,119 @@
+module Spree
+  module PromotionHandler
+    class Coupon
+      attr_reader :order
+      attr_accessor :error, :success, :status_code
+
+      def initialize(order)
+        @order = order
+      end
+
+      def apply
+        if order.coupon_code.present?
+          if promotion.present? && promotion.actions.exists?
+            handle_present_promotion(promotion)
+          else
+            if promotion_code && promotion_code.promotion.expired?
+              set_error_code :coupon_code_expired
+            else
+              set_error_code :coupon_code_not_found
+            end
+          end
+        end
+
+        self
+      end
+
+      def set_success_code(c)
+        @status_code = c
+        @success = Spree.t(c)
+      end
+
+      def set_error_code(c)
+        @status_code = c
+        @error = Spree.t(c)
+      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: order.coupon_code.downcase).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 (self.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
+          determine_promotion_application_result
+        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
+
+      def determine_promotion_application_result
+        detector = lambda { |p|
+          p.source.promotion.codes.any? { |code| code.value == order.coupon_code.downcase }
+        }
+
+        # Check for applied adjustments.
+        discount = order.line_item_adjustments.promotion.detect(&detector)
+        discount ||= order.shipment_adjustments.promotion.detect(&detector)
+        discount ||= order.adjustments.promotion.detect(&detector)
+
+        # Check for applied line items.
+        created_line_items = promotion.actions.detect { |a| a.type == 'Spree::Promotion::Actions::CreateLineItems' }
+
+        if (discount && discount.eligible) || created_line_items
+          order.update_totals
+          order.persist_totals
+          set_success_code :coupon_code_applied
+        else
+          # if the promotion exists on an order, but wasn't found above,
+          # we've already selected a better promotion
+          if order.promotions.with_coupon_code(order.coupon_code)
+            set_error_code :coupon_code_better_exists
+          else
+            # if the promotion was created after the order
+            set_error_code :coupon_code_not_found
+          end
+        end
+      end
+    end
+  end
+end