solidus_core 1.0.0.pre

data/app/models/spree/product_option_type.rb

@@ -0,0 +1,7 @@
+module Spree
+  class ProductOptionType < Spree::Base
+    belongs_to :product, class_name: 'Spree::Product', inverse_of: :product_option_types
+    belongs_to :option_type, class_name: 'Spree::OptionType', inverse_of: :product_option_types
+    acts_as_list scope: :product
+  end
+end

data/app/models/spree/product_property.rb

@@ -0,0 +1,25 @@
+module Spree
+  class ProductProperty < Spree::Base
+    belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :product_properties
+    belongs_to :property, class_name: 'Spree::Property', inverse_of: :product_properties
+
+    validates :property, presence: true
+    validates :value, length: { maximum: 255 }
+
+    default_scope -> { order("#{self.table_name}.position") }
+
+    # virtual attributes for use with AJAX completion stuff
+    def property_name
+      property.name if property
+    end
+
+    def property_name=(name)
+      unless name.blank?
+        unless property = Property.find_by(name: name)
+          property = Property.create(name: name, presentation: name)
+        end
+        self.property = property
+      end
+    end
+  end
+end

data/app/models/spree/product_scope/scopes.rb

@@ -0,0 +1,47 @@
+module Spree
+  class ProductScope < Spree::Base
+    before_validation(:on => :create) do
+      # Add default empty arguments so scope validates and errors aren't caused when previewing it
+      if name && args = self.class.arguments_for_scope_name(name)
+        self.arguments ||= ['']*args.length
+      end
+    end
+
+    def self.all_scopes
+      {
+        # Scopes for selecting products based on taxon
+        :taxon => {
+          :taxons_name_eq => [:taxon_name],
+          :in_taxons => [:taxon_names],
+        },
+        # product selection based on name, or search
+        :search => {
+          :in_name => [:words],
+          :in_name_or_keywords => [:words],
+          :in_name_or_description => [:words],
+          :with_ids => [:ids]
+        },
+        # Scopes for selecting products based on option types and properties
+        :values => {
+          :with => [:value],
+          :with_property => [:property],
+          :with_property_value => [:property, :value],
+          :with_option => [:option],
+          :with_option_value => [:option, :value],
+        },
+        # product selection based upon master price
+        :price => {
+          :price_between => [:low, :high],
+          :master_price_lte => [:amount],
+          :master_price_gte => [:amount],
+        },
+      }
+    end
+
+    def self.arguments_for_scope_name(name)
+      if group = all_scopes.detect { |k,v| v[name.to_sym] }
+        group[1][name.to_sym]
+      end
+    end
+  end
+end

data/app/models/spree/promotion.rb

@@ -0,0 +1,229 @@
+module Spree
+  class Promotion < Spree::Base
+    MATCH_POLICIES = %w(all any)
+    UNACTIVATABLE_ORDER_STATES = ["complete", "awaiting_return", "returned"]
+
+    attr_reader :eligibility_errors
+
+    belongs_to :promotion_category
+
+    has_many :promotion_rules, autosave: true, dependent: :destroy
+    alias_method :rules, :promotion_rules
+
+    has_many :promotion_actions, autosave: true, dependent: :destroy
+    alias_method :actions, :promotion_actions
+
+    has_many :order_promotions, class_name: "Spree::OrderPromotion"
+    has_many :orders, through: :order_promotions
+
+    has_many :codes, class_name: "Spree::PromotionCode", inverse_of: :promotion
+    alias_method :promotion_codes, :codes
+
+    accepts_nested_attributes_for :promotion_actions, :promotion_rules
+
+    validates_associated :rules
+
+    validates :name, presence: true
+    validates :path, uniqueness: { allow_blank: true }
+    validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
+    validates :per_code_usage_limit, numericality: { greater_than_or_equal_to: 0, allow_nil: true }
+    validates :description, length: { maximum: 255 }
+
+    before_save :normalize_blank_values
+
+    scope :coupons, -> { where.not(code: nil) }
+    scope :advertised, -> { where(advertise: true) }
+    scope :active, -> do
+      table = self.arel_table
+      time = Time.current
+      where(table[:starts_at].eq(nil).or(table[:starts_at].lt(time))).
+        where(table[:expires_at].eq(nil).or(table[:expires_at].gt(time)))
+    end
+    scope :applied, -> { joins(:order_promotions).uniq }
+
+    # temporary code. remove after the column is dropped from the db.
+    def columns
+      super.reject { |column| column.name == "code" }
+    end
+
+    def self.order_activatable?(order)
+      order && !UNACTIVATABLE_ORDER_STATES.include?(order.state)
+    end
+
+    def code
+      raise "Attempted to call code on a Spree::Promotion. Promotions are now tied to multiple code records"
+    end
+
+    def code=(val)
+      raise "Attempted to call code= on a Spree::Promotion. Promotions are now tied to multiple code records"
+    end
+
+    def self.with_coupon_code(val)
+      joins(:codes).where(
+        PromotionCode.arel_table[:value].eq(val.downcase)
+      ).first
+    end
+
+    def as_json(options={})
+      options[:except] ||= :code
+      super
+    end
+
+    def expired?
+      !active?
+    end
+
+    def active?
+      (starts_at.nil? || starts_at < Time.current) &&
+        (expires_at.nil? || expires_at > Time.current)
+    end
+
+    def activate(order:, line_item: nil, user: nil, path: nil, promotion_code: nil)
+      return unless self.class.order_activatable?(order)
+
+      payload = {
+        order: order,
+        promotion: self,
+        line_item: line_item,
+        user: user,
+        path: path,
+        promotion_code: promotion_code,
+      }
+
+      # Track results from actions to see if any action has been taken.
+      # Actions should return nil/false if no action has been taken.
+      # If an action returns true, then an action has been taken.
+      results = actions.map do |action|
+        action.perform(payload)
+      end
+      # If an action has been taken, report back to whatever activated this promotion.
+      action_taken = results.include?(true)
+
+      if action_taken
+        # connect to the order
+        order_promotions.find_or_create_by!(
+          order_id: order.id,
+          promotion_code_id: promotion_code.try!(:id),
+        )
+      end
+
+      return action_taken
+    end
+
+    # called anytime order.update! happens
+    def eligible?(promotable, promotion_code: nil)
+      return false if expired?
+      return false if usage_limit_exceeded?
+      return false if promotion_code && promotion_code.usage_limit_exceeded?
+      return false if blacklisted?(promotable)
+      !!eligible_rules(promotable, {})
+    end
+
+    # eligible_rules returns an array of promotion rules where eligible? is true for the promotable
+    # if there are no such rules, an empty array is returned
+    # if the rules make this promotable ineligible, then nil is returned (i.e. this promotable is not eligible)
+    def eligible_rules(promotable, options = {})
+      # Promotions without rules are eligible by default.
+      return [] if rules.none?
+      eligible = lambda { |r| r.eligible?(promotable, options) }
+      specific_rules = rules.for(promotable)
+      return [] if specific_rules.none?
+
+      if match_all?
+        # If there are rules for this promotion, but no rules for this
+        # particular promotable, then the promotion is ineligible by default.
+        unless specific_rules.all?(&eligible)
+          @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
+          return nil
+        end
+        specific_rules
+      else
+        unless specific_rules.any?(&eligible)
+          @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
+          return nil
+        end
+        specific_rules.select(&eligible)
+      end
+    end
+
+    def products
+      rules.where(type: "Spree::Promotion::Rules::Product").map(&:products).flatten.uniq
+    end
+
+    # Whether the promotion has exceeded it's 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
+      Spree::Adjustment.eligible.
+        promotion.
+        where(source_id: actions.map(&:id)).
+        joins(:order).
+        merge(Spree::Order.complete).
+        distinct.
+        count(:order_id)
+    end
+
+    # TODO: specs
+    def line_item_actionable?(order, line_item, promotion_code: nil)
+      if eligible?(order, promotion_code: promotion_code)
+        rules = eligible_rules(order)
+        if rules.blank?
+          true
+        else
+          rules.send(match_all? ? :all? : :any?) do |rule|
+            rule.actionable? line_item
+          end
+        end
+      else
+        false
+      end
+    end
+
+    def used_by?(user, excluded_orders = [])
+      [
+        :adjustments,
+        :line_item_adjustments,
+        :shipment_adjustments
+      ].any? do |adjustment_type|
+        user.orders.complete.joins(adjustment_type).where(
+          spree_adjustments: {
+            source_type: "Spree::PromotionAction",
+            source_id: actions.map(&:id),
+            eligible: true
+          }
+        ).where.not(
+          id: excluded_orders.map(&:id)
+        ).any?
+      end
+    end
+
+    private
+
+    def blacklisted?(promotable)
+      case promotable
+      when Spree::LineItem
+        !promotable.product.promotionable?
+      when Spree::Order
+        promotable.line_items.any? &&
+          promotable.line_items.joins(:product).where(spree_products: {promotionable: false}).any?
+      end
+    end
+
+    def normalize_blank_values
+      self[:path] = nil if self[:path].blank?
+    end
+
+    def match_all?
+      match_policy == "all"
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Spree
+  class Promotion
+    module Actions
+      class CreateAdjustment < PromotionAction
+        include Spree::CalculatedAdjustments
+        include Spree::AdjustmentSource
+
+        has_many :adjustments, as: :source
+
+        delegate :eligible?, to: :promotion
+
+        before_validation :ensure_action_has_calculator
+        before_destroy :deals_with_adjustments_for_deleted_source
+
+        # Creates the adjustment related to a promotion for the order passed
+        # through options hash
+        #
+        # Returns `true` if an adjustment is applied to an order,
+        # `false` if the promotion has already been applied.
+        def perform(options = {})
+          order = options[:order]
+          return if promotion_credit_exists?(order)
+
+          amount = compute_amount(order)
+          return if amount == 0
+          Spree::Adjustment.create!(
+            amount: amount,
+            order: order,
+            adjustable: order,
+            source: self,
+            promotion_code: options[:promotion_code],
+            label: "#{Spree.t(:promotion)} (#{promotion.name})"
+          )
+          true
+        end
+
+        # Ensure a negative amount which does not exceed the sum of the order's
+        # item_total and ship_total
+        def compute_amount(calculable)
+          amount = self.calculator.compute(calculable).to_f.abs
+          [(calculable.item_total + calculable.ship_total), amount].min * -1
+        end
+
+        private
+
+        # Tells us if there if the specified promotion is already associated with the line item
+        # regardless of whether or not its currently eligible. Useful because generally
+        # you would only want a promotion action to apply to order no more than once.
+        #
+        # Receives an adjustment +source+ (here a PromotionAction object) and tells
+        # if the order has adjustments from that already
+        def promotion_credit_exists?(adjustable)
+          self.adjustments.where(adjustable_id: adjustable.id).exists?
+        end
+
+        def ensure_action_has_calculator
+          return if self.calculator
+          self.calculator = Calculator::FlatPercentItemTotal.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+module Spree
+  class Promotion
+    module Actions
+      class CreateItemAdjustments < PromotionAction
+        include Spree::CalculatedAdjustments
+        include Spree::AdjustmentSource
+
+        has_many :adjustments, as: :source
+
+        delegate :eligible?, to: :promotion
+
+        before_validation :ensure_action_has_calculator
+        before_destroy :deals_with_adjustments_for_deleted_source
+
+        def perform(payload = {})
+          order = payload[:order]
+          promotion = payload[:promotion]
+          promotion_code = payload[:promotion_code]
+
+          result = false
+
+          line_items_to_adjust(promotion, order).each do |line_item|
+            current_result = create_adjustment(line_item, order, promotion_code)
+            result ||= current_result
+          end
+          return result
+        end
+
+        # Ensure a negative amount which does not exceed the sum of the order's
+        # item_total and ship_total
+        def compute_amount(adjustable)
+          order = adjustable.is_a?(Order) ? adjustable : adjustable.order
+          return 0 unless promotion.line_item_actionable?(order, adjustable)
+          promotion_amount = self.calculator.compute(adjustable).to_f.abs
+          [adjustable.amount, promotion_amount].min * -1
+        end
+
+        private
+
+        def create_adjustment(adjustable, order, promotion_code)
+          amount = self.compute_amount(adjustable)
+          return if amount == 0
+          self.adjustments.create!(
+            amount: amount,
+            adjustable: adjustable,
+            order: order,
+            promotion_code: promotion_code,
+            label: "#{Spree.t(:promotion)} (#{promotion.name})",
+          )
+          true
+        end
+
+        # Tells us if there if the specified promotion is already associated with the line item
+        # regardless of whether or not its currently eligible. Useful because generally
+        # you would only want a promotion action to apply to line item no more than once.
+        #
+        # Receives an adjustment +source+ (here a PromotionAction object) and tells
+        # if the order has adjustments from that already
+        def promotion_credit_exists?(adjustable)
+          self.adjustments.where(adjustable_id: adjustable.id).exists?
+        end
+
+        def ensure_action_has_calculator
+          return if self.calculator
+          self.calculator = Calculator::PercentOnLineItem.new
+        end
+
+        def line_items_to_adjust(promotion, order)
+          excluded_ids = self.adjustments.
+            where(adjustable_id: order.line_items.pluck(:id), adjustable_type: 'Spree::LineItem').
+            pluck(:adjustable_id)
+
+          order.line_items.where.not(id: excluded_ids).select do |line_item|
+            promotion.line_item_actionable? order, line_item
+          end
+        end
+      end
+    end
+  end
+end