solidus_core 1.0.0.pre

data/app/models/spree/promotion/actions/create_quantity_adjustments.rb

@@ -0,0 +1,129 @@
+module Spree::Promotion::Actions
+  class CreateQuantityAdjustments < CreateItemAdjustments
+    include Spree::CalculatedAdjustments
+
+    preference :group_size, :integer, default: 1
+
+    has_many :line_item_actions, foreign_key: :action_id, dependent: :destroy
+    has_many :line_items, through: :line_item_actions
+
+    ##
+    # Computes the amount for the adjustment based on the line item and any
+    # other applicable items in the order. The rules for this specific
+    # adjustment are as follows:
+    #
+    # = Setup
+    #
+    # We have a quantity group promotion on t-shirts. If a user orders 3
+    # t-shirts, they get $5 off of each. The shirts come in one size and three
+    # colours: red, blue, and white.
+    #
+    # == Scenario 1
+    #
+    # User has 2 red shirts, 1 white shirt, and 1 blue shirt in their
+    # order. We want to compute the adjustment amount for the white shirt.
+    #
+    # *Result:* -$5
+    #
+    # *Reasoning:* There are a total of 4 items that are eligible for the
+    # promotion. Since that is greater than 3, we can discount the items. The
+    # white shirt has a quantity of 1, therefore it will get discounted by
+    # +adjustment_amount * 1+ or $5.
+    #
+    # === Scenario 1-1
+    #
+    # What about the blue shirt? How much does it get discounted?
+    #
+    # *Result:* $0
+    #
+    # *Reasoning:* We have a total quantity of 4. However, we only apply the
+    # adjustment to groups of 3. Assuming the white and red shirts have already
+    # had their adjustment calculated, that means 3 units have been discounted.
+    # Leaving us with a lonely blue shirt that isn't part of a group of 3.
+    # Therefore, it does not receive the discount.
+    #
+    # == Scenario 2
+    #
+    # User has 4 red shirts in their order. What is the amount?
+    #
+    # *Result:* -$15
+    #
+    # *Reasoning:* The total quantity of eligible items is 4, so we the
+    # adjustment will be non-zero. However, we only apply it to groups of 3,
+    # therefore there is one extra item that is not eligible for the
+    # adjustment. +adjustment_amount * 3+ or $15.
+    #
+    def compute_amount(line_item)
+      adjustment_amount = calculator.compute(PartialLineItem.new(line_item)).to_f.abs
+
+      order = line_item.order
+      line_items = actionable_line_items(order)
+
+      actioned_line_items = order.line_item_adjustments(true).
+        select { |a| a.source == self && a.amount < 0 }.
+        map(&:adjustable)
+      other_line_items = actioned_line_items - [line_item]
+
+      applicable_quantity = total_applicable_quantity(line_items)
+      used_quantity = total_used_quantity(other_line_items)
+      usable_quantity = [
+        applicable_quantity - used_quantity,
+        line_item.quantity
+      ].min
+
+      persist_quantity(usable_quantity,  line_item)
+
+      amount = adjustment_amount * usable_quantity
+      [line_item.amount, amount].min * -1
+    end
+
+    private
+
+    def actionable_line_items(order)
+      order.line_items(true).select do |item|
+        promotion.line_item_actionable? order, item
+      end
+    end
+
+    def total_applicable_quantity(line_items)
+      total_quantity = line_items.sum(&:quantity)
+      extra_quantity = total_quantity % preferred_group_size
+
+      total_quantity - extra_quantity
+    end
+
+    def total_used_quantity(line_items)
+      line_item_actions.where(
+        line_item_id: line_items.map(&:id)
+      ).sum(:quantity)
+    end
+
+    def persist_quantity(quantity, line_item)
+      line_item_action = line_item_actions.where(
+        line_item_id: line_item.id
+      ).first_or_initialize
+      line_item_action.quantity = quantity
+      line_item_action.save!
+    end
+
+    ##
+    # Used specifically for PercentOnLineItem calculator. That calculator uses
+    # `line_item.amount`, however we might not necessarily want to discount the
+    # entire amount. This class allows us to determine the discount per
+    # quantity and then calculate the adjustment amount the way we normally do
+    # for flat rate adjustments.
+    class PartialLineItem
+      def initialize(line_item)
+        @line_item = line_item
+      end
+
+      def amount
+        @line_item.price
+      end
+
+      def currency
+        @line_item.currency
+      end
+    end
+  end
+end

data/app/models/spree/promotion/actions/free_shipping.rb

@@ -0,0 +1,41 @@
+module Spree
+  class Promotion
+    module Actions
+      class FreeShipping < Spree::PromotionAction
+        def perform(payload={})
+          order = payload[:order]
+          promotion_code = payload[:promotion_code]
+
+          results = order.shipments.map do |shipment|
+            return false if promotion_credit_exists?(shipment)
+            shipment.adjustments.create!(
+              order: shipment.order,
+              amount: compute_amount(shipment),
+              source: self,
+              promotion_code: promotion_code,
+              label: label,
+            )
+            true
+          end
+          # Did we actually end up applying any adjustments?
+          # If so, then this action should be classed as 'successful'
+          results.any? { |r| r == true }
+        end
+
+        def label
+          "#{Spree.t(:promotion)} (#{promotion.name})"
+        end
+
+        def compute_amount(shipment)
+          shipment.cost * -1
+        end
+
+        private
+
+        def promotion_credit_exists?(shipment)
+          shipment.adjustments.where(:source_id => self.id).exists?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Spree
+  class Promotion
+    module Rules
+      class FirstOrder < PromotionRule
+        attr_reader :user, :email
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, options = {})
+          @user = order.try(:user) || options[:user]
+          @email = order.email
+
+          if user || email
+            if !completed_orders.blank? && completed_orders.first != order
+              eligibility_errors.add(:base, eligibility_error_message(:not_first_order))
+            end
+          else
+            eligibility_errors.add(:base, eligibility_error_message(:no_user_or_email_specified))
+          end
+
+          eligibility_errors.empty?
+        end
+
+        private
+          def completed_orders
+            user ? user.orders.complete : orders_by_email
+          end
+
+          def orders_by_email
+            Spree::Order.where(email: email).complete
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Spree
+  class Promotion
+    module Rules
+      # A rule to apply to an order greater than (or greater than or equal to)
+      # a specific amount
+      class ItemTotal < PromotionRule
+        preference :amount_min, :decimal, default: 100.00
+        preference :operator_min, :string, default: '>'
+        preference :amount_max, :decimal, default: 1000.00
+        preference :operator_max, :string, default: '<'
+
+
+        OPERATORS_MIN = ['gt', 'gte']
+        OPERATORS_MAX = ['lt','lte']
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, options = {})
+          item_total = order.item_total
+
+          lower_limit_condition = item_total.send(preferred_operator_min == 'gte' ? :>= : :>, BigDecimal.new(preferred_amount_min.to_s))
+          upper_limit_condition = item_total.send(preferred_operator_max == 'lte' ? :<= : :<, BigDecimal.new(preferred_amount_max.to_s))
+
+          eligibility_errors.add(:base, ineligible_message_max) unless upper_limit_condition
+          eligibility_errors.add(:base, ineligible_message_min) unless lower_limit_condition
+
+          eligibility_errors.empty?
+        end
+
+        private
+        def formatted_amount_min
+          Spree::Money.new(preferred_amount_min).to_s
+        end
+
+        def formatted_amount_max
+          Spree::Money.new(preferred_amount_max).to_s
+        end
+
+
+        def ineligible_message_max
+          if preferred_operator_max == 'gte'
+            eligibility_error_message(:item_total_more_than_or_equal, amount: formatted_amount_max)
+          else
+            eligibility_error_message(:item_total_more_than, amount: formatted_amount_max)
+          end
+        end
+
+        def ineligible_message_min
+          if preferred_operator_min == 'gte'
+            eligibility_error_message(:item_total_less_than, amount: formatted_amount_min)
+          else
+            eligibility_error_message(:item_total_less_than_or_equal, amount: formatted_amount_min)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Spree
+  class Promotion
+    module Rules
+      class OneUsePerUser < PromotionRule
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, options = {})
+          if order.user.present?
+            if promotion.used_by?(order.user, [order])
+              eligibility_errors.add(:base, eligibility_error_message(:limit_once_per_user))
+            end
+          else
+            eligibility_errors.add(:base, eligibility_error_message(:no_user_specified))
+          end
+
+          eligibility_errors.empty?
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,50 @@
+module Spree
+  class Promotion
+    module Rules
+      class OptionValue < PromotionRule
+        MATCH_POLICIES = %w(any)
+        preference :match_policy, :string, default: MATCH_POLICIES.first
+        preference :eligible_values, :hash
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(promotable, options = {})
+          case preferred_match_policy
+          when 'any'
+            promotable.line_items.any? { |item| actionable?(item) }
+          end
+        end
+
+        def actionable?(line_item)
+
+          pid = line_item.product.id
+          ovids = line_item.variant.option_values.pluck(:id)
+
+          product_ids.include?(pid) && (value_ids(pid) & ovids).present?
+        end
+
+        def preferred_eligible_values_with_numerification
+          values = preferred_eligible_values_without_numerification || {}
+          Hash[values.keys.map(&:to_i).zip(
+            values.values.map do |v|
+              (v.is_a?(Array) ? v : v.split(",")).map(&:to_i)
+            end
+          )]
+        end
+        alias_method_chain :preferred_eligible_values, :numerification
+
+        private
+
+        def product_ids
+          preferred_eligible_values.keys
+        end
+
+        def value_ids(product_id)
+          preferred_eligible_values[product_id]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Spree
+  class Promotion
+    module Rules
+      # A rule to limit a promotion based on products in the order.  Can
+      # require all or any of the products to be present.  Valid products
+      # either come from assigned product group or are assingned directly to
+      # the rule.
+      class Product < PromotionRule
+        has_and_belongs_to_many :products, class_name: '::Spree::Product', join_table: 'spree_products_promotion_rules', foreign_key: 'promotion_rule_id'
+
+        MATCH_POLICIES = %w(any all none)
+        preference :match_policy, :string, default: MATCH_POLICIES.first
+
+        # scope/association that is used to test eligibility
+        def eligible_products
+          products
+        end
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, options = {})
+          return true if eligible_products.empty?
+
+          if preferred_match_policy == 'all'
+            unless eligible_products.all? {|p| order.products.include?(p) }
+              eligibility_errors.add(:base, eligibility_error_message(:missing_product))
+            end
+          elsif preferred_match_policy == 'any'
+            unless order.products.any? {|p| eligible_products.include?(p) }
+              eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products))
+            end
+          else
+            unless order.products.none? {|p| eligible_products.include?(p) }
+              eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product))
+            end
+          end
+
+          eligibility_errors.empty?
+        end
+
+        def actionable?(line_item)
+          case preferred_match_policy
+          when 'any', 'all'
+            product_ids.include? line_item.variant.product_id
+          when 'none'
+            product_ids.exclude? line_item.variant.product_id
+          else
+            raise "unexpected match policy: #{preferred_match_policy.inspect}"
+          end
+        end
+
+        def product_ids_string
+          product_ids.join(',')
+        end
+
+        def product_ids_string=(s)
+          self.product_ids = s.to_s.split(',').map(&:strip)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module Spree
+  class Promotion
+    module Rules
+      class Taxon < PromotionRule
+        has_and_belongs_to_many :taxons, class_name: '::Spree::Taxon', join_table: 'spree_taxons_promotion_rules', foreign_key: 'promotion_rule_id'
+
+        MATCH_POLICIES = %w(any all)
+        preference :match_policy, default: MATCH_POLICIES.first
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, options = {})
+          if preferred_match_policy == 'all'
+            unless (taxons.to_a - taxons_in_order_including_parents(order)).empty?
+              eligibility_errors.add(:base, eligibility_error_message(:missing_taxon))
+            end
+          else
+            order_taxons = taxons_in_order_including_parents(order)
+            unless taxons.any?{ |taxon| order_taxons.include? taxon }
+              eligibility_errors.add(:base, eligibility_error_message(:no_matching_taxons))
+            end
+          end
+
+          eligibility_errors.empty?
+        end
+
+        def actionable?(line_item)
+          taxon_product_ids.include? line_item.variant.product_id
+        end
+
+        def taxon_ids_string
+          taxons.pluck(:id).join(',')
+        end
+
+        def taxon_ids_string=(s)
+          ids = s.to_s.split(',').map(&:strip)
+          self.taxons = Spree::Taxon.find(ids)
+        end
+
+        private
+
+        # All taxons in an order
+        def order_taxons(order)
+          Spree::Taxon.joins(products: {variants_including_master: :line_items}).where(spree_line_items: {order_id: order.id}).uniq
+        end
+
+        # ids of taxons rules and taxons rules children
+        def taxons_including_children_ids
+          taxons.inject([]){ |ids,taxon| ids += taxon.self_and_descendants.ids }
+        end
+
+        # taxons order vs taxons rules and taxons rules children
+        def order_taxons_in_taxons_and_children(order)
+          order_taxons(order).where(id: taxons_including_children_ids)
+        end
+
+        def taxons_in_order_including_parents(order)
+          order_taxons_in_taxons_and_children(order).inject([]){ |taxons, taxon| taxons << taxon.self_and_ancestors }.flatten.uniq
+        end
+
+        def taxon_product_ids
+          Spree::Product.joins(:taxons).where(spree_taxons: {id: taxons.pluck(:id)}).pluck(:id).uniq
+        end
+      end
+    end
+  end
+end