solidus_core 4.5.1 → 4.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 995355f29d96abe41d7beb6b28cbe8bd8198d8c4ebee544dedc223f15b856548
-  data.tar.gz: 07b683686244717fc86fe1a83777e29845365dbed70c2117d1aacddf8c729717
+  metadata.gz: f616e30c09a8f81468fd2f3d646b4ba5624ad26af29aae44985622adf3db57b8
+  data.tar.gz: 982dc95e2dc4518445e5dd6d133354cd283663028902c55ad4850af1e18ea4cd
 SHA512:
-  metadata.gz: '0963f51448492bca5190edb6641ea96206670f8ce17bea75e67c429838b5b98c041a936d64f57b994ca731df036995ef402eb24e723840a3b00efb109bf4e5c0'
-  data.tar.gz: 0fc6248571ff6027d618e4840d9c154bba8674fdbfd96805a58fbbc051b7c36d9c31d6e1d20b042bce38b8c5fc2b48d8b3201acb2ec264be2466c29704612c02
+  metadata.gz: 9a4cd294113878e692b12af0214b7200522d4ce583a2d515e7d848c342fe787d64dd78c9b9a9b6de02fdf7b2c47a5bab7e3a5054cb0d76935851c7935d3b79d3
+  data.tar.gz: aa69ad3e6b7616a701675aca113da85e7b9472f6f95ffe2bc42ea1fa1115ceffdcb1c710482e8d4a509616d1a6c5c0036a157dd92405f6937eea261fbdc38c77

data/README.md

@@ -1,6 +1,6 @@
 Summary
 ------
-Solidus Core provides the essential ecommerce data models upon which the
+Solidus Core provides the essential e-commerce data models upon which the
 Solidus system depends.
 
 Core models

data/app/jobs/spree/base_job.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Spree
+  # Base class for all Solidus background jobs
+  class BaseJob < ActiveJob::Base # rubocop:disable Rails/ApplicationJob
+    # Automatically retry jobs that encountered a deadlock
+    retry_on ActiveRecord::Deadlocked
+
+    # Most jobs are safe to ignore if the underlying records are no longer available
+    discard_on ActiveJob::DeserializationError
+  end
+end

data/app/jobs/spree/state_change_tracking_job.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Spree
+  # Background job to track state changes asynchronously
+  # This avoids performance impact during checkout and prevents
+  # callback-related issues with recent versions of the state_machines gem.
+  class StateChangeTrackingJob < BaseJob
+    # @param stateful [GlobalId] The stateful object to track changes for
+    # @param previous_state [String] The previous state of the order
+    # @param current_state [String] The current state of the order
+    # @param transition_timestamp [Time] When the state transition occurred
+    # @param name [String] The element name of the state transition being
+    #   tracked. It defaults to the `stateful` model element name.
+    def perform(
+      stateful,
+      previous_state,
+      current_state,
+      transition_timestamp,
+      name = stateful.class.model_name.element
+    )
+      Spree::StateChange.create!(
+        name: name,
+        stateful: stateful,
+        previous_state: previous_state,
+        next_state: current_state,
+        created_at: transition_timestamp,
+        updated_at: transition_timestamp,
+        user_id: stateful.try(:user_id) || stateful.try(:order)&.user_id
+      )
+    end
+  end
+end

data/app/models/concerns/spree/state_change_tracking.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Spree
+  module StateChangeTracking
+    extend ActiveSupport::Concern
+
+    included do
+      after_update :enqueue_state_change_tracking, if: :saved_change_to_state?
+    end
+
+    private
+
+    # Enqueue background job to track state changes asynchronously
+    def enqueue_state_change_tracking
+      previous_state, current_state = saved_changes['state']
+
+      # Enqueue the job to track this state change
+      StateChangeTrackingJob.perform_later(
+        self,
+        previous_state,
+        current_state,
+        Time.current
+      )
+    end
+  end
+end

data/app/models/concerns/spree/user_address_book.rb

@@ -5,7 +5,7 @@ module Spree
     extend ActiveSupport::Concern
 
     included do
-      has_many :user_addresses, foreign_key: "user_id", class_name: "Spree::UserAddress" do
+      has_many :user_addresses, foreign_key: "user_id", class_name: "Spree::UserAddress", inverse_of: :user, dependent: :destroy do
         def find_first_by_address_values(address_attrs)
           detect { |ua| ua.address == Spree::Address.new(address_attrs) }
         end
@@ -32,11 +32,29 @@ module Spree
 
       has_many :addresses, through: :user_addresses
 
-      has_one :default_user_bill_address, ->{ default_billing }, class_name: 'Spree::UserAddress', foreign_key: 'user_id'
-      has_one :bill_address, through: :default_user_bill_address, source: :address
-
-      has_one :default_user_ship_address, ->{ default_shipping }, class_name: 'Spree::UserAddress', foreign_key: 'user_id'
-      has_one :ship_address, through: :default_user_ship_address, source: :address
+      has_one :default_user_bill_address,
+        ->{ default_billing },
+        class_name: 'Spree::UserAddress',
+        foreign_key: 'user_id',
+        inverse_of: false,
+        dependent: false
+      has_one :bill_address,
+        through: :default_user_bill_address,
+        source: :address,
+        inverse_of: false,
+        dependent: false
+
+      has_one :default_user_ship_address,
+        ->{ default_shipping },
+        class_name: 'Spree::UserAddress',
+        foreign_key: 'user_id',
+        inverse_of: false,
+        dependent: false
+      has_one :ship_address,
+        through: :default_user_ship_address,
+        source: :address,
+        inverse_of: false,
+        dependent: false
 
       accepts_nested_attributes_for :ship_address
       accepts_nested_attributes_for :bill_address

data/app/models/concerns/spree/user_methods.rb

@@ -11,20 +11,58 @@ module Spree
     included do
       extend Spree::DisplayMoney
 
-      has_many :role_users, foreign_key: "user_id", class_name: "Spree::RoleUser", dependent: :destroy
-      has_many :spree_roles, through: :role_users, source: :role, class_name: "Spree::Role"
-
-      has_many :user_stock_locations, foreign_key: "user_id", class_name: "Spree::UserStockLocation"
-      has_many :stock_locations, through: :user_stock_locations
-
-      has_many :spree_orders, foreign_key: "user_id", class_name: "Spree::Order"
-      has_many :orders, foreign_key: "user_id", class_name: "Spree::Order"
-
-      has_many :store_credits, -> { includes(:credit_type) }, foreign_key: "user_id", class_name: "Spree::StoreCredit"
-      has_many :store_credit_events, through: :store_credits
-
-      has_many :credit_cards, class_name: "Spree::CreditCard", foreign_key: :user_id
-      has_many :wallet_payment_sources, foreign_key: 'user_id', class_name: 'Spree::WalletPaymentSource', inverse_of: :user
+      has_many :role_users,
+        foreign_key: "user_id",
+        class_name: "Spree::RoleUser",
+        dependent: :destroy,
+        inverse_of: :user
+      has_many :spree_roles,
+        through: :role_users,
+        source: :role,
+        class_name: "Spree::Role",
+        inverse_of: :users
+
+      has_many :user_stock_locations,
+        foreign_key: "user_id",
+        class_name: "Spree::UserStockLocation",
+        inverse_of: :user,
+        dependent: :destroy
+      has_many :stock_locations,
+        through: :user_stock_locations,
+        inverse_of: :users
+
+      has_many :spree_orders,
+        foreign_key: "user_id",
+        class_name: "Spree::Order",
+        inverse_of: :user,
+        dependent: false
+      has_many :orders,
+        foreign_key: "user_id",
+        class_name: "Spree::Order",
+        inverse_of: :user,
+        dependent: false
+
+      has_many :store_credits,
+        -> { includes(:credit_type) },
+        foreign_key: "user_id",
+        class_name: "Spree::StoreCredit",
+        dependent: :nullify,
+        inverse_of: :user
+      has_many :store_credit_events,
+        through: :store_credits,
+        inverse_of: false
+
+      has_many :credit_cards,
+        class_name: "Spree::CreditCard",
+        foreign_key: :user_id,
+        dependent: :nullify,
+        inverse_of: :user
+
+      has_many :wallet_payment_sources,
+        foreign_key: 'user_id',
+        class_name: 'Spree::WalletPaymentSource',
+        inverse_of: :user,
+        dependent: :destroy
 
       after_create :auto_generate_spree_api_key
       before_destroy :check_for_deletion

data/app/models/concerns/spree/user_reporting.rb

@@ -17,7 +17,7 @@ module Spree
       if order_count.to_i > 0
         lifetime_value / order_count
       else
-        BigDecimal("0.00")
+        Spree::ZERO
       end
     end
   end

data/app/models/spree/address.rb

@@ -11,10 +11,10 @@ module Spree
     mattr_accessor :state_validator_class
     self.state_validator_class = Spree::Address::StateValidator
 
-    belongs_to :country, class_name: "Spree::Country", optional: true
+    belongs_to :country, class_name: "Spree::Country"
     belongs_to :state, class_name: "Spree::State", optional: true
 
-    validates :address1, :city, :country_id, :name, presence: true
+    validates :address1, :city, :name, presence: true
     validates :zipcode, presence: true, if: :require_zipcode?
     validates :phone, presence: true, if: :require_phone?
 
@@ -28,6 +28,12 @@ module Spree
 
     self.allowed_ransackable_attributes = %w[name]
 
+    enum :reverse_charge_status, {
+      disabled: 0,
+      enabled: 1,
+      not_validated: 2
+    }, prefix: true
+
     unless ActiveRecord::Relation.method_defined? :with_values # Rails 7.1+
       scope :with_values, ->(attributes) do
         where(value_attributes(attributes))

data/app/models/spree/adjustment_reason.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class AdjustmentReason < Spree::Base
-    has_many :adjustments, inverse_of: :adjustment_reason
+    has_many :adjustments, inverse_of: :adjustment_reason, dependent: :restrict_with_error
 
     validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
     validates :code, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }

data/app/models/spree/calculator.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'spree/preferences/persistable'
-
 module Spree
   class Calculator < Spree::Base
     include Spree::Preferences::Persistable

data/app/models/spree/carton.rb

@@ -15,6 +15,13 @@ class Spree::Carton < Spree::Base
   validates :inventory_units, presence: true
   validates :shipped_at, presence: true
 
+  # This accessor is used by the `Spree::CartonShippedMailerSubscriber`
+  # on carton creation to either send or suppress the associated
+  # carton shipped email.
+  #
+  # @return [boolean, NilClass] Whether the email should be suppressed.
+  attr_accessor :suppress_email
+
   make_permalink field: :number, length: 11, prefix: 'C'
 
   scope :trackable, -> { where("tracking IS NOT NULL AND tracking != ''") }

data/app/models/spree/classification.rb

@@ -4,10 +4,10 @@ module Spree
   class Classification < Spree::Base
     self.table_name = 'spree_products_taxons'
     acts_as_list scope: :taxon
-    belongs_to :product, class_name: "Spree::Product", inverse_of: :classifications, touch: true, optional: true
-    belongs_to :taxon, class_name: "Spree::Taxon", inverse_of: :classifications, touch: true, optional: true
+    belongs_to :product, class_name: "Spree::Product", inverse_of: :classifications, touch: true
+    belongs_to :taxon, class_name: "Spree::Taxon", inverse_of: :classifications, touch: true
 
     # For https://github.com/spree/spree/issues/3494
-    validates_uniqueness_of :taxon_id, scope: :product_id, message: :already_linked
+    validates :taxon_id, uniqueness: { scope: :product_id, message: :already_linked }
   end
 end

data/app/models/spree/core/state_machines/order/class_methods.rb

@@ -38,22 +38,6 @@ module Spree
             state_machine :state, initial: :cart, use_transactions: false do
               klass.next_event_transitions.each { |state| transition(state.merge(on: :next)) }
 
-              # Persist the state on the order
-              after_transition do |order, transition|
-                # Hard to say if this is really necessary, it was introduced in this commit:
-                # https://github.com/mamhoff/solidus/commit/fa1d66c42e4c04ee7cd1c20d87e4cdb74a226d3d
-                # But it seems to be harmless, so we'll keep it for now.
-                order.state = order.state # rubocop:disable Lint/SelfAssignment
-
-                order.state_changes.create(
-                  previous_state: transition.from,
-                  next_state:     transition.to,
-                  name:           'order',
-                  user_id:        order.user_id
-                )
-                order.save
-              end
-
               event :cancel do
                 transition to: :canceled, if: :allow_cancel?, from: :complete
               end

data/app/models/spree/core/state_machines/order.rb

@@ -6,6 +6,7 @@ module Spree
       module Order
         def self.included(klass)
           klass.extend ClassMethods
+          klass.include StateChangeTracking
         end
 
         def checkout_steps

data/app/models/spree/core/state_machines/payment.rb

@@ -15,6 +15,7 @@ module Spree
       #
       module Payment
         extend ActiveSupport::Concern
+        include StateChangeTracking
 
         included do
           state_machine initial: :checkout do
@@ -45,14 +46,6 @@ module Spree
             event :invalidate do
               transition from: [:checkout], to: :invalid
             end
-
-            after_transition do |payment, transition|
-              payment.state_changes.create!(
-                previous_state: transition.from,
-                next_state:     transition.to,
-                name:           'payment'
-              )
-            end
           end
         end
       end

data/app/models/spree/core/state_machines/shipment.rb

@@ -15,6 +15,7 @@ module Spree
       #
       module Shipment
         extend ActiveSupport::Concern
+        include StateChangeTracking
 
         included do
           state_machine initial: :pending, use_transactions: false do
@@ -42,14 +43,6 @@ module Spree
               transition from: :canceled, to: :pending
             end
             after_transition from: :canceled, to: [:pending, :ready, :shipped], do: :after_resume
-
-            after_transition do |shipment, transition|
-              shipment.state_changes.create!(
-                previous_state: transition.from,
-                next_state:     transition.to,
-                name:           'shipment'
-              )
-            end
           end
         end
       end

data/app/models/spree/country.rb

@@ -2,11 +2,22 @@
 
 module Spree
   class Country < Spree::Base
-    has_many :states, -> { order(:name) }, dependent: :destroy
-    has_many :addresses, dependent: :nullify
-    has_many :prices, class_name: "Spree::Price", foreign_key: "country_iso", primary_key: "iso"
-
-    validates :name, :iso_name, presence: true
+    has_many :states,
+      -> { order(:name) },
+      dependent: :destroy,
+      inverse_of: :country
+    has_many :addresses,
+      dependent: :restrict_with_error,
+      inverse_of: :country
+    has_many :prices,
+      class_name: "Spree::Price",
+      foreign_key: "country_iso",
+      primary_key: "iso",
+      dependent: :restrict_with_error,
+      inverse_of: :country
+
+    validates :name, :iso_name, :iso, presence: true
+    validates :iso, uniqueness: true
 
     self.allowed_ransackable_attributes = %w[name]
 

data/app/models/spree/customer_return.rb

@@ -4,7 +4,7 @@ module Spree
   class CustomerReturn < Spree::Base
     include Metadata
 
-    belongs_to :stock_location, optional: true
+    belongs_to :stock_location
 
     has_many :return_items, inverse_of: :customer_return
     has_many :return_authorizations, through: :return_items
@@ -14,7 +14,6 @@ module Spree
     before_create :generate_number
 
     validates :return_items, presence: true
-    validates :stock_location, presence: true
     validate :return_items_belong_to_same_order
 
     accepts_nested_attributes_for :return_items

data/app/models/spree/fulfilment_changer.rb

@@ -86,15 +86,21 @@ module Spree
     # we can take from the desired location, we could end up with some items being backordered.
     def run_tracking_inventory
       # Retrieve how many on hand items we can take from desired stock location
-      available_quantity = [desired_shipment.stock_location.count_on_hand(variant), default_on_hand_quantity].max
-
+      available_quantity = get_available_quantity
       new_on_hand_quantity = [available_quantity, quantity].min
-      unstock_quantity = desired_shipment.stock_location.backorderable?(variant) ? quantity : new_on_hand_quantity
+      backordered_quantity = get_backordered_quantity(available_quantity, new_on_hand_quantity)
+
+      # Determine how many backordered and on_hand items we'll need to move. We
+      # don't want to move more than what's being asked. And we can't move a
+      # negative amount, which is why we need to perform our min/max logic here.
+      backordered_quantity_to_move = [backordered_quantity, quantity].min
+      on_hand_quantity_to_move = [quantity - backordered_quantity_to_move, 0].max
 
       ActiveRecord::Base.transaction do
         if handle_stock_counts?
           # We only run this query if we need it.
           current_on_hand_quantity = [current_shipment.inventory_units.pre_shipment.size, quantity].min
+          unstock_quantity = desired_shipment.stock_location.backorderable?(variant) ? quantity : new_on_hand_quantity
 
           # Restock things we will not fulfil from the current shipment anymore
           current_stock_location.restock(variant, current_on_hand_quantity, current_shipment)
@@ -105,19 +111,21 @@ module Spree
         # These two statements are the heart of this class. We change the number
         # of inventory units requested from one shipment to the other.
         # We order by state, because `'backordered' < 'on_hand'`.
+        # We start to move the new actual backordered quantity, so the remaining
+        # quantity can be set to on_hand state.
         current_shipment.
           inventory_units.
           where(variant:).
           order(state: :asc).
-          limit(new_on_hand_quantity).
-          update_all(shipment_id: desired_shipment.id, state: :on_hand)
+          limit(backordered_quantity_to_move).
+          update_all(shipment_id: desired_shipment.id, state: :backordered)
 
         current_shipment.
           inventory_units.
           where(variant:).
           order(state: :asc).
-          limit(quantity - new_on_hand_quantity).
-          update_all(shipment_id: desired_shipment.id, state: :backordered)
+          limit(on_hand_quantity_to_move).
+          update_all(shipment_id: desired_shipment.id, state: :on_hand)
       end
     end
 
@@ -141,11 +149,22 @@ module Spree
       current_shipment.order.completed? && current_stock_location != desired_stock_location
     end
 
-    def default_on_hand_quantity
+    def get_available_quantity
       if current_stock_location != desired_stock_location
-        0
+        desired_location_quantifier.positive_stock
       else
-        current_shipment.inventory_units.where(variant:).on_hand.count
+        sl_availability = current_location_quantifier.positive_stock
+        shipment_availability = current_shipment.inventory_units.where(variant: variant).on_hand.count
+        sl_availability + shipment_availability
+      end
+    end
+
+    def get_backordered_quantity(available_quantity, new_on_hand_quantity)
+      if current_stock_location != desired_stock_location
+        quantity - new_on_hand_quantity
+      else
+        shipment_quantity = current_shipment.inventory_units.where(variant: variant).size
+        shipment_quantity - available_quantity
       end
     end
 
@@ -156,11 +175,19 @@ module Spree
     end
 
     def enough_stock_at_desired_location
-      unless Spree::Stock::Quantifier.new(variant, desired_stock_location).can_supply?(quantity)
+      unless desired_location_quantifier.can_supply?(quantity)
         errors.add(:desired_shipment, :not_enough_stock_at_desired_location)
       end
     end
 
+    def desired_location_quantifier
+      @desired_location_quantifier ||= Spree::Stock::Quantifier.new(variant, desired_stock_location)
+    end
+
+    def current_location_quantifier
+      @current_location_quantifier ||= Spree::Stock::Quantifier.new(variant, current_stock_location)
+    end
+
     def desired_shipment_different_from_current
       if desired_shipment.id == current_shipment.id
         errors.add(:desired_shipment, :can_not_transfer_within_same_shipment)

data/app/models/spree/inventory_unit.rb

@@ -24,7 +24,7 @@ module Spree
       raise "The order association has been removed from InventoryUnit. The order is now determined from the shipment."
     end
 
-    validates_presence_of :shipment, :line_item, :variant
+    validates :shipment, :line_item, :variant, presence: true
 
     before_destroy :ensure_can_destroy
 

data/app/models/spree/line_item.rb

@@ -18,11 +18,11 @@ module Spree
 
     has_one :product, through: :variant
 
-    has_many :adjustments, as: :adjustable, inverse_of: :adjustable, dependent: :destroy
+    has_many :adjustments, as: :adjustable, inverse_of: :adjustable, dependent: :destroy, autosave: true
     has_many :inventory_units, inverse_of: :line_item
 
     before_validation :normalize_quantity
-    before_validation :set_required_attributes
+    after_initialize :set_required_attributes
 
     validates :variant, presence: true
     validates :quantity, numericality: {
@@ -159,6 +159,7 @@ module Spree
     # Sets tax category, price-related attributes from
     # its variant if they are nil and a variant is present.
     def set_required_attributes
+      return if persisted?
       return unless variant
       self.tax_category ||= variant.tax_category
       set_pricing_attributes

data/app/models/spree/order.rb

@@ -52,7 +52,8 @@ module Spree
       :total_available_store_credit,
       :item_total_before_tax,
       :shipment_total_before_tax,
-      :item_total_excluding_vat
+      :item_total_excluding_vat,
+      :promo_total
     )
     alias :display_ship_total :display_shipment_total
 
@@ -101,7 +102,7 @@ module Spree
     has_many :cartons, -> { distinct }, through: :inventory_units
 
     # Adjustments and promotions
-    has_many :adjustments, -> { order(:created_at) }, as: :adjustable, inverse_of: :adjustable, dependent: :destroy
+    has_many :adjustments, -> { order(:created_at) }, as: :adjustable, inverse_of: :adjustable, dependent: :destroy, autosave: true
     has_many :line_item_adjustments, through: :line_items, source: :adjustments
     has_many :shipment_adjustments, through: :shipments, source: :adjustments
     has_many :all_adjustments,
@@ -844,9 +845,10 @@ module Spree
       cancel_shipments!
       cancel_payments!
 
-      send_cancel_email
       update_column(:canceled_at, Time.current)
       recalculate
+
+      Spree::Bus.publish :order_canceled, order: self
     end
 
     def cancel_shipments!
@@ -862,10 +864,6 @@ module Spree
       end
     end
 
-    def send_cancel_email
-      Spree::Config.order_mailer_class.cancel_email(self).deliver_later
-    end
-
     def after_resume
       shipments.each(&:resume!)
     end

data/app/models/spree/order_cancellations.rb

@@ -9,9 +9,22 @@ class Spree::OrderCancellations
   #     #call(unit_cancels)
   class_attribute :short_ship_tax_notifier
 
-  # allows sending an email when inventory is cancelled
-  class_attribute :send_cancellation_mailer
-  self.send_cancellation_mailer = true
+  class << self
+    def send_cancellation_mailer=(value)
+      @send_cancellation_mailer = value
+
+      unless value
+        Spree.deprecator.warn "Using the `:send_cancellation_mailer` class " \
+          "attribute is deprecated in favor of including or omitting the " \
+          "`Spree::OrderInventoryCancellationMailerSubscriber` from " \
+          "`Spree::Config.environment.subscribers` in an initializer."
+      end
+    end
+
+    def send_cancellation_mailer
+      @send_cancellation_mailer || @send_cancellation_mailer.nil?
+    end
+  end
 
   def initialize(order)
     @order = order
@@ -38,9 +51,6 @@ class Spree::OrderCancellations
         inventory_units.each do |iu|
           unit_cancels << short_ship_unit(iu, created_by:)
         end
-
-        update_shipped_shipments(inventory_units)
-        Spree::Config.order_mailer_class.inventory_cancellation_email(@order, inventory_units.to_a).deliver_later if Spree::OrderCancellations.send_cancellation_mailer
       end
 
       @order.recalculate
@@ -50,6 +60,7 @@ class Spree::OrderCancellations
       end
     end
 
+    Spree::Bus.publish(:order_short_shipped, order: @order, inventory_units:)
     unit_cancels
   end
 
@@ -109,18 +120,4 @@ class Spree::OrderCancellations
 
     unit_cancel
   end
-
-  # if any shipments are now fully shipped then mark them as such
-  def update_shipped_shipments(inventory_units)
-    shipments = Spree::Shipment.
-      includes(:inventory_units).
-      where(id: inventory_units.map(&:shipment_id)).
-      to_a
-
-    shipments.each do |shipment|
-      if shipment.inventory_units.all? { |iu| iu.shipped? || iu.canceled? }
-        shipment.update!(state: 'shipped', shipped_at: Time.current)
-      end
-    end
-  end
 end