solidus_friendly_promotions 1.0.0.pre

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    # A rule to apply a promotion only to line items with or without a chosen product
+    class LineItemProduct < PromotionRule
+      include LineItemLevelRule
+
+      MATCH_POLICIES = %w[include exclude].freeze
+
+      has_many :product_promotion_rules,
+        dependent: :destroy,
+        foreign_key: :promotion_rule_id,
+        class_name: "SolidusFriendlyPromotions::ProductsPromotionRule"
+      has_many :products,
+        class_name: "Spree::Product",
+        through: :product_promotion_rules
+
+      preference :match_policy, :string, default: MATCH_POLICIES.first
+
+      def eligible?(line_item, _options = {})
+        order_includes_product = product_ids.include?(line_item.variant.product_id)
+        success = inverse? ? !order_includes_product : order_includes_product
+
+        unless success
+          message_code = inverse? ? :has_excluded_product : :no_applicable_products
+          eligibility_errors.add(
+            :base,
+            eligibility_error_message(message_code),
+            error_code: message_code
+          )
+        end
+
+        success
+      end
+
+      def product_ids_string
+        product_ids.join(",")
+      end
+
+      def product_ids_string=(product_ids)
+        self.product_ids = product_ids.to_s.split(",").map(&:strip)
+      end
+
+      private
+
+      def inverse?
+        preferred_match_policy == "exclude"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    class LineItemTaxon < PromotionRule
+      include LineItemLevelRule
+
+      has_many :promotion_rule_taxons, class_name: "SolidusFriendlyPromotions::PromotionRulesTaxon", foreign_key: :promotion_rule_id,
+        dependent: :destroy
+      has_many :taxons, through: :promotion_rule_taxons, class_name: "Spree::Taxon"
+
+      MATCH_POLICIES = %w[include exclude].freeze
+
+      validates :preferred_match_policy, inclusion: {in: MATCH_POLICIES}
+
+      preference :match_policy, :string, default: MATCH_POLICIES.first
+
+      def eligible?(line_item, _options = {})
+        found = Spree::Classification.where(
+          product_id: line_item.variant.product_id,
+          taxon_id: rule_taxon_ids_with_children
+        ).exists?
+
+        case preferred_match_policy
+        when "include"
+          found
+        when "exclude"
+          !found
+        else
+          raise "unexpected match policy: #{preferred_match_policy.inspect}"
+        end
+      end
+
+      def taxon_ids_string
+        taxons.pluck(:id).join(",")
+      end
+
+      def taxon_ids_string=(taxon_ids)
+        taxon_ids = taxon_ids.to_s.split(",").map(&:strip)
+        self.taxons = Spree::Taxon.find(taxon_ids)
+      end
+
+      def updateable?
+        true
+      end
+
+      private
+
+      # ids of taxons rules and taxons rules children
+      def rule_taxon_ids_with_children
+        taxons.flat_map { |taxon| taxon.self_and_descendants.ids }.uniq
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    # Promotion rule for ensuring an order contains a minimum quantity of
+    # applicable items.
+    #
+    # This promotion rule is only compatible with the "all" match policy. It
+    # doesn't make a lot of sense to use it without that policy as it reduces
+    # it to a simple quantity check across the entire order which would be
+    # better served by an item total rule.
+    class MinimumQuantity < PromotionRule
+      include OrderLevelRule
+
+      validates :preferred_minimum_quantity, numericality: {only_integer: true, greater_than: 0}
+
+      preference :minimum_quantity, :integer, default: 1
+
+      # Will look at all of the "applicable" line items in the order and
+      # determine if the sum of their quantity is greater than the minimum.
+      #
+      # "Applicable" items are ones that pass all eligibility checks of applicable rules.
+      #
+      # When false is returned, the reason will be included in the
+      # `eligibility_errors` object.
+      #
+      # @param order [Spree::Order] the order we want to check eligibility on
+      # @return [Boolean] true if promotion is eligible, false otherwise
+      def eligible?(order)
+        applicable_line_items = order.line_items.select do |line_item|
+          promotion.rules.select do |rule|
+            rule.applicable?(line_item)
+          end.all? { _1.eligible?(line_item) }
+        end
+
+        if applicable_line_items.sum(&:quantity) < preferred_minimum_quantity
+          eligibility_errors.add(
+            :base,
+            eligibility_error_message(:quantity_less_than_minimum, count: preferred_minimum_quantity),
+            error_code: :quantity_less_than_minimum
+          )
+        end
+
+        eligibility_errors.empty?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    class NthOrder < PromotionRule
+      include OrderLevelRule
+
+      preference :nth_order, :integer, default: 2
+      # It does not make sense to have this apply to the first order using preferred_nth_order == 1
+      # Instead we could use the first_order rule
+      validates :preferred_nth_order, numericality: {only_integer: true, greater_than: 1}
+
+      # This is never eligible if the order does not have a user, and that user does not have any previous completed orders.
+      #
+      # Use the first order rule if you want a promotion to be applied to the first order for a user.
+      # @param order [Spree::Order]
+      def eligible?(order, _options = {})
+        return false unless order.user
+
+        nth_order?(order)
+      end
+
+      private
+
+      def completed_order_count(order)
+        order
+          .user
+          .orders
+          .complete
+          .where(Spree::Order.arel_table[:completed_at].lt(order.completed_at || Time.current))
+          .count
+      end
+
+      def nth_order?(order)
+        count = completed_order_count(order) + 1
+        count == preferred_nth_order
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    class OneUsePerUser < PromotionRule
+      include OrderLevelRule
+
+      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),
+              error_code: :limit_once_per_user
+            )
+          end
+        else
+          eligibility_errors.add(:base, eligibility_error_message(:no_user_specified), error_code: :no_user_specified)
+        end
+
+        eligibility_errors.empty?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    class OptionValue < PromotionRule
+      include LineItemApplicableOrderRule
+
+      preference :eligible_values, :hash
+
+      def order_eligible?(order)
+        order.line_items.any? { |item| line_item_eligible?(item) }
+      end
+
+      def line_item_eligible?(line_item)
+        LineItemOptionValue.new(preferred_eligible_values: preferred_eligible_values).eligible?(line_item)
+      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
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    # 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.
+    class Product < PromotionRule
+      include LineItemApplicableOrderRule
+
+      has_many :products_promotion_rules,
+        dependent: :destroy,
+        foreign_key: :promotion_rule_id,
+        class_name: "SolidusFriendlyPromotions::ProductsPromotionRule"
+      has_many :products, class_name: "Spree::Product", through: :products_promotion_rules
+
+      def preload_relations
+        [:products]
+      end
+
+      MATCH_POLICIES = %w[any all none only].freeze
+
+      validates :preferred_match_policy, inclusion: {in: MATCH_POLICIES}
+
+      preference :match_policy, :string, default: MATCH_POLICIES.first
+
+      # scope/association that is used to test eligibility
+      def eligible_products
+        products
+      end
+
+      def order_eligible?(order)
+        return true if eligible_products.empty?
+
+        case preferred_match_policy
+        when "all"
+          unless eligible_products.all? { |product| order_products(order).include?(product) }
+            eligibility_errors.add(:base, eligibility_error_message(:missing_product), error_code: :missing_product)
+          end
+        when "any"
+          unless order_products(order).any? { |product| eligible_products.include?(product) }
+            eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products),
+              error_code: :no_applicable_products)
+          end
+        when "none"
+          unless order_products(order).none? { |product| eligible_products.include?(product) }
+            eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product),
+              error_code: :has_excluded_product)
+          end
+        when "only"
+          unless order_products(order).all? { |product| eligible_products.include?(product) }
+            eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product),
+              error_code: :has_excluded_product)
+          end
+        else
+          raise "unexpected match policy: #{preferred_match_policy.inspect}"
+        end
+
+        eligibility_errors.empty?
+      end
+
+      def line_item_eligible?(line_item, _options = {})
+        # The order level eligibility check happens first, and if none of the products
+        # are in the order, then no line items should be available to check.
+        raise "This should not happen" if preferred_match_policy == "none"
+        product_ids.include?(line_item.variant.product_id)
+      end
+
+      def product_ids_string
+        product_ids.join(",")
+      end
+
+      def product_ids_string=(product_ids)
+        self.product_ids = product_ids.to_s.split(",").map(&:strip)
+      end
+
+      private
+
+      def order_products(order)
+        order.line_items.map(&:variant).map(&:product)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    class ShippingMethod < PromotionRule
+      include ShipmentLevelRule
+
+      preference :shipping_method_ids, type: :array, default: []
+
+      def applicable?(promotable)
+        promotable.is_a?(Spree::Shipment) || promotable.is_a?(Spree::ShippingRate)
+      end
+
+      def eligible?(promotable)
+        promotable.shipping_method&.id&.in?(preferred_shipping_method_ids.map(&:to_i))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    class Store < PromotionRule
+      include OrderLevelRule
+
+      has_many :promotion_rules_stores, class_name: "SolidusFriendlyPromotions::PromotionRulesStore",
+        foreign_key: :promotion_rule_id,
+        dependent: :destroy
+      has_many :stores, through: :promotion_rules_stores, class_name: "Spree::Store"
+
+      def preload_relations
+        [:stores]
+      end
+
+      def eligible?(order, _options = {})
+        stores.none? || stores.include?(order.store)
+      end
+
+      def updateable?
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    class Taxon < PromotionRule
+      include LineItemApplicableOrderRule
+
+      has_many :promotion_rules_taxons, class_name: "SolidusFriendlyPromotions::PromotionRulesTaxon", foreign_key: :promotion_rule_id,
+        dependent: :destroy
+      has_many :taxons, through: :promotion_rules_taxons, class_name: "Spree::Taxon"
+
+      def preload_relations
+        [:taxons]
+      end
+
+      MATCH_POLICIES = %w[any all none].freeze
+
+      validates :preferred_match_policy, inclusion: {in: MATCH_POLICIES}
+
+      preference :match_policy, :string, default: MATCH_POLICIES.first
+
+      def order_eligible?(order)
+        order_taxons = taxons_in_order(order)
+
+        case preferred_match_policy
+        when "all"
+          matches_all = taxons.all? do |rule_taxon|
+            order_taxons.where(id: rule_taxon.self_and_descendants.ids).exists?
+          end
+
+          unless matches_all
+            eligibility_errors.add(:base, eligibility_error_message(:missing_taxon), error_code: :missing_taxon)
+          end
+        when "any"
+          unless order_taxons.where(id: rule_taxon_ids_with_children).exists?
+            eligibility_errors.add(
+              :base,
+              eligibility_error_message(:no_matching_taxons),
+              error_code: :no_matching_taxons
+            )
+          end
+        when "none"
+          if order_taxons.where(id: rule_taxon_ids_with_children).exists?
+            eligibility_errors.add(
+              :base,
+              eligibility_error_message(:has_excluded_taxon),
+              error_code: :has_excluded_taxon
+            )
+          end
+        else
+          raise "unexpected match policy: #{preferred_match_policy.inspect}"
+        end
+
+        eligibility_errors.empty?
+      end
+
+      def line_item_eligible?(line_item)
+        # The order level eligibility check happens first, and if none of the taxons
+        # are in the order, then no line items should be available to check.
+        raise "This should not happen" if preferred_match_policy == "none"
+
+        raise "unexpected match policy: #{preferred_match_policy.inspect}" unless preferred_match_policy.in?(MATCH_POLICIES)
+
+        Spree::Classification.where(
+          product_id: line_item.variant.product_id,
+          taxon_id: rule_taxon_ids_with_children
+        ).exists?
+      end
+
+      def taxon_ids_string
+        taxon_ids.join(",")
+      end
+
+      def taxon_ids_string=(taxon_ids)
+        self.taxon_ids = taxon_ids.to_s.split(",").map(&:strip)
+      end
+
+      def updateable?
+        true
+      end
+
+      private
+
+      # All taxons in an order
+      def taxons_in_order(order)
+        Spree::Taxon
+          .joins(products: {variants_including_master: :line_items})
+          .where(spree_line_items: {order_id: order.id})
+          .distinct
+      end
+
+      # ids of taxons rules and taxons rules children
+      def rule_taxon_ids_with_children
+        taxons.flat_map { |taxon| taxon.self_and_descendants.ids }.uniq
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    class User < PromotionRule
+      include OrderLevelRule
+
+      has_many :promotion_rules_users,
+        class_name: "SolidusFriendlyPromotions::PromotionRulesUser",
+        foreign_key: :promotion_rule_id,
+        dependent: :destroy
+      has_many :users, through: :promotion_rules_users, class_name: Spree::UserClassHandle.new
+
+      def preload_relations
+        [:users]
+      end
+
+      def eligible?(order, _options = {})
+        users.include?(order.user)
+      end
+
+      def user_ids_string
+        user_ids.join(",")
+      end
+
+      def user_ids_string=(user_ids)
+        self.user_ids = user_ids.to_s.split(",").map(&:strip)
+      end
+
+      def updateable?
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    class UserLoggedIn < PromotionRule
+      include OrderLevelRule
+
+      def eligible?(order, _options = {})
+        if order.user.blank?
+          eligibility_errors.add(:base, eligibility_error_message(:no_user_specified), error_code: :no_user_specified)
+        end
+        eligibility_errors.empty?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    class UserRole < PromotionRule
+      include OrderLevelRule
+
+      preference :role_ids, :array, default: []
+
+      MATCH_POLICIES = %w[any all].freeze
+      preference :match_policy, default: MATCH_POLICIES.first
+
+      def eligible?(order, _options = {})
+        return false unless order.user
+
+        if all_match_policy?
+          match_all_roles?(order)
+        else
+          match_any_roles?(order)
+        end
+      end
+
+      private
+
+      def all_match_policy?
+        preferred_match_policy == "all" && preferred_role_ids.present?
+      end
+
+      def user_roles(order)
+        order.user.spree_roles.where(id: preferred_role_ids)
+      end
+
+      def match_all_roles?(order)
+        user_roles(order).count == preferred_role_ids.count
+      end
+
+      def match_any_roles?(order)
+        user_roles(order).exists?
+      end
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/shipping_rate_discount.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class ShippingRateDiscount < Spree::Base
+    belongs_to :shipping_rate, inverse_of: :discounts, class_name: "Spree::ShippingRate"
+    belongs_to :promotion_action, -> { with_discarded }, inverse_of: false
+
+    extend Spree::DisplayMoney
+    money_methods :amount
+  end
+end

data/app/models/solidus_friendly_promotions/simple_order_contents.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class SimpleOrderContents < Spree::OrderContents
+    def update_cart(params)
+      if order.update(params)
+        unless order.completed?
+          order.line_items = order.line_items.select { |li| li.quantity > 0 }
+          order.check_shipments_and_restart_checkout
+        end
+        reload_totals
+        true
+      else
+        false
+      end
+    end
+
+    private
+
+    def after_add_or_remove(line_item, options = {})
+      shipment = options[:shipment]
+      shipment.present? ? shipment.update_amounts : order.check_shipments_and_restart_checkout
+      reload_totals
+      line_item
+    end
+  end
+end

data/app/models/solidus_friendly_promotions.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  def self.table_name_prefix
+    "friendly_"
+  end
+end

data/app/views/solidus_friendly_promotions/admin/promotion_actions/_calculator_select.html.erb

@@ -0,0 +1,16 @@
+<%= form_with model: promotion_action, scope: :promotion_action, url: path, method: :get do |form| %>
+  <div class="field">
+    <%= form.hidden_field :type %>
+    <%= form.label :calculator_type %>
+    <%=
+      form.select :calculator_type,
+        options_for_promotion_action_calculator_types(form.object),
+        {
+          include_blank: t(:choose_promotion_action_calculator, scope: 'solidus_friendly_promotions')
+        },
+        class: 'custom-select fullwidth',
+        onchange: 'this.form.requestSubmit()',
+        required: true
+    %>
+  </div>
+<% end %>

data/app/views/solidus_friendly_promotions/admin/promotion_actions/_form.html.erb

@@ -0,0 +1,3 @@
+<%= form.hidden_field :type %>
+<%= form.hidden_field :calculator_type %>
+<%= render form.object, promotion_action: form.object, param_prefix: form.object_name, form: form %>

data/app/views/solidus_friendly_promotions/admin/promotion_actions/_promotion_action.html.erb

@@ -0,0 +1,29 @@
+<%= turbo_frame_tag @promotion, dom_id(promotion_action) do %>
+  <div class="promotion_action promotion-block">
+    <h6 class='promotion-title'> <%= promotion_action.model_name.human %></h6>
+
+    <% if can?(:destroy, promotion_action) %>
+      <%= link_to_with_icon 'trash', '', solidus_friendly_promotions.admin_promotion_promotion_action_path(@promotion, promotion_action), method: :delete, class: 'delete' %>
+    <% end %>
+
+
+    <%= render "solidus_friendly_promotions/admin/promotion_actions/calculator_select",
+      path: solidus_friendly_promotions.edit_admin_promotion_promotion_action_path(@promotion, promotion_action),
+      promotion_action: promotion_action %>
+
+    <%=
+      form_with(
+      model: promotion_action,
+      scope: :promotion_action,
+      url: solidus_friendly_promotions.admin_promotion_promotion_action_path(@promotion, promotion_action),
+      data: { turbo: false }
+    ) do |form| %>
+      <%= render 'solidus_friendly_promotions/admin/promotion_actions/form', form: form %>
+      <div class="row">
+        <div class="col-12">
+          <%= button_tag "Update", class: "btn btn-secondary float-right" %>
+        </div>
+      </div>
+    <% end %>
+  </div>
+<% end %>