spree_core 5.6.1 → 6.0.0.beta1

data/app/services/spree/commissions/calculate_line.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Spree
+  module Commissions
+    # Works out what one commission line is worth, and builds it.
+    #
+    # Two amounts, computed independently, because they are two different
+    # supplies. `amount` is the platform's fee, charged on what the seller sold.
+    # `tax_amount` is VAT on that fee — the marketplace's own taxable service to
+    # the seller, which is why it is applied *on top* rather than taken out of
+    # the item's own VAT. Keeping them apart is what lets a marketplace invoice
+    # its commission properly in the EU, and it is the reason the base defaults
+    # to the seller's **net** price: mixing the consumer's VAT into the fee base
+    # would tax the same money twice under two different regimes.
+    #
+    # The returned record is not saved — the caller persists it inside whatever
+    # transaction is placing the order.
+    #
+    # Swap through +Spree.commissions_calculate_line_service+.
+    class CalculateLine
+      prepend Spree::ServiceModule::Base
+
+      # @param rate [Spree::CommissionRate] the resolved rate
+      # @param seller [Spree::Seller] the seller being charged
+      # @param order [Spree::Order]
+      # @param line_item [Spree::LineItem, nil] the commissioned item…
+      # @param fulfillment [Spree::Fulfillment, nil] …or the commissioned delivery
+      # @param commission_tax [Spree::CommissionTax, nil] pre-resolved tax
+      #   treatment, so commissioning a whole order resolves it once
+      # @return [Spree::CommissionLine] unsaved
+      def call(rate:, seller:, order:, line_item: nil, fulfillment: nil, commission_tax: nil)
+        # Exactly one, checked here rather than left to the record's own
+        # validation: passing both would otherwise quietly commission the item
+        # and drop the delivery, and only fail on save.
+        subjects = [line_item, fulfillment].compact
+        unless subjects.one?
+          return failure(nil, 'a commission line needs exactly one of a line item or a fulfillment')
+        end
+
+        subject = subjects.first
+        currency = order.currency
+        precision = Spree::Money::Rounding.precision(currency)
+        tax = commission_tax || resolve_tax(rate: rate, seller: seller, order: order)
+
+        amount = Spree::Money::Rounding.quantize(charge_for(rate, subject, currency), precision)
+        tax_amount = Spree::Money::Rounding.quantize(amount * tax.rate, precision)
+
+        success(
+          Spree::CommissionLine.new(
+            order: order,
+            seller: seller,
+            line_item: line_item,
+            fulfillment: fulfillment,
+            commission_rate: rate,
+            kind: rate.kind,
+            rate: rate.value,
+            amount: amount,
+            tax_amount: tax_amount,
+            # Summed from the two rounded parts rather than rounded again, so a
+            # marketplace's ledger reconciles with its payouts to the cent.
+            total: amount + tax_amount,
+            currency: currency,
+            **tax.to_line_attributes
+          )
+        )
+      end
+
+      # The seller's own revenue on this row, net of VAT unless the rate opts
+      # into a gross base. Discounts come off either way — `taxable_basis` is
+      # already the discounted, never-negative figure both line items and
+      # fulfillments agree on — because commission is charged on what the
+      # customer actually paid, and a promotion is the seller's concession in v1.
+      #
+      # Which VAT column matters depends on how the store prices: a
+      # tax-inclusive price carries VAT inside it, which a net base removes,
+      # while a tax-exclusive one carries none, so only a gross base adds any.
+      #
+      # A class method because a value band has to weigh the sale exactly as
+      # the fee will (Spree::Commissions::Context#commission_basis) — if the
+      # two ever computed it differently, a band would admit sales the fee then
+      # charged as though they were worth something else.
+      #
+      # @param rate [Spree::CommissionRate, nil]
+      # @param subject [Spree::LineItem, Spree::Fulfillment]
+      # @return [BigDecimal]
+      def self.base_for(rate, subject)
+        basis = subject.taxable_basis
+
+        base = if rate&.tax_inclusive?
+                 basis + subject.additional_tax_total.to_d
+               else
+                 basis - subject.included_tax_total.to_d
+               end
+
+        [base, BigDecimal(0)].max
+      end
+
+      private
+
+      # Both kinds scale with quantity: a percentage through the base, which is
+      # already the line's total, and a flat fee by multiplying.
+      def charge_for(rate, subject, currency)
+        # A flat fee is charged per unit sold, in the sale's own currency — the
+        # rate only got this far because it states an amount there. Charging it
+        # once per line would let the shopper decide the fee: three cameras
+        # bought together would earn a third of three bought separately.
+        #
+        # A fulfillment has no quantity, and never reaches this branch — a flat
+        # rate is barred from charging delivery.
+        return clamp(rate, rate.amount_for(currency).to_d * subject.quantity, currency) if rate.fixed?
+
+        clamp(rate, self.class.base_for(rate, subject) * rate.value / 100, currency)
+      end
+
+      # The floor and cap are amounts, so each holds only in the currency it was
+      # written in. A sale in a currency the rate set no bounds for is charged
+      # unbounded rather than against a converted figure nobody agreed to.
+      def clamp(rate, amount, currency)
+        minimum = rate.min_amount_for(currency)
+        maximum = rate.max_amount_for(currency)
+
+        amount = [amount, minimum].max if minimum.present?
+        amount = [amount, maximum].min if maximum.present?
+        amount
+      end
+
+      def resolve_tax(rate:, seller:, order:)
+        Spree.commissions_resolve_tax_rate_service.call(rate: rate, seller: seller, order: order).value
+      end
+    end
+  end
+end

data/app/services/spree/commissions/commission_order.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Spree
+  module Commissions
+    # Writes an order's commission lines: one per sold item, plus one per
+    # fulfillment when the rate charges delivery too.
+    #
+    # Runs once, at placement, and is idempotent — an order that already
+    # carries commission is left exactly as it is. Both matter because the
+    # lines are a settlement record: recomputing them later would let a rate
+    # edit rewrite what a seller was already told they owed, and a replayed
+    # placement would charge them twice.
+    #
+    # Lines are grouped by the seller each item was bought from, which is
+    # `line_item.seller_id` — the snapshot frozen when the order was placed,
+    # not whoever owns the product today. Items with no seller are the
+    # marketplace's own and are not commissioned.
+    #
+    # It runs inside the customer's checkout, so everything it reads is loaded
+    # up front: the sellers, their billing addresses (the tax question is asked
+    # against those), the products behind each line, and the order's
+    # fulfillments — each once for the whole order rather than once per line.
+    #
+    # Swap through +Spree.commissions_commission_order_service+.
+    class CommissionOrder
+      prepend Spree::ServiceModule::Base
+
+      # @param order [Spree::Order]
+      # @return [Array<Spree::CommissionLine>] the lines written, empty when
+      #   there was nothing to commission
+      def call(order:)
+        if order.commission_lines.exists?
+          # Refreshed rather than assumed: a replayed placement can arrive
+          # between the winner writing its rows and stamping the columns, and
+          # returning here without re-summing would leave the order reporting
+          # no commission on a sale that was charged for.
+          refresh_commission_totals(order)
+          return success([])
+        end
+
+        commissioned = order.line_items.
+                       includes(seller: :billing_address, variant: { product: :categories }).
+                       select(&:seller_id)
+        return success([]) if commissioned.empty?
+
+        rates = Spree::Commissions::ResolveRate.candidates_for(order.store)
+        categories = Spree::Commissions::ResolveRate.categories_for(
+          commissioned.map { |line_item| line_item.variant&.product }
+        )
+        deliveries = deliveries_by_seller(order)
+        lines = []
+
+        Spree::CommissionLine.transaction do
+          commissioned.group_by(&:seller_id).each_value do |line_items|
+            lines.concat(
+              commission_seller(
+                order: order, seller: line_items.first.seller, line_items: line_items,
+                rates: rates, categories: categories, deliveries: deliveries
+              )
+            )
+          end
+        end
+
+        refresh_commission_totals(order)
+
+        success(lines)
+      rescue ActiveRecord::RecordNotUnique
+        # Another delivery of the same event got there first. The unique index
+        # on line item and fulfillment is what makes that safe: the winner's
+        # rows are the record, and the loser reports them rather than failing a
+        # checkout over work already done.
+        refresh_commission_totals(order)
+
+        success(order.commission_lines.reload.to_a)
+      end
+
+      private
+
+      # Denormalizes what the marketplace just earned onto the order.
+      #
+      # Written here rather than left to the totals workflow because commission
+      # is charged after the last recalculation has already run — placement
+      # publishes the event this service answers. The columns are sums only;
+      # they stay out of the order's grand total, which the shopper pays.
+      #
+      # Fee and its tax are kept apart because the tax is separately
+      # reportable: the platform files it as output tax on a B2B supply and
+      # the seller reclaims it as input tax.
+      #
+      # The gross is added up from the two parts rather than summed from the
+      # rows' own `total`, so the three columns always agree. They need not
+      # otherwise: a line rounds to its currency's precision (three places for
+      # KWD and its neighbours) while every column is scale 2, and the parts
+      # and the gross each round independently on the way in.
+      #
+      # Skips the write when nothing moved, so a replayed placement does not
+      # bump `updated_at` and invalidate every cache keyed on this order.
+      def refresh_commission_totals(order)
+        lines = order.commission_lines.reload.to_a
+        amount = lines.sum(&:amount)
+        tax = lines.sum(&:tax_amount)
+
+        totals = { commission_amount_total: amount, commission_tax_total: tax,
+                   commission_total: amount + tax }
+        return if totals.all? { |column, value| order.public_send(column) == value }
+
+        order.update_columns(totals.merge(updated_at: Time.current))
+      end
+
+      def commission_seller(order:, seller:, line_items:, rates:, categories:, deliveries:)
+        matched = line_items.filter_map do |line_item|
+          rate = resolve(line_item: line_item, seller: seller, order: order, rates: rates, categories: categories)
+          [line_item, rate] if rate
+        end
+        return [] if matched.empty?
+
+        # Memoized per rate rather than per line. Where the seller's business
+        # sits is the same question every time — so a basket governed by one
+        # rate asks the tax service once — but a rate may carry its own
+        # override, so two rates are still two answers.
+        taxes = Hash.new do |cache, rate|
+          cache[rate] = resolve_tax(rate: rate, seller: seller, order: order)
+        end
+
+        lines = matched.map do |line_item, rate|
+          write(rate: rate, seller: seller, order: order, line_item: line_item, tax: taxes[rate])
+        end
+
+        # A fulfillment carries goods, not a rate, so the one that governs
+        # delivery is whichever of the seller's matched rates asked for it.
+        shipping_rate = matched.map(&:last).find(&:include_shipping?)
+        return lines if shipping_rate.nil?
+
+        deliveries.fetch(seller.id, []).each do |fulfillment|
+          next if fulfillment.taxable_basis.zero?
+
+          lines << write(rate: shipping_rate, seller: seller, order: order,
+                         fulfillment: fulfillment, tax: taxes[shipping_rate])
+        end
+
+        lines
+      end
+
+      # The order's fulfillments, keyed by the seller whose goods they carry.
+      #
+      # Read off each fulfillment's own line items rather than assumed from the
+      # order, because until the split lands an order still holds every
+      # seller's goods — and a delivery carrying two sellers' items belongs to
+      # neither of them alone. Charging both would bill one parcel twice, and
+      # picking one would bill the wrong seller, so a shared delivery is
+      # dropped here and stays uncommissioned until splitting gives each seller
+      # their own. Once it does, every fulfillment is single-seller by
+      # construction and this becomes the plain "the seller's deliveries".
+      #
+      # @return [Hash{Integer=>Array<Spree::Fulfillment>}]
+      def deliveries_by_seller(order)
+        order.fulfillments.includes(fulfillment_items: :line_item).group_by do |fulfillment|
+          sellers = fulfillment.fulfillment_items.map { |item| item.line_item&.seller_id }.uniq
+
+          sellers.one? ? sellers.first : nil
+        end.except(nil)
+      end
+
+      def resolve(line_item:, seller:, order:, rates:, categories:)
+        Spree.commissions_resolve_rate_service.call(
+          line_item: line_item, seller: seller, store: order.store, currency: order.currency,
+          rates: rates, categories: categories
+        ).value
+      end
+
+      def resolve_tax(rate:, seller:, order:)
+        Spree.commissions_resolve_tax_rate_service.call(rate: rate, seller: seller, order: order).value
+      end
+
+      def write(rate:, seller:, order:, tax:, line_item: nil, fulfillment: nil)
+        line = Spree.commissions_calculate_line_service.call(
+          rate: rate, seller: seller, order: order,
+          line_item: line_item, fulfillment: fulfillment, commission_tax: tax
+        ).value
+        line.save!
+        line
+      end
+    end
+  end
+end

data/app/services/spree/commissions/resolve_rate.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Spree
+  module Commissions
+    # Picks the commission rate that governs one line item.
+    #
+    # Walks the store's enabled rates in list order and takes the first whose
+    # targeting admits the sale. Precedence is therefore the order an operator
+    # sees in the table, not a hardcoded product-beats-category-beats-seller
+    # ladder: seeded rates arrive in the conventional order, so a marketplace
+    # that never touches it still gets the expected answer, and one that wants
+    # a different answer drags a row.
+    #
+    # Returns nil when nothing matches, which is a real answer — a marketplace
+    # with no rate for a sale charges no commission, rather than falling back
+    # to some default the operator never configured.
+    #
+    # Swap through +Spree.commissions_resolve_rate_service+.
+    class ResolveRate
+      prepend Spree::ServiceModule::Base
+
+      # @param line_item [Spree::LineItem] the sale being commissioned
+      # @param seller [Spree::Seller] its seller
+      # @param store [Spree::Store]
+      # @param currency [String] the order's currency
+      # @param rates [Array<Spree::CommissionRate>, nil] pre-loaded candidates,
+      #   so commissioning a whole order reads the table once instead of once
+      #   per line
+      # @param categories [Hash{Integer=>Array<Spree::Category>}, nil] each
+      #   product's categories with their ancestors, resolved once for the
+      #   order — see .categories_for
+      # @return [Spree::CommissionRate, nil]
+      def call(line_item:, seller:, store:, currency: nil, rates: nil, categories: nil)
+        currency ||= line_item.currency
+        candidates = rates || self.class.candidates_for(store)
+        context = Spree::Commissions::Context.new(
+          seller: seller,
+          order: line_item.order,
+          line_item: line_item,
+          currency: currency,
+          categories: categories && line_item.variant&.product ?
+            categories.fetch(line_item.variant.product.id, []) : nil
+        )
+
+        success(
+          candidates.find do |rate|
+            rate.applies_to_currency?(currency) && rate.matches?(context)
+          end
+        )
+      end
+
+      # The store's rates in resolution order, with rules preloaded — matching
+      # reads every rule of every candidate, so without this each rate costs a
+      # query per line item.
+      #
+      # @param store [Spree::Store]
+      # @return [Array<Spree::CommissionRate>]
+      def self.candidates_for(store)
+        store.commission_rates.enabled.ordered.includes(:commission_rules).to_a
+      end
+
+      # Each product's categories together with their ancestors, keyed by
+      # product id.
+      #
+      # Resolved for a whole set of products at once because walking a nested
+      # set is a query per category, and this runs inside checkout: asking per
+      # line item would cost a query for every category of every item in the
+      # basket, most of them the same ones over and over.
+      #
+      # @param products [Array<Spree::Product>]
+      # @return [Hash{Integer=>Array<Spree::Category>}]
+      def self.categories_for(products)
+        products = products.compact.uniq
+        return {} if products.empty?
+
+        by_product = products.to_h { |product| [product.id, product.categories.to_a] }
+        ancestors = ancestors_of(by_product.values.flatten.uniq)
+
+        by_product.transform_values do |categories|
+          categories.flat_map { |category| ancestors.fetch(category.id, [category]) }.uniq
+        end
+      end
+
+      # Every category above each of the given ones, in one query per store
+      # rather than one per category. Nested sets make an ancestor a plain
+      # range comparison, so the whole set can be asked for at once.
+      #
+      # @param categories [Array<Spree::Category>]
+      # @return [Hash{Integer=>Array<Spree::Category>}]
+      def self.ancestors_of(categories)
+        return {} if categories.empty?
+
+        table = Spree::Category.arel_table
+        # Kept per store rather than flattened into one pool: bounds are only
+        # meaningful within the tree that assigned them, so a category from
+        # another store can enclose these ones by coincidence — and a rate
+        # targeting it would then match a sale it has nothing to do with.
+        pool_by_store = categories.group_by(&:store_id).transform_values do |group|
+          reaching = group.map { |c| table[:lft].lteq(c.lft).and(table[:rgt].gteq(c.rgt)) }.reduce(:or)
+          Spree::Category.where(store_id: group.first.store_id).where(reaching).to_a
+        end
+
+        categories.to_h do |category|
+          ancestors = pool_by_store.fetch(category.store_id, []).select do |node|
+            node.lft <= category.lft && node.rgt >= category.rgt
+          end
+
+          [category.id, ancestors]
+        end
+      end
+
+    end
+  end
+end

data/app/services/spree/commissions/resolve_tax_rate.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Spree
+  module Commissions
+    # How a commission is taxed — the rate, and the treatment behind it.
+    #
+    # This is tax on the marketplace's own service to the seller, not on the
+    # goods the customer bought — a separate supply with its own place of
+    # taxation, which is why it is asked against the **seller's billing
+    # address** rather than wherever the parcel went.
+    #
+    # Precedence: an explicit override on the rate, else the sale's tax engine,
+    # else the store's default. A provider with no opinion returns nil rather
+    # than zero, so silence falls through to the default instead of being read
+    # as "this fee is untaxed".
+    #
+    # The treatment is only as good as its source: an operator override or a
+    # store default is a number someone typed, so it is recorded as standard
+    # rated without inventing a jurisdiction for it. Only the tax engine knows
+    # where it taxed the fee.
+    #
+    # Swap through +Spree.commissions_resolve_tax_rate_service+.
+    class ResolveTaxRate
+      prepend Spree::ServiceModule::Base
+
+      # @param rate [Spree::CommissionRate]
+      # @param seller [Spree::Seller] the seller being invoiced
+      # @param order [Spree::Order]
+      # @return [Spree::CommissionTax]
+      def call(rate:, seller:, order:)
+        return success(configured(rate.commission_tax_rate)) if rate.commission_tax_rate.present?
+
+        from_provider = provider_tax(seller: seller, order: order)
+        return success(from_provider) if from_provider
+
+        success(configured(order.store.preferred_default_commission_tax_rate))
+      end
+
+      private
+
+      # A rate somebody configured. Standard rated by definition — nobody
+      # types a number to mean "exempt" — and carrying no jurisdiction, because
+      # a store preference does not know one.
+      def configured(value)
+        amount = value.to_d
+
+        Spree::CommissionTax.new(
+          rate: amount,
+          taxability_reason: amount.zero? ? nil : 'standard_rated'
+        )
+      end
+
+      # Commission is written while an order is being placed, so a tax service
+      # being unreachable must never cost the marketplace a checkout: the error
+      # is reported and the configured default applies.
+      def provider_tax(seller:, order:)
+        address = seller.billing_address
+        amount = order.tax_provider.service_tax_rate(address: address, store: order.store)
+        return nil if amount.blank?
+
+        Spree::CommissionTax.new(
+          rate: amount.to_d,
+          taxability_reason: amount.to_d.zero? ? 'zero_rated' : 'standard_rated',
+          country_code: address&.country_code,
+          state_code: address&.state_code
+        )
+      rescue StandardError => error
+        Rails.error.report(
+          error,
+          handled: true,
+          context: { seller_id: seller.id, order_id: order.id },
+          source: 'spree.core'
+        )
+        nil
+      end
+    end
+  end
+end

data/app/services/spree/companies/add_member.rb

@@ -0,0 +1,38 @@
+module Spree
+  module Companies
+    # Adds a person to a company node by email — the single convergent path
+    # behind both the dashboard's and the storefront's "add member".
+    #
+    # An email that matches an existing customer becomes a membership
+    # immediately; an unknown email becomes a {Spree::CompanyInvitation},
+    # whose creation event sends the invite mail. Extension payloads (e.g. an
+    # Enterprise role reference) ride +metadata+ on either record.
+    class AddMember
+      prepend Spree::ServiceModule::Base
+
+      # @param company [Spree::Company]
+      # @param email [String]
+      # @param inviter [Object, nil] the inviting customer, nil when staff
+      # @param metadata [Hash, nil] extension payload — carried on the
+      #   invitation only, where Enterprise reads it back on acceptance
+      #   (memberships have no metadata column; a direct-membership payload is
+      #   applied by the caller through the `company_membership.form_fields`
+      #   contract, not stored here)
+      # @return [Spree::ServiceModule::Result] value is the created
+      #   Spree::CompanyMembership or Spree::CompanyInvitation
+      def call(company:, email:, inviter: nil, metadata: nil)
+        normalized_email = email.to_s.strip.downcase
+        customer = Spree.customer_class.find_by(email: normalized_email)
+
+        record =
+          if customer
+            company.memberships.new(customer: customer)
+          else
+            company.invitations.new(email: normalized_email, inviter: inviter, metadata: metadata)
+          end
+
+        record.save ? success(record) : failure(record)
+      end
+    end
+  end
+end

data/app/services/spree/company_invitations/accept.rb

@@ -0,0 +1,60 @@
+module Spree
+  module CompanyInvitations
+    # Turns a pending invitation into a membership. Two ways in, converging
+    # here: a registration payload — run through the single customer-creation
+    # workflow — or an already-authenticated customer whose account the
+    # invitation binds to. Either way the membership is created, the
+    # acceptance stamped and the token spent.
+    class Accept
+      prepend Spree::ServiceModule::Base
+
+      # @param invitation [Spree::CompanyInvitation]
+      # @param customer [Object, nil] an authenticated customer accepting
+      # @param customer_attributes [Hash, nil] registration payload for a new
+      #   customer; the account is created with the invited email
+      # @return [Spree::ServiceModule::Result] value is the created
+      #   Spree::CompanyMembership
+      def call(invitation:, customer: nil, customer_attributes: nil)
+        return failure(invitation, :invitation_not_pending) unless invitation.pending?
+        # The token names one person. Without this, anyone holding it could
+        # spend it from an unrelated signed-in account and take standing over
+        # the company — which authorizes buying, reading the subtree's orders
+        # and revoking the other members' invitations.
+        return failure(invitation, :invitation_email_mismatch) unless invited_email?(invitation, customer)
+
+        if customer.nil?
+          result = Spree.customer_create_workflow.call(
+            store: invitation.store,
+            **(customer_attributes || {}).to_h.symbolize_keys.merge(email: invitation.email)
+          )
+          return failure(result.value, result.error) if result.failure?
+
+          customer = result.value
+        end
+
+        membership = nil
+        ApplicationRecord.transaction do
+          membership = invitation.company.memberships.where(customer: customer).first_or_create!
+          invitation.update!(accepted_at: Time.current, customer: customer)
+        end
+
+        invitation.publish_event('company_invitation.accepted')
+
+        success(membership)
+      rescue ActiveRecord::RecordInvalid => e
+        failure(e.record)
+      end
+
+      private
+
+      # Compared the way the invitation stores it — normalized, since a
+      # customer signed up as "Buyer@Example.com" is the same person the
+      # invitation went to.
+      def invited_email?(invitation, customer)
+        return true if customer.nil?
+
+        customer.email.to_s.strip.downcase == invitation.email
+      end
+    end
+  end
+end

data/app/services/spree/coupon_codes/coupon_codes_handler.rb

@@ -18,9 +18,21 @@ module Spree
 
       private
 
+      # Which promotions this checkout actually used.
+      #
+      # Read across the whole group when the order is one of several placed
+      # together: the codes all sit on the first child, while the discount a
+      # code bought may have landed on any of them. Asking only this order
+      # would find no discount for a code that discounted a sibling, and
+      # release a single-use code back for somebody to spend again.
       def find_current_promotions_ids
-        order.all_adjustments.promotion.eligible.joins("INNER JOIN #{Spree::PromotionAction.table_name} ON #{Spree::PromotionAction.table_name}.id = #{Spree::Adjustment.table_name}.source_id").
-          pluck("#{Spree::PromotionAction.table_name}.promotion_id").compact.uniq
+        scope = if order.respond_to?(:grouped?) && order.grouped?
+                  Spree::Discount.where(order_id: order.order_group.orders.select(:id))
+                else
+                  order.discounts
+                end
+
+        scope.promotion.where.not(promotion_id: nil).distinct.pluck(:promotion_id)
       end
 
       def use_all_current(promotion_ids)