goca-spree-core 3.1.14.rails.5.0

data/app/models/spree/product_property.rb

@@ -0,0 +1,28 @@
+module Spree
+  class ProductProperty < Spree::Base
+    acts_as_list scope: :product
+
+    with_options inverse_of: :product_properties do
+      belongs_to :product, touch: true, class_name: 'Spree::Product'
+      belongs_to :property, class_name: 'Spree::Property'
+    end
+
+    validates :property, presence: true
+
+    validates :value, db_maximum_length: true
+
+    default_scope { order(:position) }
+
+    self.whitelisted_ransackable_attributes = ['value']
+
+    # virtual attributes for use with AJAX completion stuff
+    delegate :name, to: :property, prefix: true, allow_nil: true
+
+    def property_name=(name)
+      if name.present?
+        # don't use `find_by :name` to workaround globalize/globalize#423 bug
+        self.property = Property.where(name: name).first_or_create(presentation: name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Spree
+  class Promotion
+    module Actions
+      class CreateAdjustment < PromotionAction
+        include Spree::CalculatedAdjustments
+        include Spree::AdjustmentSource
+
+        before_validation -> { self.calculator ||= Calculator::FlatPercentItemTotal.new }
+
+        def perform(options = {})
+          order = options[:order]
+          create_unique_adjustment(order, order)
+        end
+
+        def compute_amount(order)
+          [(order.item_total + order.ship_total), compute(order)].min * -1
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Spree
+  class Promotion
+    module Actions
+      class CreateItemAdjustments < PromotionAction
+        include Spree::CalculatedAdjustments
+        include Spree::AdjustmentSource
+
+        before_validation -> { self.calculator ||= Calculator::PercentOnLineItem.new }
+
+        def perform(options = {})
+          order, promotion = options[:order], options[:promotion]
+          create_unique_adjustments(order, order.line_items) do |line_item|
+            promotion.line_item_actionable?(order, line_item)
+          end
+        end
+
+        def compute_amount(line_item)
+          return 0 unless promotion.line_item_actionable?(line_item.order, line_item)
+          [line_item.amount, compute(line_item)].min * -1
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Spree
+  class Promotion
+    module Actions
+      class CreateLineItems < PromotionAction
+        has_many :promotion_action_line_items, foreign_key: :promotion_action_id
+        accepts_nested_attributes_for :promotion_action_line_items
+
+        delegate :eligible?, :to => :promotion
+
+        # Adds a line item to the Order if the promotion is eligible
+        #
+        # This doesn't play right with Add to Cart events because at the moment
+        # the item was added to cart the promo may not be eligible. However it
+        # might become eligible as the order gets updated.
+        #
+        # e.g.
+        #   - A promo adds a line item to cart if order total greater then $30
+        #   - Customer add 1 item of $10 to cart
+        #   - This action shouldn't perform because the order is not eligible
+        #   - Customer increases item quantity to 5 (order total goes to $50)
+        #   - Now the order is eligible for the promo and the action should perform
+        #
+        # Another complication is when the same line item created by the promo
+        # is also added to cart on a separate action.
+        #
+        # e.g.
+        #   - Promo adds 1 item A to cart if order total greater then $30
+        #   - Customer add 2 items B to cart, current order total is $40
+        #   - This action performs adding item A to cart since order is eligible
+        #   - Customer changes his mind and updates item B quantity to 1
+        #   - At this point order is no longer eligible and one might expect
+        #     that item A should be removed
+        #
+        # It doesn't remove items from the order here because there's no way
+        # it can know whether that item was added via this promo action or if
+        # it was manually populated somewhere else. In that case the item
+        # needs to be manually removed from the order by the customer
+        def perform(options = {})
+          order = options[:order]
+          return unless self.eligible? order
+
+          action_taken = false
+          promotion_action_line_items.each do |item|
+            current_quantity = order.quantity_of(item.variant)
+            if current_quantity < item.quantity && item_available?(item)
+              line_item = order.contents.add(item.variant, item.quantity - current_quantity)
+              action_taken = true if line_item.try(:valid?)
+            end
+          end
+          action_taken
+        end
+
+        # Checks that there's enough stock to add the line item to the order
+        def item_available?(item)
+          quantifier = Spree::Stock::Quantifier.new(item.variant)
+          quantifier.can_supply? item.quantity
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Spree
+  class Promotion
+    module Actions
+      class FreeShipping < Spree::PromotionAction
+        include Spree::AdjustmentSource
+
+        def perform(payload={})
+          order = payload[:order]
+          create_unique_adjustments(order, order.shipments)
+        end
+
+        def compute_amount(shipment)
+          shipment.cost * -1
+        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 @@
+# A rule to apply to an order greater than (or greater than or equal to)
+# a specific amount
+module Spree
+  class Promotion
+    module Rules
+      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).empty?
+        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 :preferred_eligible_values, :preferred_eligible_values_with_numerification
+        alias_method :preferred_eligible_values_without_numerification, :preferred_eligible_values
+
+        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,65 @@
+# 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.
+module Spree
+  class Promotion
+    module Rules
+      class Product < PromotionRule
+        has_many :product_promotion_rules, class_name: 'Spree::ProductPromotionRule',
+                                           foreign_key: :promotion_rule_id
+        has_many :products, through: :product_promotion_rules, class_name: 'Spree::Product'
+
+        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,70 @@
+module Spree
+  class Promotion
+    module Rules
+      class Taxon < PromotionRule
+        has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon', foreign_key: 'promotion_rule_id'
+        has_many :taxons, through: :promotion_rule_taxons, class_name: 'Spree::Taxon'
+
+        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

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_many :promotion_rule_users, class_name: 'Spree::PromotionRuleUser',
+                                        foreign_key: :promotion_rule_id,
+                                        dependent: :destroy
+        has_many :users, through: :promotion_rule_users, class_name: "::#{Spree.user_class.to_s}"
+
+        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