harpiya_core 4.3.0.alpha

data/app/models/harpiya/product_option_type.rb

@@ -0,0 +1,12 @@
+module Harpiya
+  class ProductOptionType < Harpiya::Base
+    with_options inverse_of: :product_option_types do
+      belongs_to :product, class_name: 'Harpiya::Product'
+      belongs_to :option_type, class_name: 'Harpiya::OptionType'
+    end
+    acts_as_list scope: :product
+
+    validates :product, :option_type, presence: true
+    validates :product_id, uniqueness: { scope: :option_type_id }, allow_nil: true
+  end
+end

data/app/models/harpiya/product_promotion_rule.rb

@@ -0,0 +1,9 @@
+module Harpiya
+  class ProductPromotionRule < Harpiya::Base
+    belongs_to :product, class_name: 'Harpiya::Product'
+    belongs_to :promotion_rule, class_name: 'Harpiya::PromotionRule'
+
+    validates :product, :promotion_rule, presence: true
+    validates :product_id, uniqueness: { scope: :promotion_rule_id }, allow_nil: true
+  end
+end

data/app/models/harpiya/product_property.rb

@@ -0,0 +1,43 @@
+module Harpiya
+  class ProductProperty < Harpiya::Base
+    include Harpiya::FilterParam
+
+    auto_strip_attributes :value
+
+    acts_as_list scope: :product
+
+    with_options inverse_of: :product_properties do
+      belongs_to :product, touch: true, class_name: 'Harpiya::Product'
+      belongs_to :property, touch: true, class_name: 'Harpiya::Property'
+    end
+
+    validates :property, presence: true
+
+    default_scope { order(:position) }
+
+    scope :filterable, -> { joins(:property).where(Property.table_name => { filterable: true }) }
+    scope :for_products, ->(products) { joins(:product).merge(products) }
+
+    self.whitelisted_ransackable_attributes = ['value', 'filter_param']
+    self.whitelisted_ransackable_associations = ['property']
+
+    # virtual attributes for use with AJAX completion stuff
+    delegate :name, :presentation, to: :property, prefix: true, allow_nil: true
+
+    def property_name=(name)
+      ActiveSupport::Deprecation.warn(<<-DEPRECATION, caller)
+        `ProductProperty#property_name=` is deprecated and will be removed in Harpiya 5.0.
+      DEPRECATION
+      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
+
+    protected
+
+    def param_candidate
+      value
+    end
+  end
+end

data/app/models/harpiya/promotion.rb

@@ -0,0 +1,241 @@
+module Harpiya
+  class Promotion < Harpiya::Base
+    MATCH_POLICIES = %w(all any)
+    UNACTIVATABLE_ORDER_STATES = ['complete', 'awaiting_return', 'returned']
+
+    attr_reader :eligibility_errors, :generate_code
+
+    belongs_to :promotion_category, optional: true
+
+    has_many :promotion_rules, autosave: true, dependent: :destroy
+    alias rules promotion_rules
+
+    has_many :promotion_actions, autosave: true, dependent: :destroy
+    alias actions promotion_actions
+
+    has_many :order_promotions, class_name: 'Harpiya::OrderPromotion'
+    has_many :orders, through: :order_promotions, class_name: 'Harpiya::Order'
+
+    accepts_nested_attributes_for :promotion_actions, :promotion_rules
+
+    validates_associated :rules
+
+    validates :name, presence: true
+    validates :path, :code, uniqueness: { case_sensitive: false, allow_blank: true }
+    validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
+    validates :description, length: { maximum: 255 }, allow_blank: true
+    validate :expires_at_must_be_later_than_starts_at, if: -> { starts_at && expires_at }
+
+    before_save :normalize_blank_values
+
+    before_validation :normalize_code
+
+    scope :coupons, -> { where.not(code: nil) }
+    scope :advertised, -> { where(advertise: true) }
+    scope :applied, lambda {
+      joins(<<-SQL).distinct
+        INNER JOIN harpiya_order_promotions
+        ON harpiya_order_promotions.promotion_id = #{table_name}.id
+      SQL
+    }
+
+    self.whitelisted_ransackable_attributes = ['path', 'promotion_category_id', 'code']
+
+    def self.with_coupon_code(coupon_code)
+      where("lower(#{table_name}.code) = ?", coupon_code.strip.downcase).
+        includes(:promotion_actions).where.not(harpiya_promotion_actions: { id: nil }).
+        first
+    end
+
+    def self.active
+      where('harpiya_promotions.starts_at IS NULL OR harpiya_promotions.starts_at < ?', Time.current).
+        where('harpiya_promotions.expires_at IS NULL OR harpiya_promotions.expires_at > ?', Time.current)
+    end
+
+    def self.order_activatable?(order)
+      order && !UNACTIVATABLE_ORDER_STATES.include?(order.state)
+    end
+
+    def generate_code=(generating_code)
+      if ActiveModel::Type::Boolean.new.cast(generating_code)
+        self.code = random_code
+      end
+    end
+
+    def expired?
+      !!(starts_at && Time.current < starts_at || expires_at && Time.current > expires_at)
+    end
+
+    def activate(payload)
+      order = payload[:order]
+      return unless self.class.order_activatable?(order)
+
+      payload[:promotion] = self
+
+      # 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
+        # create the join_table entry.
+        orders << order
+        save
+      end
+
+      action_taken
+    end
+
+    # Called when a promotion is removed from the cart
+    def deactivate(payload)
+      order = payload[:order]
+      return unless self.class.order_activatable?(order)
+
+      payload[:promotion] = self
+
+      # 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.revert(payload) if action.respond_to?(:revert)
+      end
+
+      # If an action has been taken, report back to whatever `d this promotion.
+      action_taken = results.include?(true)
+
+      if action_taken
+        # connect to the order
+        # create the join_table entry.
+        orders << order
+        save
+      end
+
+      action_taken
+    end
+
+    # called anytime order.update_with_updater! happens
+    def eligible?(promotable)
+      return false if expired? || usage_limit_exceeded?(promotable) || 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?
+
+      specific_rules = rules.select { |rule| rule.applicable?(promotable) }
+      return [] if specific_rules.none?
+
+      rule_eligibility = Hash[specific_rules.map do |rule|
+        [rule, rule.eligible?(promotable, options)]
+      end]
+
+      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 rule_eligibility.values.all?
+          @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
+          return nil
+        end
+        specific_rules
+      else
+        unless rule_eligibility.values.any?
+          @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
+          return nil
+        end
+
+        [rule_eligibility.detect { |_, eligibility| eligibility }.first]
+      end
+    end
+
+    def products
+      rules.where(type: 'Harpiya::Promotion::Rules::Product').map(&:products).flatten.uniq
+    end
+
+    def usage_limit_exceeded?(promotable)
+      usage_limit.present? && usage_limit > 0 && adjusted_credits_count(promotable) >= usage_limit
+    end
+
+    def adjusted_credits_count(promotable)
+      adjustments = promotable.is_a?(Order) ? promotable.all_adjustments : promotable.adjustments
+      credits_count - adjustments.promotion.where(source_id: actions.pluck(:id)).size
+    end
+
+    def credits
+      Adjustment.eligible.promotion.where(source_id: actions.map(&:id))
+    end
+
+    def credits_count
+      credits.count
+    end
+
+    def line_item_actionable?(order, line_item)
+      if eligible? order
+        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 = [])
+      user.orders.complete.joins(:promotions).joins(:all_adjustments).
+        where.not(harpiya_orders: { id: excluded_orders.map(&:id) }).
+        where(harpiya_promotions: { id: id }).
+        where(harpiya_adjustments: { source_type: 'Harpiya::PromotionAction', eligible: true }).any?
+    end
+
+    private
+
+    def blacklisted?(promotable)
+      case promotable
+      when Harpiya::LineItem
+        !promotable.product.promotionable?
+      when Harpiya::Order
+        promotable.line_items.any? &&
+          promotable.line_items.joins(:product).where(harpiya_products: { promotionable: true }).none?
+      end
+    end
+
+    def normalize_blank_values
+      [:code, :path].each do |column|
+        self[column] = nil if self[column].blank?
+      end
+    end
+
+    def normalize_code
+      self.code = code.strip if code.present?
+    end
+
+    def match_all?
+      match_policy == 'all'
+    end
+
+    def expires_at_must_be_later_than_starts_at
+      errors.add(:expires_at, :invalid_date_range) if expires_at < starts_at
+    end
+
+    def random_code
+      coupon_code = loop do
+        random_token = SecureRandom.hex(4)
+        break random_token unless self.class.exists?(code: random_token)
+      end
+      coupon_code
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Harpiya
+  class Promotion
+    module Actions
+      class CreateAdjustment < PromotionAction
+        include Harpiya::CalculatedAdjustments
+        include Harpiya::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_total(order), compute(order)].min * -1
+        end
+
+        def order_total(order)
+          order.item_total + order.ship_total - order.shipping_discount
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Harpiya
+  class Promotion
+    module Actions
+      class CreateItemAdjustments < PromotionAction
+        include Harpiya::CalculatedAdjustments
+        include Harpiya::AdjustmentSource
+
+        before_validation -> { self.calculator ||= Calculator::PercentOnLineItem.new }
+
+        def perform(options = {})
+          order     = options[:order]
+          promotion = 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)
+
+          amounts = [line_item.amount, compute(line_item)]
+          order   = line_item.order
+
+          # Prevent negative order totals
+          amounts << order.amount - order.adjustments.eligible.sum(:amount).abs if order.adjustments.eligible.any?
+
+          amounts.min * -1
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+module Harpiya
+  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 eligible? order
+
+          action_taken = false
+          promotion_action_line_items.each do |item|
+            current_quantity = order.quantity_of(item.variant)
+            next unless current_quantity < item.quantity && item_available?(item)
+
+            line_item = Harpiya::Dependencies.cart_add_item_service.constantize.call(order: order,
+                                                                                   variant: item.variant,
+                                                                                   quantity: item.quantity - current_quantity).value
+            action_taken = true if line_item.try(:valid?)
+          end
+          action_taken
+        end
+
+        # Called by promotion handler when a promotion is removed
+        # This will find any line item matching the ones defined in the PromotionAction
+        # and remove the same quantity as was added by the PromotionAction.
+        # Should help to prevent some of cases listed above the #perform method
+        def revert(options = {})
+          order = options[:order]
+          return if eligible?(order)
+
+          action_taken = false
+          promotion_action_line_items.each do |item|
+            line_item = order.find_line_item_by_variant(item.variant)
+            next unless line_item.present?
+
+            Harpiya::Dependencies.cart_remove_item_service.constantize.call(order: order,
+                                                                          variant: item.variant,
+                                                                          quantity: (item.quantity || 1))
+            action_taken = true
+          end
+
+          action_taken
+        end
+
+        # Checks that there's enough stock to add the line item to the order
+        def item_available?(item)
+          quantifier = Harpiya::Stock::Quantifier.new(item.variant)
+          quantifier.can_supply? item.quantity
+        end
+      end
+    end
+  end
+end