filter available shipping methods based on tags

app/controllers/spree/admin/orders_controller.rb

@@ -150,6 +150,7 @@ def load_distribution_choices
       def ensure_distribution
         unless @order
           @order = Spree::Order.new
+          @order.created_by = spree_current_user
           @order.generate_order_number
           @order.save!
         end

app/helpers/enterprises_helper.rb

@@ -12,14 +12,12 @@ def current_customer
   end
 
   def available_shipping_methods
-    return [] if current_distributor.blank?
-
-    shipping_methods = current_distributor.shipping_methods.display_on_checkout.to_a
-
-    applicator = OpenFoodNetwork::TagRuleApplicator.new(current_distributor, "FilterShippingMethods", current_customer.andand.tag_list)
-    applicator.filter!(shipping_methods)
-
-    shipping_methods.uniq
+    DistributorShippingMethods.shipping_methods(
+      distributor: current_distributor,
+      checkout: true,
+      customer: current_customer,
+      apply_tags: true
+    )
   end
 
   def available_payment_methods

app/models/enterprise.rb

@@ -348,7 +348,9 @@ def supplied_taxons
   end
 
   def ready_for_checkout?
-    shipping_methods.any? && payment_methods.available.any?
+    DistributorShippingMethods.shipping_methods(
+      distributor: self, checkout: true, apply_tags: false
+    ).any? && payment_methods.available.any?
   end
 
   def self.find_available_permalink(test_permalink)

app/models/spree/order.rb

@@ -593,7 +593,9 @@ def create_proposed_shipments
       adjustments.shipping.delete_all
       shipments.destroy_all
 
-      packages = OrderManagement::Stock::Coordinator.new(self).packages
+      packages = OrderManagement::Stock::Coordinator.new(self).packages(
+        checkout: true, apply_tags: !created_by&.admin?
+      )
       packages.each do |package|
         shipments << package.to_shipment
       end

app/models/spree/shipment.rb

@@ -108,7 +108,9 @@ def refresh_rates
 
       # The call to Stock::Estimator below will replace the current shipping_method
       original_shipping_method_id = shipping_method.try(:id)
-      self.shipping_rates = OrderManagement::Stock::Estimator.new(order).shipping_rates(to_package)
+      self.shipping_rates = OrderManagement::Stock::Estimator.new(order).shipping_rates(
+        to_package, checkout: false, apply_tags: false
+      )
 
       keep_original_shipping_method_selection(original_shipping_method_id)
 

app/models/spree/shipping_method.rb

@@ -3,7 +3,6 @@
 module Spree
   class ShippingMethod < ActiveRecord::Base
     include Spree::Core::CalculatedAdjustments
-    DISPLAY = [:both, :front_end, :back_end].freeze
 
     acts_as_taggable
 

app/services/distributor_shipping_methods.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class DistributorShippingMethods
+  def self.shipping_methods(distributor:, customer: nil, checkout: false, apply_tags: true)
+    return [] if distributor.blank?
+
+    shipping_methods = distributor.shipping_methods
+    shipping_methods = shipping_methods.display_on_checkout if checkout
+    shipping_methods = shipping_methods.to_a
+
+    if apply_tags
+      OpenFoodNetwork::TagRuleApplicator.new(
+        distributor, "FilterShippingMethods", customer&.tag_list
+      ).filter!(shipping_methods)
+    end
+
+    shipping_methods.uniq
+  end
+end

engines/order_management/app/services/order_management/stock/coordinator.rb

@@ -9,10 +9,10 @@ def initialize(order)
         @order = order
       end
 
-      def packages
+      def packages(checkout: true, apply_tags: true)
         packages = build_packages
         packages = prioritize_packages(packages)
-        estimate_packages(packages)
+        estimate_packages(packages: packages, checkout: checkout, apply_tags: apply_tags)
       end
 
       # Build package with default stock location
@@ -32,10 +32,12 @@ def prioritize_packages(packages)
         prioritizer.prioritized_packages
       end
 
-      def estimate_packages(packages)
+      def estimate_packages(packages:, checkout: true, apply_tags: true)
         estimator = OrderManagement::Stock::Estimator.new(order)
         packages.each do |package|
-          package.shipping_rates = estimator.shipping_rates(package)
+          package.shipping_rates = estimator.shipping_rates(
+            package, checkout: checkout, apply_tags: apply_tags
+          )
         end
         packages
       end

engines/order_management/app/services/order_management/stock/estimator.rb

@@ -10,9 +10,10 @@ def initialize(order)
         @currency = order.currency
       end
 
-      def shipping_rates(package, frontend_only = true)
+      def shipping_rates(package, checkout: true, apply_tags: true)
         shipping_rates = []
-        shipping_methods = shipping_methods(package)
+        shipping_methods =
+          shipping_methods(package, checkout: checkout, apply_tags: apply_tags)
         return [] unless shipping_methods
 
         shipping_methods.each do |shipping_method|
@@ -23,7 +24,7 @@ def shipping_rates(package, frontend_only = true)
         shipping_rates.sort_by! { |r| r.cost || 0 }
 
         unless shipping_rates.empty?
-          if frontend_only
+          if checkout
             shipping_rates.each do |rate|
               if rate.shipping_method.frontend?
                 rate.selected = true
@@ -40,8 +41,8 @@ def shipping_rates(package, frontend_only = true)
 
       private
 
-      def shipping_methods(package)
-        shipping_methods = package.shipping_methods
+      def shipping_methods(package, checkout: true, apply_tags: true)
+        shipping_methods = package.shipping_methods(checkout: checkout, apply_tags: apply_tags)
         shipping_methods.delete_if { |ship_method| !ship_method.calculator.available?(package) }
         shipping_methods.delete_if { |ship_method| !ship_method.include?(order.ship_address) }
         shipping_methods.delete_if { |ship_method|

engines/order_management/app/services/order_management/stock/package.rb

@@ -79,24 +79,13 @@ def currency
         # TODO calculate from first variant?
       end
 
-      # Returns all existing shipping categories.
-      #   It disables the matching of product shipping category with shipping method's category
-      #   It allows checkout of products with categories that are not the ship method's categories
-      #
-      # @return [Array<Spree::ShippingCategory>]
-      def shipping_categories
-        Spree::ShippingCategory.all
-      end
-
-      # Skips the methods that are not used by the order's distributor
-      #
-      # @return [Array<Spree::ShippingMethod>]
-      def shipping_methods
-        available_shipping_methods = shipping_categories.flat_map(&:shipping_methods).uniq.to_a
-
-        available_shipping_methods.keep_if do |shipping_method|
-          ships_with?(order.distributor.shipping_methods.to_a, shipping_method)
-        end
+      def shipping_methods(checkout: true, apply_tags: true)
+        DistributorShippingMethods.shipping_methods(
+          distributor: order.distributor,
+          checkout: checkout,
+          customer: order.customer,
+          apply_tags: apply_tags
+        )
       end
 
       def inspect
@@ -124,17 +113,6 @@ def to_shipment
 
         shipment
       end
-
-      private
-
-      # Checks whether the given distributor provides the specified shipping method
-      #
-      # @param shipping_methods [Array<Spree::ShippingMethod>]
-      # @param shipping_method [Spree::ShippingMethod]
-      # @return [Boolean]
-      def ships_with?(shipping_methods, shipping_method)
-        shipping_methods.include?(shipping_method)
-      end
     end
   end
 end

engines/order_management/spec/services/order_management/stock/package_spec.rb

@@ -164,16 +164,6 @@ module Stock
             expect(package.shipping_methods).to eq [shipping_method1]
           end
         end
-
-        describe '#shipping_categories' do
-          it "returns ship categories that are not the ship categories of the order's products" do
-            package
-            other_shipping_category = Spree::ShippingCategory.create(name: "Custom")
-
-            expect(package.shipping_categories).to eq [shipping_method1.shipping_categories.first,
-                                                       other_shipping_category]
-          end
-        end
       end
     end
   end

spec/lib/open_food_network/tag_rule_applicator_spec.rb

@@ -11,7 +11,6 @@ module OpenFoodNetwork
     let!(:product_tag_rule2) { create(:filter_products_tag_rule, enterprise: enterprise, priority: 4, preferred_customer_tags: "tag1", preferred_variant_tags: "tag3", preferred_matched_variants_visibility: "hidden" ) }
     let!(:product_tag_rule3) { create(:filter_products_tag_rule, enterprise: enterprise, priority: 3, preferred_customer_tags: "tag2", preferred_variant_tags: "tag1", preferred_matched_variants_visibility: "visible" ) }
     let!(:default_product_tag_rule) { create(:filter_products_tag_rule, enterprise: enterprise, priority: 2, is_default: true, preferred_variant_tags: "tag1", preferred_matched_variants_visibility: "hidden" ) }
-    let!(:sm_tag_rule) { create(:filter_shipping_methods_tag_rule, enterprise: enterprise, priority: 1, preferred_customer_tags: "tag1", preferred_shipping_method_tags: "tag1", preferred_matched_shipping_methods_visibility: "visible" ) }
 
     describe "initialisation" do
       context "when enterprise is nil" do

spec/services/distributor_shipping_methods_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DistributorShippingMethods do
+  let!(:enterprise) { create(:distributor_enterprise) }
+  let!(:shipping_method) { create(:shipping_method, distributors: [enterprise]) }
+  let!(:member_shipping_method) { create(:shipping_method, distributors: [enterprise]) }
+  let!(:backend_shipping_method) { create(:shipping_method, distributors: [enterprise]) }
+  let!(:customer) { create(:customer) }
+  let!(:sm_tag_rule) {
+    create(
+      :filter_shipping_methods_tag_rule,
+      enterprise: enterprise,
+      priority: 2,
+      preferred_customer_tags: "member",
+      preferred_shipping_method_tags: "member",
+      preferred_matched_shipping_methods_visibility: "visible"
+    )
+  }
+
+  let!(:default_sm_tag_rule) {
+    create(
+      :filter_shipping_methods_tag_rule,
+      enterprise: enterprise,
+      priority: 1,
+      is_default: true,
+      preferred_shipping_method_tags: [],
+      preferred_customer_tags: [],
+      preferred_matched_shipping_methods_visibility: "hidden"
+    )
+  }
+
+  it "returns all shipping methods for a distributor" do
+    expect(DistributorShippingMethods.shipping_methods(distributor: enterprise).count).to eq(3)
+  end
+
+  it "does not return a shipping method tagged as 'member' for a customer without that tag" do
+    member_shipping_method.tag_list << "member"
+    member_shipping_method.save
+    result =
+      DistributorShippingMethods.shipping_methods(distributor: enterprise, customer: customer)
+    expect(result).to include(shipping_method)
+    expect(result).to include(backend_shipping_method)
+  end
+
+  it "returns the shipping method tagged 'member' for a customer with that tag" do
+    member_customer = create(:customer)
+    member_customer.tag_list << "member"
+    member_customer.save
+    member_shipping_method.tag_list << "member"
+    member_shipping_method.save
+    result = DistributorShippingMethods.shipping_methods(
+      distributor: enterprise, customer: member_customer
+    )
+    expect(result).to include(member_shipping_method)
+  end
+
+  it "does not return a non-checkout shipping method if passed checkout=true" do
+    backend_shipping_method.display_on = "back_end"
+    backend_shipping_method.save
+    result = DistributorShippingMethods.shipping_methods(
+      distributor: enterprise, checkout: true, customer: customer
+    )
+    expect(result).to include(shipping_method)
+  end
+end