spree_core 5.6.1 → 6.0.0.beta1

data/app/models/spree/export.rb

@@ -6,11 +6,20 @@ module Spree
 
     SUPPORTED_FILE_FORMATS = %i[csv].freeze
 
+    # Raised when a seller-owned export names a model that cannot be narrowed
+    # to one seller. Failing loudly beats writing a file that silently spans
+    # the whole marketplace.
+    class SellerScopeUnavailable < StandardError
+      def initialize(model_class)
+        super("#{model_class} does not define `for_seller`, so a seller-scoped export of it " \
+              'would contain every seller\'s records.')
+      end
+    end
+
     include Spree::SingleStoreResource
     include Spree::NumberIdentifier
-    include Spree::VendorConcern if defined?(Spree::VendorConcern)
 
-    include Spree::Core::NumberGenerator.new(prefix: 'EF')
+    has_spree_number prefix: 'EF'
 
     publishes_lifecycle_events
 
@@ -26,12 +35,22 @@ module Spree
     # exports without a human user attached. The email notification is
     # skipped for these — apps poll instead.
     belongs_to :user, class_name: Spree.admin_user_class.to_s, optional: true
-    belongs_to :vendor, -> { with_deleted }, class_name: 'Spree::Vendor', optional: true
+    belongs_to :seller, -> { with_deleted }, class_name: 'Spree::Seller', optional: true
 
     #
     # Validations
     #
-    validates :format, :store, :type, presence: true
+    validates :format, :type, presence: true
+    # Refuse before the job runs rather than at generate. `scope` raises for a
+    # seller-owned export of a model it cannot narrow, and that raise would
+    # otherwise land inside the background job, where nothing records it — the
+    # export simply never becomes `done` and the caller waits out its poll. A
+    # validation makes it a 422 the caller reads straight away.
+    #
+    # Not `on: :create`: an export born without a seller passes, and assigning
+    # one afterwards would reach the same raise.
+    validate :seller_scope_must_be_available, if: -> { seller_id.present? }
+    validate :ensure_seller_belongs_to_store
 
     #
     # Enums
@@ -41,7 +60,19 @@ module Spree
     #
     # Ransack configuration
     #
-    self.whitelisted_ransackable_attributes = %w[number type format vendor_id]
+    self.whitelisted_ransackable_attributes = %w[number type format seller_id]
+    # Lets an operator filter their list by who ran the job — the seller's
+    # name, not an id they would have to look up first.
+    self.whitelisted_ransackable_associations = %w[seller]
+
+    #
+    # Scopes
+    #
+    # `for_store` comes from Spree::SingleStoreResource and includes a store's
+    # sellers' exports, which is what puts them in the operator's list.
+    scope :for_seller, ->(seller) { where(seller_id: seller) }
+    # The operator's own, as opposed to those their sellers ran.
+    scope :first_party, -> { where(seller_id: nil) }
 
     #
     # Preferences
@@ -83,8 +114,15 @@ module Spree
     end
 
     def generate
-      send(:"generate_#{format}")
-      handle_attachment
+      # An export runs in a job, where nothing has named a store. Scopes that
+      # read the current one — the product search's custom-field arm, address
+      # validation — would otherwise answer for the default store rather than
+      # the one whose records are being exported.
+      Spree::Current.set(store: store) do
+        send(:"generate_#{format}")
+        handle_attachment
+      end
+
       send_export_done_email
     end
 
@@ -94,11 +132,11 @@ module Spree
         records_to_export.includes(scope_includes).find_in_batches do |batch|
           batch.each do |record|
             if multi_line_csv?
-              record.to_csv(store).each do |line|
+              record.to_csv(store, **to_csv_options).each do |line|
                 csv << Spree::CSV::FormulaSanitizer.row(line)
               end
             else
-              csv << Spree::CSV::FormulaSanitizer.row(record.to_csv(store))
+              csv << Spree::CSV::FormulaSanitizer.row(record.to_csv(store, **to_csv_options))
             end
           end
         end
@@ -109,15 +147,25 @@ module Spree
       false
     end
 
+    # Keyword arguments passed to each record's `to_csv`. Subclasses override
+    # to narrow what a particular export writes — see Spree::Exports::Orders,
+    # which drops columns a seller may not read.
+    #
+    # @return [Hash]
+    def to_csv_options
+      {}
+    end
+
     def csv_headers
       raise NotImplementedError, 'csv_headers must be implemented'
     end
 
-    # Returns an array of metafield headers for the model
+    # Returns an array of custom_field headers for the model
     #
     # @return [Array<String>]
-    def metafields_headers
-      @metafields_headers ||= Spree::MetafieldDefinition.for_resource_type(model_class.to_s).order(:namespace, :key).map(&:csv_header_name)
+    def custom_fields_headers
+      @custom_fields_headers ||= store.custom_field_definitions.for_resource_type(model_class.to_s).
+                                 order(:namespace, :key).map(&:csv_header_name)
     end
 
     def build_csv_line(_record)
@@ -130,23 +178,43 @@ module Spree
       ::File.delete(export_tmp_file_path) if ::File.exist?(export_tmp_file_path)
     end
 
+    # The records this export may contain.
+    #
+    # Tenancy is these scope narrowings, never the ability: a seller holding
+    # `read_orders` is granted the model class, not their own subset (see
+    # Spree::Ability), so dropping `for_seller` here would put every seller's
+    # rows in one seller's file.
     def scope
       scope = model_class
       scope = scope.for_store(store) if model_class.respond_to?(:for_store)
-      scope = scope.for_vendor(vendor) if model_class.respond_to?(:for_vendor) && vendor.present?
-      scope.accessible_by(current_ability)
+
+      if seller.present?
+        raise SellerScopeUnavailable, model_class unless model_class.respond_to?(:for_seller)
+
+        scope = scope.for_seller(seller)
+        # A draft is either a checkout in flight or the operator's working
+        # document, and is not this seller's sale — the same exclusion every
+        # endpoint on the seller branch applies.
+        scope = scope.not_drafts if model_class.respond_to?(:not_drafts)
+      end
+
+      # A staff-created export only contains what its creator may read; a
+      # userless export (console, system jobs) is unfiltered.
+      scope = scope.accessible_by(current_ability) if user.present?
+      scope
     end
 
     def records_to_export
       return scope.ransack.result if search_params.blank?
 
-      params = search_params.is_a?(String) ? JSON.parse(search_params.to_s).to_h : search_params
-      params = decode_prefixed_id_filters(params)
+      params = decoded_search_params
 
       # `cf_*` custom-field predicates aren't Ransack attributes — resolve them
       # first so an export of a filtered list matches what the admin sees.
-      filtered_scope, params = if scope.respond_to?(:with_metafield_filters)
-                                scope.with_metafield_filters(params)
+      filtered_scope, params = if scope.respond_to?(:with_custom_field_filters)
+                                scope.with_custom_field_filters(
+                                  params, schema: Spree::SearchProvider::CustomFieldSchema.new(store)
+                                )
                               else
                                 [scope, params]
                               end
@@ -154,9 +222,27 @@ module Spree
       filtered_scope.ransack(params).result
     end
 
+    # `search_params` as a Hash — whether it is still the Hash a caller
+    # assigned or the JSON string the column stores.
+    #
+    # @return [ActiveSupport::HashWithIndifferentAccess]
+    def parsed_search_params
+      return {}.with_indifferent_access if search_params.blank?
+
+      params = search_params.is_a?(String) ? JSON.parse(search_params.to_s).to_h : search_params
+      params.to_h.with_indifferent_access
+    end
+
+    # `parsed_search_params` with prefixed ids decoded to primary keys.
+    #
+    # @return [ActiveSupport::HashWithIndifferentAccess]
+    def decoded_search_params
+      decode_prefixed_id_filters(parsed_search_params)
+    end
+
     # Replace any prefixed IDs in `search_params` with their raw DB IDs so
     # Ransack can match them. Without this, an admin filtering an export by
-    # a foreign key (`promotion_id_eq: 'promo_xxx'`, `vendor_id_in: [...]`)
+    # a foreign key (`promotion_id_eq: 'promo_xxx'`, `seller_id_in: [...]`)
     # would always get zero rows. We only touch values that look like
     # prefixed IDs — anything else (numeric IDs, code strings, ranges,
     # state names) passes through untouched.
@@ -182,7 +268,7 @@ module Spree
     # eg. Spree::Exports::Products => Spree::Product
     def model_class
       if type == 'Spree::Exports::Customers'
-        Spree.user_class
+        Spree.customer_class
       else
         "Spree::#{type.demodulize.singularize}".constantize
       end
@@ -209,8 +295,11 @@ module Spree
       end
     end
 
+    # Capability is read against whatever granted it: a seller's roles are held
+    # on the seller, not the store, so an ability built from the store alone
+    # would answer "no rules" and empty the file.
     def current_ability
-      @current_ability ||= Spree.ability_class.new(user, { store: store })
+      @current_ability ||= Spree.ability_class.new(user, { store: store, resource: seller || store })
     end
 
     # eg. Spree::Exports::Products => products-store-my-store-code-20241030133348.csv
@@ -278,6 +367,24 @@ module Spree
 
     private
 
+    def seller_scope_must_be_available
+      return if model_class.respond_to?(:for_seller)
+
+      errors.add(:type, :seller_scope_unavailable)
+    rescue NameError
+      # An unresolvable `type` is the presence/registry validation's business.
+      nil
+    end
+
+    # A seller can only export the marketplace they belong to. Mirrors the
+    # Spree::Import twin — the two models carry the same tenancy pair.
+    def ensure_seller_belongs_to_store
+      return if seller.blank? || store.blank?
+      return if seller.store_id == store_id
+
+      errors.add(:seller, :invalid)
+    end
+
     def set_default_format
       self.format = SUPPORTED_FILE_FORMATS.first if format.blank?
     end

data/app/models/spree/exports/customers.rb

@@ -5,12 +5,12 @@ module Spree
         [
           { bill_address: :state },
           { ship_address: :state },
-          { metafields: :metafield_definition }
+          { custom_fields: :custom_field_definition }
         ]
       end
 
       def csv_headers
-        Spree::CSV::CustomerPresenter::HEADERS + metafields_headers
+        Spree::CSV::CustomerPresenter::HEADERS + custom_fields_headers
       end
     end
   end

data/app/models/spree/exports/gift_cards.rb

@@ -2,11 +2,11 @@ module Spree
   module Exports
     class GiftCards < Spree::Export
       def scope_includes
-        [:user, { metafields: :metafield_definition }]
+        [:user, { custom_fields: :custom_field_definition }]
       end
 
       def csv_headers
-        Spree::CSV::GiftCardPresenter::HEADERS + metafields_headers
+        Spree::CSV::GiftCardPresenter::HEADERS + custom_fields_headers
       end
     end
   end

data/app/models/spree/exports/newsletter_subscribers.rb

@@ -6,11 +6,11 @@ module Spree
       end
 
       def scope_includes
-        [:user, { metafields: :metafield_definition }]
+        [:user, { custom_fields: :custom_field_definition }]
       end
 
       def csv_headers
-        Spree::CSV::NewsletterSubscriberPresenter::HEADERS + metafields_headers
+        Spree::CSV::NewsletterSubscriberPresenter::HEADERS + custom_fields_headers
       end
     end
   end

data/app/models/spree/exports/orders.rb

@@ -1,15 +1,17 @@
 module Spree
   module Exports
     class Orders < Spree::Export
+      SELLER_OMITTED_HEADERS = ['Email'].freeze
+
       def scope_includes
         [
           :store,
           :payments,
           :shipments,
-          { bill_address: [:state, :country] },
-          { ship_address: [:state, :country] },
-          { line_items: { variant: { product: [:taxons] } } },
-          { metafields: :metafield_definition }
+          :bill_address,
+          :ship_address,
+          { line_items: { variant: { product: [:categories] } } },
+          { custom_fields: :custom_field_definition }
         ]
       end
 
@@ -18,7 +20,35 @@ module Spree
       end
 
       def csv_headers
-        Spree::CSV::OrderLineItemPresenter::HEADERS + metafields_headers
+        Spree::CSV::OrderLineItemPresenter.headers(omit_headers: omitted_headers) + custom_fields_headers
+      end
+
+      def to_csv_options
+        { omit_headers: omitted_headers }
+      end
+
+      # Columns a seller's own export leaves out.
+      #
+      # The buyer's email is withheld from every seller-facing surface — it is
+      # the one contact detail that lets a marketplace's customer be taken off
+      # the marketplace, and `Spree::Api::V3::Seller::OrderSerializer` already
+      # withholds it. A bulk CSV that carried it would hand over in a
+      # spreadsheet exactly what the order page refuses to show, and would
+      # undo the message relay this is the counterpart to
+      # (docs/plans/6.1-marketplace-message-relay.md).
+      #
+      # The addresses stay, phones included, and deliberately so: a seller is
+      # merchant of record for their own child order, so they ship to one and
+      # invoice against the other, and until the relay ships the phone on the
+      # shipping address is a seller's only way to reach a buyer about a
+      # delivery (docs/plans/6.1-marketplace-message-relay.md). Email is
+      # withheld where the phone is not because email is the channel that
+      # takes a customer off the marketplace, while a delivery phone number is
+      # what makes the parcel arrive.
+      #
+      # @return [Array<String>]
+      def omitted_headers
+        seller.present? ? SELLER_OMITTED_HEADERS : []
       end
     end
   end

data/app/models/spree/exports/price_list_prices.rb

@@ -0,0 +1,107 @@
+module Spree
+  module Exports
+    # One price list's prices, one rung per line, keyed by SKU so the file
+    # round-trips through Spree::Imports::PriceListPrices
+    # (docs/plans/6.0-volume-pricing.md).
+    #
+    # Placeholder rows — on the list but carrying no amount — are not written:
+    # the import reads a blank price as "remove this rung", so writing them
+    # would make an unchanged re-import take those products off the list.
+    class PriceListPrices < Spree::Export
+      # How many rows are loaded behind the ordered ids at a time.
+      BATCH_SIZE = 1_000
+
+      validate :price_list_selected, on: :create
+
+      # Price lists are gated by the products scope family, like their own
+      # endpoints (see Admin::PriceListsController) — there is no
+      # `read_price_lists` scope a key could be minted with.
+      def self.required_scope
+        :products
+      end
+
+      def self.model_class
+        Spree::Price
+      end
+
+      def model_class
+        Spree::Price
+      end
+
+      def scope_includes
+        [:variant]
+      end
+
+      # Only this store's lists: `Spree::Price` has no store of its own, so the
+      # tenancy narrowing the base class does through `for_store` is done here.
+      def scope
+        super.for_price_list(store.price_lists).where.not(amount: nil)
+      end
+
+      def csv_headers
+        Spree::CSV::PriceListPricePresenter::HEADERS
+      end
+
+      # Ladders read top to bottom — product, then variant, currency and
+      # quantity. `find_in_batches` forces primary-key order, so the ordered
+      # ids are fetched first and the rows loaded in slices behind them.
+      def generate_csv
+        ::CSV.open(export_tmp_file_path, 'wb', encoding: 'UTF-8', col_sep: ',', row_sep: "\r\n") do |csv|
+          csv << csv_headers
+          ordered_ids.each_slice(BATCH_SIZE) do |ids|
+            prices = Spree::Price.where(id: ids).includes(scope_includes).index_by(&:id)
+            ids.each do |id|
+              price = prices[id]
+              next if price.nil?
+
+              csv << Spree::CSV::FormulaSanitizer.row(Spree::CSV::PriceListPricePresenter.new(price).call)
+            end
+          end
+        end
+      end
+
+      # The list the export was asked for — the same Ransack filter every
+      # export carries (`price_list_id_eq`) — or nil when it names none of
+      # this store's.
+      #
+      # @return [Spree::PriceList, nil]
+      def price_list
+        value = parsed_search_params['price_list_id_eq']
+        return unless value.is_a?(String) || value.is_a?(Integer)
+
+        # A prefixed id has to be a price list's: `find_by_prefix_id` refuses
+        # another model's prefix, where a bare decode would happily turn a
+        # product's id into a list number.
+        if Spree::PrefixedId.prefixed_id?(value.to_s)
+          store.price_lists.find_by_prefix_id(value.to_s)
+        else
+          store.price_lists.find_by(id: value)
+        end
+      rescue JSON::ParserError
+        nil
+      end
+
+      private
+
+      def ordered_ids
+        variants = Spree::Variant.arel_table
+        prices = Spree::Price.arel_table
+
+        records_to_export
+          .joins(:variant)
+          .reorder(variants[:product_id].asc, variants[:position].asc, prices[:variant_id].asc,
+                   prices[:currency].asc, prices[:min_quantity].asc)
+          .pluck(prices[:id])
+      end
+
+      # Every list's rows in one file would be indistinguishable — the file
+      # names no list — so an export is refused until it is asked for one that
+      # this store owns. "All records" clears the filter, and is refused too.
+      def price_list_selected
+        return if record_selection != 'all' && price_list.present?
+
+        errors.add(:base, :price_list_required)
+      end
+    end
+  end
+end

data/app/models/spree/exports/products.rb

@@ -3,13 +3,13 @@ module Spree
     class Products < Spree::Export
       # to avoid N+1 queries
       def scope_includes
-        includes = [:tax_category, :master, :option_types, { taxons: :taxonomy }, { variants_including_master: variant_includes }]
-        includes << { metafields: :metafield_definition }
+        includes = [:tax_category, :option_types, :categories, { variants: variant_includes }]
+        includes << { custom_fields: :custom_field_definition }
         includes
       end
 
       def variant_includes
-        [:images, :prices, :stock_items, :stock_locations, { option_values: [:option_type] }]
+        [:images, :prices, :stock_levels, :stock_locations, { option_values: [:option_type] }]
       end
 
       def multi_line_csv?
@@ -27,7 +27,7 @@ module Spree
 
       def csv_headers
         headers = Spree::CSV::ProductVariantPresenter::CSV_HEADERS.dup
-        headers += metafields_headers
+        headers += custom_fields_headers
         @csv_headers ||= headers
       end
     end

data/app/models/spree/exports/purchase_orders.rb

@@ -0,0 +1,39 @@
+module Spree
+  module Exports
+    # Purchase orders as a supplier reads them: one row per line, the order's
+    # header repeated on each. Filtered to one order, it is the file a merchant
+    # sends to that supplier.
+    class PurchaseOrders < Spree::Export
+      def self.required_scope
+        :purchasing
+      end
+
+      def self.model_class
+        Spree::PurchaseOrder
+      end
+
+      def model_class
+        Spree::PurchaseOrder
+      end
+
+      def scope_includes
+        [:supplier, :destination_location, { items: { variant: :product } }]
+      end
+
+      def csv_headers
+        Spree::CSV::PurchaseOrderItemPresenter::HEADERS
+      end
+
+      def generate_csv
+        ::CSV.open(export_tmp_file_path, 'wb', encoding: 'UTF-8', col_sep: ',', row_sep: "\r\n") do |csv|
+          csv << csv_headers
+          records_to_export.includes(scope_includes).find_each do |purchase_order|
+            purchase_order.items.each do |item|
+              csv << Spree::CSV::FormulaSanitizer.row(Spree::CSV::PurchaseOrderItemPresenter.new(item).call)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/spree/exports/report.rb

@@ -0,0 +1,95 @@
+module Spree
+  module Exports
+    # CSV of one reporting query (docs/plans/6.0-analytics-semantic-layer.md).
+    # `search_params` carries `{ "query" => <contract JSON> }`; the rows are the
+    # compiled result plus a totals line. Runs as the requesting user so the
+    # query is authorized member-by-member exactly like the API — which is
+    # why a user is required (API keys cannot queue report exports).
+    class Report < Spree::Export
+      validates :user, presence: true
+      # Refuse now what the background job would refuse later: a query that
+      # does not compile, or a member the requesting user may not read, must
+      # be a 422 the caller sees rather than an export that never becomes done.
+      validate :query_must_compile_and_be_readable, on: :create, if: -> { user.present? }
+
+      def self.required_scope
+        :reports
+      end
+
+      # Not a bulk export of a model, so anchor on the saved-report model.
+      def self.model_class
+        Spree::SavedReport
+      end
+
+      def model_class
+        self.class.model_class
+      end
+
+      def csv_headers
+        labels = Spree::Reporting::Schema.new(store: store)
+        dimension_labels = reporting_query.dimensions.map { |d| labels.label_for(:dimensions, d[:dimension].name) }
+        metric_labels = reporting_query.metrics.map { |m| labels.label_for(:metrics, m.name) }
+        dimension_labels + metric_labels
+      end
+
+      def generate_csv
+        query = reporting_query
+        authorize_members!(query)
+        result = query.execute
+
+        # Labels, not group keys: the file must read like the screen, so a
+        # channel column says "Web", never the channel's database id.
+        hydration = Spree::Reporting::Hydration.new(result, store: store)
+
+        ::CSV.open(export_tmp_file_path, 'wb', encoding: 'UTF-8', col_sep: ',', row_sep: "\r\n") do |csv|
+          csv << csv_headers
+          result.rows.each do |row|
+            csv << Spree::CSV::FormulaSanitizer.row(
+              row[:dimensions].map { |name, raw| hydration.label(name, raw) } +
+                query.metrics.map { |m| row[:metrics][m.name][:value] }
+            )
+          end
+          totals = query.metrics.map { |m| result.totals[m.name][:value] }
+          # With a breakdown the totals close the file under a "Total" label in
+          # the first dimension column; without one the totals are the only row.
+          label = query.dimensions.empty? ? [] : [Spree.t('reporting.export.total')] + Array.new(query.dimensions.size - 1, '')
+          csv << Spree::CSV::FormulaSanitizer.row(label + totals)
+        end
+      end
+
+      private
+
+      def reporting_query
+        @reporting_query ||= Spree::Reporting::Query.new(store: store, params: query_params)
+      end
+
+      # The base class parses the column; this only has to insist the payload
+      # is an object, since a bare array or `null` is valid JSON that would
+      # otherwise crash rather than fail validation.
+      def query_params
+        raise Spree::Reporting::InvalidQuery, 'search_params must be an object' unless parsed_payload_is_object?
+
+        parsed_search_params[:query] || {}
+      end
+
+      def parsed_payload_is_object?
+        search_params.blank? || !search_params.is_a?(String) || JSON.parse(search_params).is_a?(Hash)
+      rescue JSON::ParserError
+        false
+      end
+
+      def authorize_members!(query)
+        forbidden = query.unreadable_subjects(current_ability).first
+        raise CanCan::AccessDenied.new(nil, :read, forbidden) if forbidden
+      end
+
+      def query_must_compile_and_be_readable
+        errors.add(:base, :forbidden_reporting_member) if reporting_query.unreadable_subjects(current_ability).any?
+      rescue Spree::Reporting::UnknownMember, Spree::Reporting::InvalidQuery => e
+        errors.add(:search_params, :invalid_reporting_query, message: e.message)
+      rescue JSON::ParserError
+        errors.add(:search_params, :invalid)
+      end
+    end
+  end
+end