solidus_promotions 4.6.2 → 4.7.0

data/app/models/solidus_promotions/calculators/tiered_percent_on_eligible_item_quantity.rb

@@ -4,34 +4,119 @@ require_dependency "spree/calculator"
 
 module SolidusPromotions
   module Calculators
-    class TieredPercentOnEligibleItemQuantity < SolidusPromotions::Calculators::TieredPercent
-      preference :tiers, :hash, default: { 10 => 5 }
-
-      before_validation do
-        # Convert tier values to decimals. Strings don't do us much good.
-        if preferred_tiers.is_a?(Hash)
-          self.preferred_tiers = preferred_tiers.map do |key, value|
-            [key.to_i, cast_to_d(value.to_s)]
-          end.to_h
-        end
-      end
+    # A calculator that applies tiered percentage discounts based on the total quantity of eligible items.
+    #
+    # This calculator defines discount tiers based on the combined quantity of all eligible line items
+    # in an order (not their monetary value). Each tier specifies a minimum quantity threshold and the
+    # corresponding percentage discount to apply. The calculator selects the highest tier that the
+    # order's eligible item quantity meets or exceeds.
+    #
+    # The tier thresholds are evaluated against the total quantity of eligible line items, but the
+    # percentage discount is applied to each individual item's discountable amount. This makes it
+    # ideal for "buy more, save more" promotions based on item count rather than order value.
+    #
+    # If the total eligible quantity doesn't meet any tier threshold, the base percentage is used.
+    # The discount is only applied if the currency matches the preferred currency.
+    #
+    # @example Use case: Bulk quantity discounts
+    #   # Buy 10+ items get 5% off, 25+ get 10% off, 50+ get 15% off
+    #   calculator = TieredPercentOnEligibleItemQuantity.new(
+    #     preferred_base_percent: 0,
+    #     preferred_tiers: {
+    #       10 => 5,   # 5% off when total eligible quantity >= 10
+    #       25 => 10,  # 10% off when total eligible quantity >= 25
+    #       50 => 15   # 15% off when total eligible quantity >= 50
+    #     },
+    #     preferred_currency: 'USD'
+    #   )
+    #
+    # @example Use case: Multi-item bundle promotions
+    #   # Encourage buying multiple items from a category
+    #   calculator = TieredPercentOnEligibleItemQuantity.new(
+    #     preferred_base_percent: 0,
+    #     preferred_tiers: {
+    #       3 => 10,   # 10% off when buying 3+ eligible items
+    #       5 => 15,   # 15% off when buying 5+ eligible items
+    #       10 => 20   # 20% off when buying 10+ eligible items
+    #     },
+    #     preferred_currency: 'USD'
+    #   )
+    class TieredPercentOnEligibleItemQuantity < Spree::Calculator
+      include PromotionCalculator
+
+      preference :base_percent, :decimal, default: Spree::ZERO
+      preference :tiers, :hash, default: {10 => 5}
+      preference :currency, :string, default: -> { Spree::Config[:currency] }
 
-      def compute_line_item(line_item)
-        order = line_item.order
+      before_validation :transform_preferred_tiers
+
+      # Computes the tiered percentage discount for an item based on total eligible item quantity.
+      #
+      # Evaluates the total quantity of all eligible line items in the order against all defined
+      # tiers and selects the highest tier threshold that is met or exceeded. Returns a percentage
+      # of the item's discountable amount based on the matching tier, or the base percentage if no
+      # tier threshold is met. Returns 0 if the currency doesn't match.
+      #
+      # @param item [Object] The object to calculate the discount for (e.g., LineItem, Shipment, ShippingRate)
+      #
+      # @return [BigDecimal] The percentage-based discount amount, rounded to currency precision
+      #
+      # @example Computing discount with tier matching
+      #   calculator = TieredPercentOnEligibleItemQuantity.new(
+      #     preferred_base_percent: 0,
+      #     preferred_tiers: { 10 => 10, 25 => 15 }
+      #   )
+      #   # Order has 3 eligible line items with quantities: 5, 6, 4 (total: 15)
+      #   line_item.discountable_amount # => 50.00
+      #   calculator.compute_item(line_item) # => 5.00 (10% of $50, matches quantity tier of 10)
+      #
+      # @example Computing discount below all tiers
+      #   calculator = TieredPercentOnEligibleItemQuantity.new(
+      #     preferred_base_percent: 5,
+      #     preferred_tiers: { 10 => 10, 25 => 15 }
+      #   )
+      #   # Order has 2 eligible line items with quantities: 3, 4 (total: 7)
+      #   line_item.discountable_amount # => 30.00
+      #   calculator.compute_item(line_item) # => 1.50 (5% base percent of $30)
+      #
+      # @example Computing discount with currency mismatch
+      #   calculator = TieredPercentOnEligibleItemQuantity.new(
+      #     preferred_currency: 'USD',
+      #     preferred_tiers: { 10 => 10 }
+      #   )
+      #   order.currency # => 'EUR'
+      #   calculator.compute_item(line_item) # => 0
+      def compute_item(item)
+        order = item.order
 
         _base, percent = preferred_tiers.sort.reverse.detect do |value, _|
           eligible_line_items_quantity_total(order) >= value
         end
         if preferred_currency.casecmp(order.currency).zero?
-          currency_exponent = ::Money::Currency.find(preferred_currency).exponent
-          (line_item.discountable_amount * (percent || preferred_base_percent) / 100).round(currency_exponent)
+          round_to_currency(item.discountable_amount * (percent || preferred_base_percent) / 100, preferred_currency)
         else
-          0
+          Spree::ZERO
         end
       end
+      alias_method :compute_shipment, :compute_item
+      alias_method :compute_shipping_rate, :compute_item
+      alias_method :compute_line_item, :compute_item
 
       private
 
+      # Transforms preferred_tiers keys to integers and values to BigDecimal.
+      #
+      # Converts tier threshold keys (item quantities) to integers and percentage values
+      # to BigDecimal for consistent calculations.
+      def transform_preferred_tiers
+        preferred_tiers.transform_keys!(&:to_i)
+        preferred_tiers.transform_values! { |value| value.to_s.to_d }
+      end
+
+      # Calculates the total quantity of all eligible line items in the order.
+      #
+      # @param order [Spree::Order] The order to calculate eligible quantity for
+      # @return [Integer] The sum of quantities for all applicable line items
       def eligible_line_items_quantity_total(order)
         calculable.applicable_line_items(order).sum(&:quantity)
       end

data/app/models/solidus_promotions/condition.rb

@@ -1,6 +1,48 @@
 # frozen_string_literal: true
 
 module SolidusPromotions
+  # Base class for all promotion conditions.
+  #
+  # Conditions determine whether a promotion is eligible to be applied to a specific
+  # promotable object (such as an order or line item). Each condition subclass implements
+  # the eligibility logic and specifies what type of objects it can be applied to.
+  #
+  # Conditions work at different levels:
+  # - Order-level conditions (include OrderLevelCondition): Check entire orders
+  # - Line item-level conditions (include LineItemLevelCondition): Check individual line items
+  # - Hybrid conditions (include LineItemApplicableOrderLevelCondition): Check orders but can also
+  #   filter which line items are eligible
+  #
+  # @abstract Subclass and override {#applicable?} and {#eligible?} to implement
+  #   a custom condition.
+  #
+  # @example Creating an order-level condition
+  #   class MinimumPurchaseCondition < Condition
+  #     include OrderLevelCondition
+  #
+  #     preference :minimum_amount, :decimal, default: 50.00
+  #
+  #     def eligible?(order, _options = {})
+  #       if order.item_total < preferred_minimum_amount
+  #         eligibility_errors.add(:base, "Order total too low")
+  #       end
+  #       eligibility_errors.empty?
+  #     end
+  #   end
+  #
+  # @example Creating a line item-level condition
+  #   class SpecificProductCondition < Condition
+  #     include LineItemLevelCondition
+  #
+  #     preference :product_id, :integer
+  #
+  #     def eligible?(line_item, _options = {})
+  #       if line_item.product_id != preferred_product_id
+  #         eligibility_errors.add(:base, "Wrong product")
+  #       end
+  #       eligibility_errors.empty?
+  #     end
+  #   end
   class Condition < Spree::Base
     include Spree::Preferences::Persistable
 
@@ -12,46 +54,183 @@ module SolidusPromotions
     validate :unique_per_benefit, on: :create
     validate :possible_condition_for_benefit, if: -> { benefit.present? }
 
+    class << self
+      # Returns the subset of conditions that can compute eligibility instances of the provided array of classes.
+      #
+      # @example SolidusPromotions::Condition.applicable_to([Spree::Order, Spree::LineItem])
+      #
+      # @param [Array<Class>] An array of classes to compute eligibility for
+      # @return [Array<SolidusPromotions::Condition>] Conditions that can compute eligibility for the provided classes.
+      def applicable_to(classes)
+        SolidusPromotions.config.conditions.select do |condition_class|
+          (condition_class.instance_methods & classes.map { |k| eligible_method_for(k) }).any?
+        end
+      end
+
+      # Generates the eligibility method name for a promotable
+      #
+      # @return [Symbol] the method name
+      def eligible_method_for(promotable_class)
+        :"#{promotable_class.name.demodulize.underscore}_eligible?"
+      end
+    end
+
+    # Returns relations that should be preloaded for this condition.
+    #
+    # Override this method in subclasses to specify associations that should be eager loaded
+    # to avoid N+1 queries when evaluating conditions.
+    #
+    # @return [Array<Symbol>] An array of association names to preload
+    #
+    # @example Preloading products association
+    #   def preload_relations
+    #     [:products]
+    #   end
     def preload_relations
       []
     end
 
-    def applicable?(_promotable)
-      raise NotImplementedError, "applicable? should be implemented in a sub-class of SolidusPromotions::Rule"
+    # Determines if this condition can be applied to a given promotable object.
+    #
+    # @param _promotable [Object] The object to check (e.g., Spree::Order, Spree::LineItem)
+    #
+    # @return [Boolean] true if this condition applies to the promotable type
+    #
+    # @example Condition applicability
+    #   condition.applicable?(order)      # => true
+    #   condition.applicable?(line_item)  # => false
+    def applicable?(promotable)
+      respond_to?(eligible_method_for(promotable))
     end
 
-    def eligible?(_promotable, _options = {})
-      raise NotImplementedError, "eligible? should be implemented in a sub-class of SolidusPromotions::Rule"
+    # Determines if the promotable object meets this condition's eligibility requirements.
+    #
+    # This typically dispatches to a specific eligibility method defined on a subclass, such as
+    # `#order_eligible?` or `line_item_eligible?`.
+    #
+    # @param _promotable [Object] The object to evaluate (e.g., Spree::Order, Spree::LineItem)
+    # @param _options [Hash] Additional options for eligibility checking
+    #
+    # @return [Boolean] true if the promotable meets the condition, false otherwise
+    #
+    # @see #eligibility_errors
+    def eligible?(promotable, ...)
+      if applicable?(promotable)
+        send(eligible_method_for(promotable), promotable, ...)
+      else
+        raise NotImplementedError, "Please implement #{eligible_method_for(promotable)} in your condition"
+      end
     end
 
-    def level
-      raise NotImplementedError, "level should be implemented in a sub-class of SolidusPromotions::Rule"
+    def self.inherited(klass)
+      def klass.method_added(method_added)
+        if method_added == :eligible?
+          Spree.deprecator.warn <<~MSG
+            Please refactor `#{name}`. You're defining `eligible?`. Instead, define method for each type of promotable
+            that your condition can be applied to. For example:
+            ```
+            class MyCondition < SolidusPromotions::Condition
+              def applicable?(promotable)
+                promotable.is_a?(Spree::Order)
+              end
+
+              def eligible?(order)
+                order.total > 20
+              end
+            ```
+            can now become
+            ```
+            class MyCondition < SolidusPromotions::Condition
+              def order_eligible?(order)
+                order.total > 20
+              end
+            end
+            ```
+          MSG
+        end
+        super
+      end
+      super
     end
 
+    def level
+      raise NotImplementedError, "level should be implemented in a sub-class of SolidusPromotions::Condition"
+    end
+    deprecate :level, deprecator: Spree.deprecator
+
+    # Returns an errors object for tracking eligibility failures.
+    #
+    # When {#eligible?} determines that a promotable doesn't meet the condition,
+    # it should add descriptive errors to this object. These errors are used to
+    # provide feedback about why a promotion isn't being applied.
+    #
+    # @return [ActiveModel::Errors] An errors collection for this condition
+    #
+    # @example Adding an eligibility error
+    #   def eligible?(order, _options = {})
+    #     if order.item_total < 50
+    #       eligibility_errors.add(:base, "Minimum order is $50", error_code: :item_total_too_low)
+    #     end
+    #     eligibility_errors.empty?
+    #   end
     def eligibility_errors
       @eligibility_errors ||= ActiveModel::Errors.new(self)
     end
 
+    # Returns the partial path for rendering this condition in the admin interface.
+    #
+    # @return [String] The path to the admin form partial for this condition
+    #
+    # @example
+    #   # For SolidusPromotions::Conditions::ItemTotal
+    #   # => "solidus_promotions/admin/condition_fields/item_total"
     def to_partial_path
       "solidus_promotions/admin/condition_fields/#{model_name.element}"
     end
 
+    # Determines if this condition can be updated in the admin interface.
+    #
+    # A condition is considered updateable if it has any preferences that can be configured.
+    #
+    # @return [Boolean] true if the condition has configurable preferences
     def updateable?
       preferences.any?
     end
 
     private
 
+    def eligible_method_for(promotable)
+      self.class.eligible_method_for(promotable.class)
+    end
+
+    # Validates that only one instance of this condition type exists per benefit.
+    #
+    # Prevents duplicate conditions of the same type from being added to a single benefit.
     def unique_per_benefit
       return unless self.class.exists?(benefit_id: benefit_id, type: self.class.name)
 
       errors.add(:benefit, :already_contains_condition_type)
     end
 
+    # Validates that this condition type is allowed for the associated benefit.
+    #
+    # Checks the benefit's {Benefit#applicable_conditions} to ensure this condition
+    # type is compatible.
     def possible_condition_for_benefit
-      benefit.possible_conditions.include?(self.class) || errors.add(:type, :invalid_condition_type)
+      benefit.class.applicable_conditions.include?(self.class) || errors.add(:type, :invalid_condition_type)
     end
 
+    # Generates a translated eligibility error message.
+    #
+    # Looks up the error message in the I18n translations under the condition's scope.
+    #
+    # @param key [Symbol] The I18n key for the error message
+    # @param options [Hash] Interpolation options for the message
+    #
+    # @return [String] The translated error message
+    #
+    # @example
+    #   eligibility_error_message(:item_total_too_low, minimum: "$50")
     def eligibility_error_message(key, options = {})
       I18n.t(key, scope: [:solidus_promotions, :eligibility_errors, self.class.name.underscore], **options)
     end

data/app/models/solidus_promotions/conditions/first_order.rb

@@ -3,10 +3,12 @@
 module SolidusPromotions
   module Conditions
     class FirstOrder < Condition
+      # TODO: Remove in Solidus 5
       include OrderLevelCondition
+
       attr_reader :user, :email
 
-      def eligible?(order, options = {})
+      def order_eligible?(order, options = {})
         @user = order.try(:user) || options[:user]
         @email = order.email
 

data/app/models/solidus_promotions/conditions/first_repeat_purchase_since.rb

@@ -3,16 +3,17 @@
 module SolidusPromotions
   module Conditions
     class FirstRepeatPurchaseSince < Condition
+      # TODO: Remove in Solidus 5
       include OrderLevelCondition
 
       preference :days_ago, :integer, default: 365
-      validates :preferred_days_ago, numericality: { only_integer: true, greater_than: 0 }
+      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 = {})
+      def order_eligible?(order, _options = {})
         return false unless order.user
 
         last_order = last_completed_order(order.user)

data/app/models/solidus_promotions/conditions/item_total.rb

@@ -8,6 +8,7 @@ module SolidusPromotions
     # 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 < Condition
+      # TODO: Remove in Solidus 5
       include OrderLevelCondition
 
       preference :amount, :decimal, default: 100.00
@@ -28,7 +29,7 @@ module SolidusPromotions
         end
       end
 
-      def eligible?(order, _options = {})
+      def order_eligible?(order, _options = {})
         return false unless order.currency == preferred_currency
 
         unless total_for_order(order).send(operator, threshold)

data/app/models/solidus_promotions/conditions/line_item_option_value.rb

@@ -3,26 +3,18 @@
 module SolidusPromotions
   module Conditions
     class LineItemOptionValue < Condition
+      # TODO: Remove in Solidus 5
       include LineItemLevelCondition
 
-      preference :eligible_values, :hash
+      include OptionValueCondition
 
-      def eligible?(line_item, _options = {})
+      def line_item_eligible?(line_item, _options = {})
         pid = line_item.product.id
-        ovids = line_item.variant.option_values.pluck(:id)
+        ovids = line_item.variant.option_value_ids
 
         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

data/app/models/solidus_promotions/conditions/line_item_product.rb

@@ -4,26 +4,16 @@ module SolidusPromotions
   module Conditions
     # A condition to apply a promotion only to line items with or without a chosen product
     class LineItemProduct < Condition
+      # TODO: Remove in Solidus 5
       include LineItemLevelCondition
 
-      MATCH_POLICIES = %w[include exclude].freeze
+      include ProductCondition
 
-      has_many :condition_products,
-        dependent: :destroy,
-        foreign_key: :condition_id,
-        class_name: "SolidusPromotions::ConditionProduct",
-        inverse_of: :condition
-      has_many :products,
-        class_name: "Spree::Product",
-        through: :condition_products
+      MATCH_POLICIES = %w[include exclude].freeze
 
       preference :match_policy, :string, default: MATCH_POLICIES.first
 
-      def preload_relations
-        [:products]
-      end
-
-      def eligible?(line_item, _options = {})
+      def line_item_eligible?(line_item, _options = {})
         order_includes_product = product_ids.include?(line_item.variant.product_id)
         success = inverse? ? !order_includes_product : order_includes_product
 
@@ -39,14 +29,6 @@ module SolidusPromotions
         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?

data/app/models/solidus_promotions/conditions/line_item_taxon.rb

@@ -3,60 +3,29 @@
 module SolidusPromotions
   module Conditions
     class LineItemTaxon < Condition
+      # TODO: Remove in Solidus 5
       include LineItemLevelCondition
 
-      has_many :condition_taxons,
-        class_name: "SolidusPromotions::ConditionTaxon",
-        foreign_key: :condition_id,
-        dependent: :destroy,
-        inverse_of: :condition
-      has_many :taxons, through: :condition_taxons, class_name: "Spree::Taxon"
+      include TaxonCondition
 
       MATCH_POLICIES = %w[include exclude].freeze
 
-      validates :preferred_match_policy, inclusion: { in: MATCH_POLICIES }
+      validates :preferred_match_policy, inclusion: {in: MATCH_POLICIES}
 
       preference :match_policy, :string, default: MATCH_POLICIES.first
 
-      def preload_relations
-        [:taxons]
-      end
-
-      def eligible?(line_item, _options = {})
-        found = Spree::Classification.where(
-          product_id: line_item.variant.product_id,
-          taxon_id: condition_taxon_ids_with_children
-        ).exists?
+      def line_item_eligible?(line_item, _options = {})
+        line_item_taxon_ids = line_item.variant.product.classifications.map(&:taxon_id)
 
         case preferred_match_policy
         when "include"
-          found
+          taxon_ids_with_children.any? { |taxon_and_descendant_ids| (line_item_taxon_ids & taxon_and_descendant_ids).any? }
         when "exclude"
-          !found
+          taxon_ids_with_children.none? { |taxon_and_descendant_ids| (line_item_taxon_ids & taxon_and_descendant_ids).any? }
         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 conditions and taxons conditions children
-      def condition_taxon_ids_with_children
-        taxons.flat_map { |taxon| taxon.self_and_descendants.ids }.uniq
-      end
     end
   end
 end

data/app/models/solidus_promotions/conditions/minimum_quantity.rb

@@ -10,9 +10,10 @@ module SolidusPromotions
     # it to a simple quantity check across the entire order which would be
     # better served by an item total condition.
     class MinimumQuantity < Condition
+      # TODO: Remove in Solidus 5
       include OrderLevelCondition
 
-      validates :preferred_minimum_quantity, numericality: { only_integer: true, greater_than: 0 }
+      validates :preferred_minimum_quantity, numericality: {only_integer: true, greater_than: 0}
 
       preference :minimum_quantity, :integer, default: 1
 
@@ -26,7 +27,7 @@ module SolidusPromotions
       #
       # @param order [Spree::Order] the order we want to check eligibility on
       # @return [Boolean] true if promotion is eligible, false otherwise
-      def eligible?(order)
+      def order_eligible?(order, _options = {})
         if benefit.applicable_line_items(order).sum(&:quantity) < preferred_minimum_quantity
           eligibility_errors.add(
             :base,

data/app/models/solidus_promotions/conditions/nth_order.rb

@@ -3,18 +3,19 @@
 module SolidusPromotions
   module Conditions
     class NthOrder < Condition
+      # TODO: Remove in Solidus 5
       include OrderLevelCondition
 
       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 condition
-      validates :preferred_nth_order, numericality: { only_integer: true, greater_than: 1 }
+      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 condition if you want a promotion to be applied to the first order for a user.
       # @param order [Spree::Order]
-      def eligible?(order, _options = {})
+      def order_eligible?(order, _options = {})
         return false unless order.user
 
         nth_order?(order)

data/app/models/solidus_promotions/conditions/one_use_per_user.rb

@@ -3,9 +3,10 @@
 module SolidusPromotions
   module Conditions
     class OneUsePerUser < Condition
+      # TODO: Remove in Solidus 5
       include OrderLevelCondition
 
-      def eligible?(order, _options = {})
+      def order_eligible?(order, _options = {})
         if order.user.present?
           if promotion.used_by?(order.user, [order])
             eligibility_errors.add(

data/app/models/solidus_promotions/conditions/option_value.rb

@@ -5,23 +5,18 @@ module SolidusPromotions
     class OptionValue < Condition
       include LineItemApplicableOrderLevelCondition
 
-      preference :eligible_values, :hash
+      include OptionValueCondition
 
-      def order_eligible?(order)
-        order.line_items.any? { |item| line_item_eligible?(item) }
+      def order_eligible?(order, _options = {})
+        OrderOptionValue.new(preferred_eligible_values: preferred_eligible_values).eligible?(order)
       end
 
-      def line_item_eligible?(line_item)
+      def line_item_eligible?(line_item, _options = {})
         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
+      def price_eligible?(price, _options = {})
+        PriceOptionValue.new(preferred_eligible_values: preferred_eligible_values).eligible?(price)
       end
     end
   end