solidus_promotions 4.4.0

data/app/models/solidus_promotions/migration_support/order_promotion_syncer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module MigrationSupport
+    class OrderPromotionSyncer
+      attr_reader :order
+
+      def initialize(order:)
+        @order = order
+      end
+
+      def call
+        sync_spree_order_promotions_to_solidus_order_promotions
+        sync_solidus_order_promotions_to_spree_order_promotions
+      end
+
+      private
+
+      def sync_spree_order_promotions_to_solidus_order_promotions
+        order.order_promotions.each do |spree_order_promotion|
+          solidus_promotion = SolidusPromotions::Promotion.find_by(
+            original_promotion_id: spree_order_promotion.promotion.id
+          )
+          next unless solidus_promotion
+          if spree_order_promotion.promotion_code
+            solidus_promotion_code = solidus_promotion.codes.find_by(
+              value: spree_order_promotion.promotion_code.value
+            )
+          end
+          order.solidus_order_promotions.find_or_create_by!(
+            promotion: solidus_promotion,
+            promotion_code: solidus_promotion_code
+          )
+        end
+      end
+
+      def sync_solidus_order_promotions_to_spree_order_promotions
+        order.solidus_order_promotions.each do |solidus_order_promotion|
+          spree_promotion = solidus_order_promotion.promotion.original_promotion
+          next unless spree_promotion
+          if solidus_order_promotion.promotion_code
+            spree_promotion_code = spree_promotion.promotion_codes.find_by(
+              value: solidus_order_promotion.promotion_code.value
+            )
+          end
+          order.order_promotions.find_or_create_by!(
+            promotion: spree_promotion,
+            promotion_code: spree_promotion_code
+          )
+        end
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/order_adjuster/choose_discounts.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class OrderAdjuster
+    class ChooseDiscounts
+      attr_reader :discounts
+
+      def initialize(discounts)
+        @discounts = discounts
+      end
+
+      def call
+        Array.wrap(
+          discounts.min_by do |discount|
+            [discount.amount, -discount.source&.id.to_i]
+          end
+        )
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/order_adjuster/discount_order.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class OrderAdjuster
+    class DiscountOrder
+      attr_reader :order, :promotions, :dry_run
+
+      def initialize(order, promotions, dry_run: false)
+        @order = order
+        @promotions = promotions
+        @dry_run = dry_run
+      end
+
+      def call
+        return order if order.shipped?
+
+        SolidusPromotions::Promotion.ordered_lanes.each_key do |lane|
+          lane_promotions = promotions.select { |promotion| promotion.lane == lane }
+          lane_benefits = eligible_benefits_for_promotable(lane_promotions.flat_map(&:benefits), order)
+          perform_order_benefits(lane_benefits, lane) unless dry_run
+          line_item_discounts = adjust_line_items(lane_benefits)
+          shipment_discounts = adjust_shipments(lane_benefits)
+          shipping_rate_discounts = adjust_shipping_rates(lane_benefits)
+          (line_item_discounts + shipment_discounts + shipping_rate_discounts).each do |item, chosen_discounts|
+            item.current_discounts.concat(chosen_discounts)
+          end
+        end
+
+        order
+      end
+
+      private
+
+      def perform_order_benefits(lane_benefits, lane)
+        lane_benefits.select { |benefit| benefit.level == :order }.each do |benefit|
+          benefit.perform(order)
+        end
+
+        automated_line_items = order.line_items.select(&:managed_by_order_benefit)
+        return if automated_line_items.empty?
+
+        ineligible_line_items = automated_line_items.select do |line_item|
+          line_item.managed_by_order_benefit.promotion.lane == lane && !line_item.managed_by_order_benefit.in?(lane_benefits)
+        end
+
+        ineligible_line_items.each do |line_item|
+          line_item.managed_by_order_benefit.remove_from(order)
+        end
+      end
+
+      def adjust_line_items(benefits)
+        order.discountable_line_items.select do |line_item|
+          line_item.variant.product.promotionable?
+        end.map do |line_item|
+          discounts = generate_discounts(benefits, line_item)
+          chosen_item_discounts = SolidusPromotions.config.discount_chooser_class.new(discounts).call
+          [line_item, chosen_item_discounts]
+        end
+      end
+
+      def adjust_shipments(benefits)
+        order.shipments.map do |shipment|
+          discounts = generate_discounts(benefits, shipment)
+          chosen_item_discounts = SolidusPromotions.config.discount_chooser_class.new(discounts).call
+          [shipment, chosen_item_discounts]
+        end
+      end
+
+      def adjust_shipping_rates(benefits)
+        order.shipments.flat_map(&:shipping_rates).select(&:cost).map do |rate|
+          discounts = generate_discounts(benefits, rate)
+          chosen_item_discounts = SolidusPromotions.config.discount_chooser_class.new(discounts).call
+          [rate, chosen_item_discounts]
+        end
+      end
+
+      def eligible_benefits_for_promotable(possible_benefits, promotable)
+        possible_benefits.select do |candidate|
+          candidate.eligible_by_applicable_conditions?(promotable, dry_run: dry_run)
+        end
+      end
+
+      def generate_discounts(possible_benefits, item)
+        eligible_benefits = eligible_benefits_for_promotable(possible_benefits, item)
+        eligible_benefits.select do |benefit|
+          benefit.can_discount?(item)
+        end.map do |benefit|
+          benefit.discount(item)
+        end.compact
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/order_adjuster/load_promotions.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class OrderAdjuster
+    class LoadPromotions
+      def initialize(order:, dry_run_promotion: nil)
+        @order = order
+        @dry_run_promotion = dry_run_promotion
+      end
+
+      def call
+        promos = connected_order_promotions | sale_promotions
+        promos << dry_run_promotion if dry_run_promotion
+        promos.flat_map(&:benefits).group_by(&:preload_relations).each do |benefit_preload_relations, benefits|
+          preload(records: benefits, associations: benefit_preload_relations)
+          benefits.flat_map(&:conditions).group_by(&:preload_relations).each do |condition_preload_relations, conditions|
+            preload(records: conditions, associations: condition_preload_relations)
+          end
+        end
+        promos.reject { |promotion| promotion.usage_limit_exceeded?(excluded_orders: [order]) }
+      end
+
+      private
+
+      attr_reader :order, :dry_run_promotion
+
+      def preload(records:, associations:)
+        ActiveRecord::Associations::Preloader.new(records: records, associations: associations).call
+      end
+
+      def connected_order_promotions
+        eligible_connected_promotion_ids = order.solidus_order_promotions.select do |order_promotion|
+          order_promotion.promotion.kept? && (order_promotion.promotion_code.nil? || !order_promotion.promotion_code.usage_limit_exceeded?(excluded_orders: [order]))
+        end.map(&:promotion_id)
+        order.solidus_promotions.active(reference_time).where(id: eligible_connected_promotion_ids).includes(promotion_includes)
+      end
+
+      def sale_promotions
+        SolidusPromotions::Promotion.kept.where(apply_automatically: true).active(reference_time).includes(promotion_includes)
+      end
+
+      def reference_time
+        order.completed_at || Time.current
+      end
+
+      def promotion_includes
+        {
+          benefits: :conditions
+        }
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/order_adjuster/persist_discounted_order.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class OrderAdjuster
+    class PersistDiscountedOrder
+      def initialize(order)
+        @order = order
+      end
+
+      def call
+        order.line_items.each do |line_item|
+          update_adjustments(line_item, line_item.current_discounts)
+        end
+
+        order.shipments.each do |shipment|
+          update_adjustments(shipment, shipment.current_discounts)
+        end
+
+        order.shipments.flat_map(&:shipping_rates).each do |shipping_rate|
+          shipping_rate.discounts = shipping_rate.current_discounts.map do |discount|
+            SolidusPromotions::ShippingRateDiscount.create!(
+              shipping_rate: shipping_rate,
+              amount: discount.amount,
+              label: discount.label,
+              benefit: discount.source
+            )
+          end
+        end
+        order.reset_current_discounts
+        order
+      end
+
+      private
+
+      attr_reader :order
+
+      # Walk through the discounts for an item and update adjustments for it. Once
+      # all of the discounts have been added as adjustments, remove any old promotion
+      # adjustments that weren't touched.
+      #
+      # @private
+      # @param [#adjustments] item a {Spree::LineItem} or {Spree::Shipment}
+      # @param [Array<SolidusPromotions::ItemDiscount>] item_discounts a list of calculated discounts for an item
+      # @return [void]
+      def update_adjustments(item, item_discounts)
+        promotion_adjustments = item.adjustments.select(&:promotion?)
+
+        active_adjustments = item_discounts.map do |item_discount|
+          update_adjustment(item, item_discount)
+        end
+        item.update(promo_total: active_adjustments.sum(&:amount))
+        # Remove any promotion adjustments tied to promotion benefits which no longer match.
+        unmatched_adjustments = promotion_adjustments - active_adjustments
+
+        item.adjustments.destroy(unmatched_adjustments)
+      end
+
+      # Update or create a new promotion adjustment on an item.
+      #
+      # @private
+      # @param [#adjustments] item a {Spree::LineItem} or {Spree::Shipment}
+      # @param [SolidusPromotions::ItemDiscount] discount_item calculated discounts for an item
+      # @return [Spree::Adjustment] the created or updated promotion adjustment
+      def update_adjustment(item, discount_item)
+        adjustment = item.adjustments.detect do |item_adjustment|
+          item_adjustment.source == discount_item.source
+        end
+
+        adjustment ||= item.adjustments.new(
+          source: discount_item.source,
+          order_id: item.is_a?(Spree::Order) ? item.id : item.order_id,
+          label: discount_item.label
+        )
+        adjustment.update!(amount: discount_item.amount)
+        adjustment
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/order_adjuster.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class OrderAdjuster
+    attr_reader :order, :promotions, :dry_run
+
+    def initialize(order, dry_run_promotion: nil)
+      @order = order
+      @dry_run = !!dry_run_promotion
+      @promotions = LoadPromotions.new(order: order, dry_run_promotion: dry_run_promotion).call
+    end
+
+    def call
+      order.reset_current_discounts
+
+      return order if (!SolidusPromotions.config.recalculate_complete_orders && order.complete?) || order.shipped?
+
+      discounted_order = DiscountOrder.new(order, promotions, dry_run: dry_run).call
+
+      PersistDiscountedOrder.new(discounted_order).call unless dry_run
+
+      order.reset_current_discounts
+
+      unless dry_run
+        # Since automations might have added a line item, we need to recalculate item total and item count here.
+        order.item_total = order.line_items.sum(&:amount)
+        order.item_count = order.line_items.sum(&:quantity)
+        order.promo_total = (order.line_items + order.shipments).sum(&:promo_total)
+      end
+      order
+    end
+  end
+end

data/app/models/solidus_promotions/order_promotion.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  # SolidusPromotions::OrderPromotion represents the relationship between:
+  #
+  # 1. A promotion that a user attempted to apply to their order
+  # 2. The specific code that they used
+  class OrderPromotion < Spree::Base
+    belongs_to :order, class_name: "Spree::Order"
+    belongs_to :promotion, -> { with_discarded }, class_name: "SolidusPromotions::Promotion"
+    belongs_to :promotion_code, class_name: "SolidusPromotions::PromotionCode", optional: true
+
+    validates :promotion_code, presence: true, if: :require_promotion_code?
+
+    self.allowed_ransackable_associations = %w[promotion_code]
+
+    private
+
+    def require_promotion_code?
+      promotion && !promotion.apply_automatically && promotion.codes.any?
+    end
+  end
+end

data/app/models/solidus_promotions/permission_sets/solidus_promotion_management.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module PermissionSets
+    class SolidusPromotionManagement < Spree::PermissionSets::Base
+      def activate!
+        can :manage, SolidusPromotions::Promotion
+        can :manage, SolidusPromotions::Condition
+        can :manage, SolidusPromotions::Benefit
+        can :manage, SolidusPromotions::PromotionCategory
+        can :manage, SolidusPromotions::PromotionCode
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/promotion.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class Promotion < Spree::Base
+    include Spree::SoftDeletable
+
+    belongs_to :category, class_name: "SolidusPromotions::PromotionCategory",
+      foreign_key: :promotion_category_id, optional: true
+    belongs_to :original_promotion, class_name: "Spree::Promotion", optional: true
+    has_many :benefits, class_name: "SolidusPromotions::Benefit", dependent: :destroy
+    has_many :conditions, through: :benefits
+    has_many :codes, class_name: "SolidusPromotions::PromotionCode", dependent: :destroy
+    has_many :code_batches, class_name: "SolidusPromotions::PromotionCodeBatch", dependent: :destroy
+    has_many :order_promotions, class_name: "SolidusPromotions::OrderPromotion", dependent: :destroy
+
+    validates :name, :customer_label, presence: true
+    validates :path, uniqueness: { allow_blank: true, case_sensitive: 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 }
+    validate :apply_automatically_disallowed_with_paths
+    validate :apply_automatically_disallowed_with_promotion_codes
+
+    before_save :normalize_blank_values
+    after_discard :delete_cart_connections
+
+    scope :active, ->(time = Time.current) { has_benefits.started_and_unexpired(time) }
+    scope :advertised, -> { where(advertise: true) }
+    scope :coupons, -> { joins(:codes).distinct }
+    scope :started_and_unexpired, ->(time = Time.current) do
+      table = arel_table
+
+      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 :has_benefits, -> do
+      joins(:benefits).distinct
+    end
+
+    enum :lane, SolidusPromotions.config.preferred_lanes
+
+    def self.with_coupon_code(val)
+      joins(:codes).where(
+        SolidusPromotions::PromotionCode.arel_table[:value].eq(val.downcase)
+      ).first
+    end
+
+    def self.human_enum_name(enum_name, enum_value)
+      I18n.t("activerecord.attributes.#{model_name.i18n_key}.#{enum_name.to_s.pluralize}.#{enum_value}")
+    end
+
+    def self.lane_options
+      ordered_lanes.map do |lane_name, _index|
+        [human_enum_name(:lane, lane_name), lane_name]
+      end
+    end
+
+    def self.ordered_lanes
+      lanes.sort_by(&:last).to_h
+    end
+
+    self.allowed_ransackable_associations = ["codes"]
+    self.allowed_ransackable_attributes = %w[name customer_label path promotion_category_id lane updated_at]
+    self.allowed_ransackable_scopes = %i[active with_discarded]
+
+    # All orders that have been discounted using this promotion
+    def discounted_orders
+      Spree::Order
+        .joins(:all_adjustments)
+        .where(
+          spree_adjustments: {
+            source_type: "SolidusPromotions::Benefit",
+            source_id: benefits.map(&:id)
+          }
+        ).distinct
+    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: [])
+      discounted_orders
+        .complete
+        .where.not(id: [excluded_orders.map(&:id)])
+        .where.not(spree_orders: { state: :canceled })
+        .count
+    end
+
+    def used_by?(user, excluded_orders = [])
+      discounted_orders
+        .complete
+        .where.not(id: excluded_orders.map(&:id))
+        .where(user: user)
+        .where.not(spree_orders: { state: :canceled })
+        .exists?
+    end
+
+    # Whether the promotion 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
+
+    def not_expired?(time = Time.current)
+      !expired?(time)
+    end
+
+    def not_started?(time = Time.current)
+      !started?(time)
+    end
+
+    def started?(time = Time.current)
+      starts_at.nil? || starts_at < time
+    end
+
+    def active?(time = Time.current)
+      started?(time) && not_expired?(time) && benefits.present?
+    end
+
+    def inactive?(time = Time.current)
+      !active?(time)
+    end
+
+    def expired?(time = Time.current)
+      expires_at.present? && expires_at < time
+    end
+
+    def products
+      conditions.where(type: "SolidusPromotions::Conditions::Product").flat_map(&:products).uniq
+    end
+
+    def eligibility_results
+      @eligibility_results ||= SolidusPromotions::EligibilityResults.new(self)
+    end
+
+    private
+
+    def normalize_blank_values
+      self[:path] = nil if self[:path].blank?
+    end
+
+    def apply_automatically_disallowed_with_paths
+      return unless apply_automatically
+
+      errors.add(:apply_automatically, :disallowed_with_path) if path.present?
+    end
+
+    def apply_automatically_disallowed_with_promotion_codes
+      return unless apply_automatically
+
+      errors.add(:apply_automatically, :disallowed_with_promotion_codes) if codes.present?
+    end
+
+    def delete_cart_connections
+      order_promotions.where(order: Spree::Order.incomplete).destroy_all
+    end
+  end
+end

data/app/models/solidus_promotions/promotion_advertiser.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class PromotionAdvertiser
+    def self.for_product(product)
+      promotion_ids = ConditionProduct.joins(condition: :benefit).where(product: product).select(:promotion_id).distinct
+      SolidusPromotions::Promotion.advertised.where(id: promotion_ids).reject(&:inactive?)
+    end
+  end
+end

data/app/models/solidus_promotions/promotion_category.rb

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

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  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 StandardError => 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.filter! do |value|
+            SolidusPromotions::PromotionCode.create!(
+              value: value,
+              promotion: promotion,
+              promotion_code_batch: promotion_code_batch
+            )
+          rescue ActiveRecord::RecordInvalid
+            false
+          end
+
+          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_promotions/promotion_code.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class PromotionCode < Spree::Base
+    belongs_to :promotion, -> { with_discarded }, inverse_of: :codes
+    belongs_to :promotion_code_batch, inverse_of: :promotion_codes, optional: true
+
+    has_many :order_promotions, class_name: "SolidusPromotions::OrderPromotion", dependent: :destroy
+
+    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(:solidus_order_promotions)
+        .where(SolidusPromotions::OrderPromotion.table_name => { 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