solidus_friendly_promotions 1.0.0.pre

data/app/models/solidus_friendly_promotions/promotion_action.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "spree/preferences/persistable"
+
+module SolidusFriendlyPromotions
+  # 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.
+  class PromotionAction < Spree::Base
+    include Spree::Preferences::Persistable
+    include Spree::SoftDeletable
+    include Spree::CalculatedAdjustments
+    include Spree::AdjustmentSource
+
+    belongs_to :promotion, inverse_of: :actions
+    belongs_to :original_promotion_action, class_name: "Spree::PromotionAction", optional: true
+    has_many :adjustments, class_name: "Spree::Adjustment", as: :source
+
+    scope :of_type, ->(type) { where(type: Array.wrap(type).map(&:to_s)) }
+
+    def preload_relations
+      [:calculator]
+    end
+
+    def can_discount?(object)
+      raise NotImplementedError
+    end
+
+    def discount(adjustable)
+      amount = compute_amount(adjustable)
+      return if amount.zero?
+      ItemDiscount.new(
+        item: adjustable,
+        label: adjustment_label(adjustable),
+        amount: amount,
+        source: self
+      )
+    end
+
+    # Ensure a negative amount which does not exceed the object's amount
+    def compute_amount(adjustable)
+      promotion_amount = calculator.compute(adjustable) || BigDecimal("0")
+      [adjustable.discountable_amount, promotion_amount.abs].min * -1
+    end
+
+    def adjustment_label(adjustable)
+      I18n.t(
+        "solidus_friendly_promotions.adjustment_labels.#{adjustable.class.name.demodulize.underscore}",
+        promotion: SolidusFriendlyPromotions::Promotion.model_name.human,
+        promotion_customer_label: promotion.customer_label
+      )
+    end
+
+    def to_partial_path
+      "solidus_friendly_promotions/admin/promotion_actions/actions/#{model_name.element}"
+    end
+
+    def level
+      raise NotImplementedError
+    end
+
+    def relevant_rules
+      promotion.rules.select do |rule|
+        rule.level.in?([:order, level].uniq)
+      end
+    end
+
+    def available_calculators
+      SolidusFriendlyPromotions.config.promotion_calculators[self.class] || (raise NotImplementedError)
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/promotion_category.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class PromotionCategory < Spree::Base
+    has_many :promotions, dependent: :nullify
+
+    validates :name, presence: true
+  end
+end

data/app/models/solidus_friendly_promotions/promotion_code/batch_builder.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class PromotionCode < Spree::Base
+    class BatchBuilder
+      attr_reader :promotion_code_batch, :options
+
+      delegate :promotion, :number_of_codes, :base_code, to: :promotion_code_batch
+
+      DEFAULT_OPTIONS = {
+        random_code_length: 6,
+        batch_size: 1000,
+        sample_characters: ("a".."z").to_a + (2..9).to_a.map(&:to_s)
+      }.freeze
+
+      def initialize(promotion_code_batch, options = {})
+        @promotion_code_batch = promotion_code_batch
+        options.assert_valid_keys(*DEFAULT_OPTIONS.keys)
+        @options = DEFAULT_OPTIONS.merge(options)
+      end
+
+      def build_promotion_codes
+        generate_random_codes
+        promotion_code_batch.update!(state: "completed")
+      rescue => e
+        promotion_code_batch.update!(
+          error: e.inspect,
+          state: "failed"
+        )
+        raise e
+      end
+
+      private
+
+      def generate_random_codes
+        created_codes = promotion_code_batch.promotion_codes.count
+
+        batch_size = @options[:batch_size]
+
+        while created_codes < number_of_codes
+          max_codes_to_generate = [batch_size, number_of_codes - created_codes].min
+
+          new_codes = Array.new(max_codes_to_generate) { generate_random_code }.uniq
+          codes_for_current_batch = get_unique_codes(new_codes)
+
+          codes_for_current_batch = codes_for_current_batch.map do |value|
+            SolidusFriendlyPromotions::PromotionCode.create!(
+              value: value,
+              promotion: promotion,
+              promotion_code_batch: promotion_code_batch
+            )
+          rescue ActiveRecord::RecordInvalid
+            nil
+          end.compact
+          created_codes += codes_for_current_batch.size
+        end
+      end
+
+      def generate_random_code
+        suffix = Array.new(@options[:random_code_length]) do
+          @options[:sample_characters].sample
+        end.join
+
+        "#{base_code}#{@promotion_code_batch.join_characters}#{suffix}"
+      end
+
+      def get_unique_codes(code_set)
+        code_set - PromotionCode.where(value: code_set.to_a).pluck(:value)
+      end
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/promotion_code.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class PromotionCode < Spree::Base
+    belongs_to :promotion, inverse_of: :codes
+    belongs_to :promotion_code_batch, inverse_of: :promotion_codes, optional: true
+    has_many :adjustments, class_name: "Spree::Adjustment"
+
+    before_validation :normalize_code
+
+    validates :value, presence: true, uniqueness: {allow_blank: true, case_sensitive: true}
+    validate :promotion_not_apply_automatically, on: :create
+
+    self.allowed_ransackable_attributes = ["value"]
+
+    # Whether the promotion code has exceeded its usage restrictions
+    #
+    # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage limit
+    # @return true or false
+    def usage_limit_exceeded?(excluded_orders: [])
+      return unless usage_limit
+
+      usage_count(excluded_orders: excluded_orders) >= usage_limit
+    end
+
+    # Number of times the code has been used overall
+    #
+    # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage count
+    # @return [Integer] usage count
+    def usage_count(excluded_orders: [])
+      promotion
+        .discounted_orders
+        .complete
+        .where.not(spree_orders: {state: :canceled})
+        .joins(:friendly_order_promotions)
+        .where(friendly_order_promotions: {promotion_code_id: id})
+        .where.not(id: excluded_orders.map(&:id))
+        .count
+    end
+
+    def usage_limit
+      promotion.per_code_usage_limit
+    end
+
+    def promotion_not_apply_automatically
+      errors.add(:base, :disallowed_with_apply_automatically) if promotion.apply_automatically
+    end
+
+    private
+
+    def normalize_code
+      self.value = value.downcase.strip
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/promotion_code_batch.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class PromotionCodeBatch < Spree::Base
+    class CantProcessStartedBatch < StandardError
+    end
+
+    belongs_to :promotion
+    has_many :promotion_codes, dependent: :destroy
+
+    validates :number_of_codes, numericality: {greater_than: 0}
+    validates :base_code, :number_of_codes, presence: true
+
+    def finished?
+      state == "completed"
+    end
+
+    def process
+      raise CantProcessStartedBatch, "Batch #{id} already started" unless state == "pending"
+
+      update!(state: "processing")
+      PromotionCodeBatchJob.perform_later(self)
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/promotion_handler/coupon.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module PromotionHandler
+    class Coupon
+      attr_reader :order, :coupon_code, :errors
+      attr_accessor :error, :success, :status_code
+
+      def initialize(order)
+        @order = order
+        @errors = []
+        @coupon_code = order&.coupon_code&.downcase
+      end
+
+      def apply
+        if coupon_code.present?
+          if promotion.present? && promotion.active?
+            handle_present_promotion
+          elsif promotion_code&.promotion&.expired?
+            set_error_code :coupon_code_expired
+          else
+            set_error_code :coupon_code_not_found
+          end
+        end
+
+        self
+      end
+
+      def remove
+        if promotion.blank?
+          set_error_code :coupon_code_not_found
+        elsif !promotion_exists_on_order?(order, promotion)
+          set_error_code :coupon_code_not_present
+        else
+          order.friendly_order_promotions.destroy_by(
+            promotion: promotion
+          )
+          order.recalculate
+          set_success_code :coupon_code_removed
+        end
+
+        self
+      end
+
+      def successful?
+        success.present? && error.blank?
+      end
+
+      def promotion
+        @promotion ||= if promotion_code&.promotion&.active?
+          promotion_code.promotion
+        end
+      end
+
+      private
+
+      def set_success_code(status_code)
+        @status_code = status_code
+        @success = I18n.t(status_code, scope: "solidus_friendly_promotions.eligibility_results")
+      end
+
+      def set_error_code(status_code, options = {})
+        @status_code = status_code
+        @error = options[:error] || I18n.t(status_code, scope: "solidus_friendly_promotions.eligibility_errors")
+        @errors = options[:errors] || [@error]
+      end
+
+      def promotion_code
+        @promotion_code ||= SolidusFriendlyPromotions::PromotionCode.where(value: coupon_code).first
+      end
+
+      def handle_present_promotion
+        return promotion_usage_limit_exceeded if promotion.usage_limit_exceeded? || promotion_code.usage_limit_exceeded?
+        return promotion_applied if promotion_exists_on_order?(order, promotion)
+
+        # Try applying this promotion, with no effects
+        Spree::Config.promotion_adjuster_class.new(order, dry_run_promotion: promotion).call
+
+        if promotion.eligibility_results.success?
+          order.friendly_order_promotions.create!(
+            promotion: promotion,
+            promotion_code: promotion_code
+          )
+          order.recalculate
+          set_success_code :coupon_code_applied
+        else
+          set_promotion_eligibility_error(promotion)
+        end
+      end
+
+      def set_promotion_eligibility_error(promotion)
+        eligibility_error = promotion.eligibility_results.detect { |result| !result.success }
+        set_error_code(eligibility_error.code, error: eligibility_error.message, errors: promotion.eligibility_results.error_messages)
+      end
+
+      def promotion_usage_limit_exceeded
+        set_error_code :coupon_code_max_usage
+      end
+
+      def ineligible_for_this_order
+        set_error_code :coupon_code_not_eligible
+      end
+
+      def promotion_applied
+        set_error_code :coupon_code_already_applied
+      end
+
+      def promotion_exists_on_order?(order, promotion)
+        order.friendly_promotions.include? promotion
+      end
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/promotion_handler/page.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module PromotionHandler
+    class Page
+      attr_reader :order, :path
+
+      def initialize(order, path)
+        @order = order
+        @path = path.gsub(/\A\//, "")
+      end
+
+      def activate
+        if promotion
+          Spree::Config.promotion_adjuster_class.new(order, dry_run_promotion: promotion).call
+          if promotion.eligibility_results.success?
+            order.friendly_promotions << promotion
+            order.recalculate
+          end
+        end
+      end
+
+      private
+
+      def promotion
+        @promotion ||= SolidusFriendlyPromotions::Promotion.active.find_by(path: path)
+      end
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/promotion_rule.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "spree/preferences/persistable"
+
+module SolidusFriendlyPromotions
+  class PromotionRule < Spree::Base
+    include Spree::Preferences::Persistable
+
+    belongs_to :promotion
+
+    scope :of_type, ->(type) { where(type: type) }
+
+    validate :unique_per_promotion, on: :create
+
+    def preload_relations
+      []
+    end
+
+    def applicable?(_promotable)
+      raise NotImplementedError, "applicable? should be implemented in a sub-class of SolidusFriendlyPromotions::Rule"
+    end
+
+    def eligible?(_promotable, _options = {})
+      raise NotImplementedError, "eligible? should be implemented in a sub-class of SolidusFriendlyPromotions::Rule"
+    end
+
+    def level
+      raise NotImplementedError, "level should be implemented in a sub-class of SolidusFriendlyPromotions::Rule"
+    end
+
+    def eligibility_errors
+      @eligibility_errors ||= ActiveModel::Errors.new(self)
+    end
+
+    def to_partial_path
+      "solidus_friendly_promotions/admin/promotion_rules/rules/#{model_name.element}"
+    end
+
+    def updateable?
+      preferences.any?
+    end
+
+    private
+
+    def unique_per_promotion
+      return unless self.class.exists?(promotion_id: promotion_id, type: self.class.name)
+
+      errors[:base] << "Promotion already contains this rule type"
+    end
+
+    def eligibility_error_message(key, options = {})
+      I18n.t(key, **{scope: [:solidus_friendly_promotions, :eligibility_errors, self.class.name.underscore]}.merge(options))
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/promotion_rules_store.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class PromotionRulesStore < Spree::Base
+    belongs_to :promotion_rule, class_name: "SolidusFriendlyPromotions::PromotionRule", optional: true
+    belongs_to :store, class_name: "Spree::Store", optional: true
+  end
+end

data/app/models/solidus_friendly_promotions/promotion_rules_taxon.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class PromotionRulesTaxon < Spree::Base
+    belongs_to :promotion_rule, class_name: "SolidusFriendlyPromotions::PromotionRule", optional: true
+    belongs_to :taxon, class_name: "Spree::Taxon", optional: true
+  end
+end

data/app/models/solidus_friendly_promotions/promotion_rules_user.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class PromotionRulesUser < Spree::Base
+    belongs_to :promotion_rule, class_name: "SolidusFriendlyPromotions::PromotionRule", optional: true
+    belongs_to :user, class_name: Spree::UserClassHandle.new, optional: true
+  end
+end

data/app/models/solidus_friendly_promotions/rules/discounted_item_total.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    # A rule to apply to an order greater than (or greater than or equal to)
+    # a specific amount after previous promotions have applied
+    #
+    # To add extra operators please override `self.operators_map` or any other helper method.
+    # To customize the error message you can also override `ineligible_message`.
+    class DiscountedItemTotal < ItemTotal
+      def to_partial_path
+        "solidus_friendly_promotions/admin/promotion_rules/rules/item_total"
+      end
+
+      private
+
+      def total_for_order(order)
+        order.discountable_item_total
+      end
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/rules/first_order.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    class FirstOrder < PromotionRule
+      include OrderLevelRule
+      attr_reader :user, :email
+
+      def eligible?(order, options = {})
+        @user = order.try(:user) || options[:user]
+        @email = order.email
+
+        if (user || email) && (completed_orders.present? && completed_orders.first != order)
+          eligibility_errors.add(:base, eligibility_error_message(:not_first_order), error_code: :not_first_order)
+        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

data/app/models/solidus_friendly_promotions/rules/first_repeat_purchase_since.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    class FirstRepeatPurchaseSince < PromotionRule
+      include OrderLevelRule
+
+      preference :days_ago, :integer, default: 365
+      validates :preferred_days_ago, numericality: {only_integer: true, greater_than: 0}
+
+      # This is never eligible if the order does not have a user, and that user does not have any previous completed orders.
+      #
+      # This is eligible if the user's most recently completed order is more than the preferred days ago
+      # @param order [Spree::Order]
+      def eligible?(order, _options = {})
+        return false unless order.user
+
+        last_order = last_completed_order(order.user)
+        return false unless last_order
+
+        last_order.completed_at < preferred_days_ago.days.ago
+      end
+
+      private
+
+      def last_completed_order(user)
+        user.orders.complete.order(:completed_at).last
+      end
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/rules/item_total.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    # A rule to apply to an order greater than (or greater than or equal to)
+    # a specific amount
+    #
+    # To add extra operators please override `self.operators_map` or any other helper method.
+    # To customize the error message you can also override `ineligible_message`.
+    class ItemTotal < PromotionRule
+      include OrderLevelRule
+
+      preference :amount, :decimal, default: 100.00
+      preference :currency, :string, default: -> { Spree::Config[:currency] }
+      preference :operator, :string, default: "gt"
+
+      # The list of allowed operators names mapped to their symbols.
+      def self.operators_map
+        {
+          gte: :>=,
+          gt: :>
+        }
+      end
+
+      def self.operator_options
+        operators_map.map do |name, _method|
+          [I18n.t(name, scope: "spree.item_total_rule.operators"), name]
+        end
+      end
+
+      def eligible?(order, _options = {})
+        return false unless order.currency == preferred_currency
+
+        unless total_for_order(order).send(operator, threshold)
+          eligibility_errors.add(:base, ineligible_message, error_code: ineligible_error_code)
+        end
+
+        eligibility_errors.empty?
+      end
+
+      private
+
+      def operator
+        self.class.operators_map.fetch(
+          preferred_operator.to_sym,
+          preferred_operator_default
+        )
+      end
+
+      def total_for_order(order)
+        order.item_total
+      end
+
+      def threshold
+        BigDecimal(preferred_amount.to_s)
+      end
+
+      def formatted_amount
+        Spree::Money.new(preferred_amount, currency: preferred_currency).to_s
+      end
+
+      def ineligible_message
+        case preferred_operator.to_s
+        when "gte"
+          eligibility_error_message(:item_total_less_than, amount: formatted_amount)
+        when "gt"
+          eligibility_error_message(:item_total_less_than_or_equal, amount: formatted_amount)
+        else
+          eligibility_error_message(
+            :item_total_doesnt_match_with_operator,
+            amount: formatted_amount,
+            operator: preferred_operator
+          )
+        end
+      end
+
+      def ineligible_error_code
+        if preferred_operator == "gte"
+          :item_total_less_than
+        else
+          :item_total_less_than_or_equal
+        end
+      end
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/rules/line_item_option_value.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    class LineItemOptionValue < PromotionRule
+      include LineItemLevelRule
+
+      preference :eligible_values, :hash
+
+      def eligible?(line_item, _options = {})
+        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
+        values = preferences[:eligible_values] || {}
+        values.keys.map(&:to_i).zip(
+          values.values.map do |value|
+            (value.is_a?(Array) ? value : value.split(",")).map(&:to_i)
+          end
+        ).to_h
+      end
+
+      private
+
+      def product_ids
+        preferred_eligible_values.keys
+      end
+
+      def value_ids(product_id)
+        preferred_eligible_values[product_id]
+      end
+    end
+  end
+end