harpiya_core 4.3.0.alpha

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

@@ -0,0 +1,19 @@
+module Harpiya
+  class Promotion
+    module Actions
+      class FreeShipping < Harpiya::PromotionAction
+        include Harpiya::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/harpiya/promotion/rules/country.rb

@@ -0,0 +1,23 @@
+# A rule to limit a promotion based on shipment country.
+module Harpiya
+  class Promotion
+    module Rules
+      class Country < PromotionRule
+        preference :country_id, :integer
+
+        def applicable?(promotable)
+          promotable.is_a?(Harpiya::Order)
+        end
+
+        def eligible?(order, options = {})
+          country_id = options[:country_id] || order.ship_address.try(:country_id)
+          unless country_id.eql?(preferred_country_id || order.store.default_country_id)
+            eligibility_errors.add(:base, eligibility_error_message(:wrong_country))
+          end
+
+          eligibility_errors.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Harpiya
+  class Promotion
+    module Rules
+      class FirstOrder < PromotionRule
+        attr_reader :user, :email
+
+        def applicable?(promotable)
+          promotable.is_a?(Harpiya::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
+          Harpiya::Order.where(email: email).complete
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# A rule to apply to an order greater than (or greater than or equal to)
+# a specific amount
+module Harpiya
+  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?(Harpiya::Order)
+        end
+
+        def eligible?(order, _options = {})
+          item_total = order.item_total
+
+          lower_limit_condition = item_total.send(preferred_operator_min == 'gte' ? :>= : :>, BigDecimal(preferred_amount_min.to_s))
+          upper_limit_condition = item_total.send(preferred_operator_max == 'lte' ? :<= : :<, BigDecimal(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
+          Harpiya::Money.new(preferred_amount_min).to_s
+        end
+
+        def formatted_amount_max
+          Harpiya::Money.new(preferred_amount_max).to_s
+        end
+
+        def ineligible_message_max
+          if preferred_operator_max == 'lt'
+            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/harpiya/promotion/rules/one_use_per_user.rb

@@ -0,0 +1,23 @@
+module Harpiya
+  class Promotion
+    module Rules
+      class OneUsePerUser < PromotionRule
+        def applicable?(promotable)
+          promotable.is_a?(Harpiya::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/harpiya/promotion/rules/option_value.rb

@@ -0,0 +1,44 @@
+module Harpiya
+  class Promotion
+    module Rules
+      module OptionValueWithNumerificationSupport
+        def preferred_eligible_values
+          values = super || {}
+          Hash[values.keys.map(&:to_i).zip(
+            values.values.map do |v|
+              (v.is_a?(Array) ? v : v.split(',')).map(&:to_i)
+            end
+          )]
+        end
+      end
+
+      class OptionValue < PromotionRule
+        prepend OptionValueWithNumerificationSupport
+
+        MATCH_POLICIES = %w(any)
+        preference :match_policy, :string, default: MATCH_POLICIES.first
+        preference :eligible_values, :hash
+
+        def applicable?(promotable)
+          promotable.is_a?(Harpiya::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)
+          product_id = line_item.product_id
+          option_values_ids = line_item.variant.option_value_ids
+          eligible_product_ids = preferred_eligible_values.keys
+          eligible_value_ids = preferred_eligible_values[product_id]
+
+          eligible_product_ids.include?(product_id) && (eligible_value_ids & option_values_ids).present?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# 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 Harpiya
+  class Promotion
+    module Rules
+      class Product < PromotionRule
+        has_many :product_promotion_rules, class_name: 'Harpiya::ProductPromotionRule',
+                                           foreign_key: :promotion_rule_id,
+                                           dependent: :destroy
+        has_many :products, through: :product_promotion_rules, class_name: 'Harpiya::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?(Harpiya::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)
+          # check this
+          self.product_ids = s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Harpiya
+  class Promotion
+    module Rules
+      class Taxon < PromotionRule
+        has_many :promotion_rule_taxons, class_name: 'Harpiya::PromotionRuleTaxon',
+                                         foreign_key: 'promotion_rule_id',
+                                         dependent: :destroy
+        has_many :taxons, through: :promotion_rule_taxons, class_name: 'Harpiya::Taxon'
+
+        MATCH_POLICIES = %w(any all)
+        preference :match_policy, default: MATCH_POLICIES.first
+
+        def applicable?(promotable)
+          promotable.is_a?(Harpiya::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 = Harpiya::Taxon.find(ids)
+        end
+
+        private
+
+        # All taxons in an order
+        def order_taxons(order)
+          Harpiya::Taxon.joins(products: { variants_including_master: :line_items }).where(harpiya_line_items: { order_id: order.id }).distinct
+        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
+          Harpiya::Product.joins(:taxons).where(harpiya_taxons: { id: taxons.pluck(:id) }).pluck(:id).uniq
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Harpiya
+  class Promotion
+    module Rules
+      class User < PromotionRule
+        belongs_to :user, class_name: "::#{Harpiya.user_class}"
+
+        has_many :promotion_rule_users, class_name: 'Harpiya::PromotionRuleUser',
+                                        foreign_key: :promotion_rule_id,
+                                        dependent: :destroy
+        has_many :users, through: :promotion_rule_users, class_name: "::#{Harpiya.user_class}"
+
+        def applicable?(promotable)
+          promotable.is_a?(Harpiya::Order)
+        end
+
+        def eligible?(order, _options = {})
+          users.include?(order.user)
+        end
+
+        def user_ids_string
+          user_ids.join(',')
+        end
+
+        def user_ids_string=(s)
+          # check this
+          self.user_ids = s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Harpiya
+  class Promotion
+    module Rules
+      class UserLoggedIn < PromotionRule
+        def applicable?(promotable)
+          promotable.is_a?(Harpiya::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/harpiya/promotion_action.rb

@@ -0,0 +1,25 @@
+## 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.
+module Harpiya
+  class PromotionAction < Harpiya::Base
+    acts_as_paranoid
+
+    belongs_to :promotion, class_name: 'Harpiya::Promotion'
+
+    scope :of_type, ->(t) { where(type: t) }
+
+    # This method should be overriden in subclass
+    # 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
+    def perform(_options = {})
+      raise 'perform should be implemented in a sub-class of PromotionAction'
+    end
+
+    protected
+
+    def label
+      Harpiya.t(:promotion_label, name: promotion.name)
+    end
+  end
+end

data/app/models/harpiya/promotion_action_line_item.rb

@@ -0,0 +1,9 @@
+module Harpiya
+  class PromotionActionLineItem < Harpiya::Base
+    belongs_to :promotion_action, class_name: 'Harpiya::Promotion::Actions::CreateLineItems'
+    belongs_to :variant, class_name: 'Harpiya::Variant'
+
+    validates :promotion_action, :variant, :quantity, presence: true
+    validates :quantity, numericality: { only_integer: true, message: Harpiya.t('validation.must_be_int') }
+  end
+end