spree_api 6.0.0.beta4 → 6.0.0.rc2

data/app/services/spree/api/v3/request_schema.rb

@@ -0,0 +1,430 @@
+module Spree
+  module Api
+    module V3
+      # What one write endpoint accepts, declared once. The controller permits
+      # from it, the API reference documents it, and the SDK request types are
+      # generated from the reference, so the three cannot disagree.
+      #
+      #   request_params :product do |body|
+      #     body.attribute :name, :string, required: true, on: :create
+      #     body.attribute :status, :string, choices: Spree::Product::STATUSES, open: true
+      #     body.attribute :category_ids, :array, of: :id
+      #     body.attribute :metadata, :hash
+      #     body.attribute :prices, :array, of: Spree::Api::V3::PriceRequestSchema
+      #     body.attribute :options, :array do |option|
+      #       option.attribute :name, :string, required: true
+      #     end
+      #   end
+      #
+      # The vocabulary is the `preference` one: a type symbol, `of:` for what
+      # an `:array` holds, `choices:` for a closed list (`open: true` when
+      # extensions may extend it), `:hash` for any keys. `required: true` is
+      # required on both actions; add `on: :create` to require it when
+      # creating only. `only: :create` (or `:update`) accepts the field on one
+      # action alone. `permit: false` documents a field the controller reads
+      # from the raw params itself. `format:` documents a string's format
+      # (`email`, `uri`). `deprecated: 'Use country_code. Removed in 6.1.'`
+      # keeps a field working while the API reference and the SDK types flag it.
+      class RequestSchema
+        KINDS = {
+          string: { type: :string },
+          integer: { type: :integer },
+          # Measurements a client sends as JSON numbers (weights, dimensions,
+          # coordinates). Money is never a number: use `decimal`.
+          number: { type: :number },
+          # Amounts, rates and quantities with decimals travel as canonical
+          # decimal strings, never JSON numbers (see Spree::Money::Rounding).
+          decimal: { type: :string, format: :decimal, pattern: '^-?\d+(\.\d+)?$' },
+          boolean: { type: :boolean },
+          date: { type: :string, format: :date },
+          datetime: { type: :string, format: :'date-time' },
+          id: { type: :string },
+          any: {},
+          # ISO codes, from the closed lists below.
+          country: { type: :string },
+          currency: { type: :string },
+          locale: { type: :string }
+        }.freeze
+
+        # The ISO lists a `country` or `currency` field takes, published once
+        # per API as a named component — the same `CountryCode` and
+        # `CurrencyCode` types the serializers declare, so a value read from
+        # a response is the type a request takes.
+        CODE_LISTS = {
+          country: ['CountryCode', -> { Spree::IsoData.country_codes }],
+          currency: ['CurrencyCode', -> { Spree::Money::Rounding::CURRENCY_CODES }],
+          locale: ['LocaleCode', -> { Spree::Locales::ALL }]
+        }.freeze
+
+        ACTIONS = %i[create update].freeze
+
+        OPEN_LIST_NOTE = 'The values listed are the built-in ones; extensions may add more.'.freeze
+
+        class Field
+          attr_reader :name, :kind, :array, :required, :nullable, :description, :example, :enum, :open, :only, :schema,
+                      :permit, :format, :deprecated
+
+          def initialize(name, kind, array: false, required: false, nullable: false, description: nil,
+                         example: nil, enum: nil, open: false, only: nil, schema: nil, permit: true, format: nil,
+                         deprecated: nil)
+            raise ArgumentError, "deprecated: says what to use instead (#{name})" if deprecated == true
+
+            raise ArgumentError, "open: needs an enum: list of the built-in values (#{name})" if open && enum.nil?
+
+            unless required.in?([true, false, :create])
+              raise ArgumentError, "required: must be true, false or :create (#{name})"
+            end
+            raise ArgumentError, "only: must be :create or :update (#{name})" if only && !only.in?(ACTIONS)
+
+            @name = name.to_sym
+            @kind = kind
+            @array = array
+            @required = required
+            @nullable = nullable
+            @description = description
+            @example = example
+            @enum = enum&.map(&:to_s)
+            @open = open
+            @only = only
+            @schema = schema
+            @permit = permit
+            @format = format
+            @deprecated = deprecated
+          end
+
+          # @param action [Symbol, nil]
+          def accepted_on?(action)
+            only.nil? || action.nil? || only == action
+          end
+
+          # @param action [Symbol, nil]
+          def required_on?(action)
+            required == true || (required == :create && action == :create)
+          end
+
+          # This field, required on `on` (`:create`) or always. A field
+          # already required always stays required always.
+          #
+          # @param on [Symbol, nil] `:create`, or nil for every action
+          # @return [Field]
+          def required_copy(on)
+            copy = dup
+            copy.instance_variable_set(:@required, required == true ? true : on || true)
+            copy
+          end
+
+          # A hash of any keys, such as `metadata` or `provider_settings`.
+          def free_object?
+            kind == :object && schema.nil?
+          end
+        end
+
+        attr_reader :name, :fields
+
+        # The types an attribute takes: the scalars above, plus `:hash` (any
+        # keys), `:object` (a block or a `shape:`) and `:array` (`of:` a type
+        # or a shape, or a block of fields).
+        TYPES = (KINDS.keys + %i[hash object array]).freeze
+
+        # A shape shared between several endpoints (a price, an address),
+        # published as its own component so each SDK has one type for it.
+        #
+        # @param name [String] the component name, such as `PriceParams`
+        # @return [RequestSchema]
+        def self.shape(name, &block)
+          raise ArgumentError, "a shape's name ends in Params (#{name})" unless name.to_s.end_with?('Params')
+
+          new(name, &block)
+        end
+
+        # A shape several endpoints share is a class in app/request_schemas,
+        # declared the way a model declares its attributes:
+        #
+        #   class Spree::Api::V3::PriceRequestSchema < Spree::Api::V3::RequestSchema
+        #     publishes 'PriceParams'
+        #
+        #     attribute :currency, :currency, required: true
+        #   end
+        #
+        # A subclass starts from its parent's attributes, so the Admin API's
+        # address extends the shared one. Without `publishes` the class is a
+        # set of attributes other declarations include rather than a type of
+        # its own.
+        class << self
+          # @param name [String] the component name, ending in `Params`
+          def publishes(name)
+            raise ArgumentError, "a shape's name ends in Params (#{name})" unless name.to_s.end_with?('Params')
+            raise ArgumentError, "#{self.name}: `publishes` goes before the attributes" if @definition
+
+            @published_name = name.to_s
+          end
+
+          # @return [RequestSchema] what the class declares
+          def definition
+            @definition ||= new(@published_name).tap do |schema|
+              schema.include_attributes(superclass) if superclass < RequestSchema
+            end
+          end
+
+          # @param value [RequestSchema, Class] an instance or a declared class
+          # @return [RequestSchema, nil]
+          def resolve(value)
+            value.is_a?(Class) ? value.definition : value
+          end
+
+          %i[attribute include_attributes require_attributes external_references].each do |method|
+            define_method(method) { |*args, **options, &block| definition.public_send(method, *args, **options, &block) }
+          end
+        end
+
+        # @param name [String, Symbol, nil] the resource, `product` publishing
+        #   `ProductCreateParams` and `ProductUpdateParams`; or a name ending
+        #   in `Params`, published as given for every action
+        # @yieldparam schema [RequestSchema] the schema, to declare attributes on
+        def initialize(name = nil)
+          @name = name&.to_s
+          @fields = {}
+          yield self if block_given?
+        end
+
+        # Declares one attribute of the body.
+        #
+        # @param name [Symbol]
+        # @param type [Symbol] one of TYPES
+        # @param of [Symbol, Class, RequestSchema, nil] what an `:array` holds:
+        #   a scalar type, or a shared shape
+        # @param shape [Class, RequestSchema, nil] what an `:object` holds
+        # @param as [String, nil] publishes a block's object (or the objects
+        #   of an `:array`) as a component of this name
+        # @param choices [Array, nil] the values the attribute takes
+        # @param required [Boolean]
+        # @param on [Symbol, nil] `:create` to require it only when creating
+        # @yieldparam schema [RequestSchema] a nested object's attributes
+        def attribute(name, type, of: nil, shape: nil, as: nil, choices: nil, required: false, on: nil, **options, &block)
+          raise ArgumentError, "#{name}: unknown type #{type.inspect}; use one of #{TYPES.join(', ')}" unless TYPES.include?(type)
+          raise ArgumentError, "#{name}: `on:` scopes `required: true` and is `:create`" if on && (!required || on != :create)
+
+          options = options.merge(required: on || required, enum: choices)
+          nested = nested_schema(type, of: of, shape: shape, as: as, &block)
+
+          case type
+          when :array then add_array(name, of, nested, options)
+          when :object
+            raise ArgumentError, "#{name}: an :object needs a block or `shape:`; use :hash for any keys" unless nested
+
+            add(Field.new(name, :object, schema: nested, **options))
+          when :hash then add(Field.new(name, :object, **options))
+          else add(Field.new(name, type, **options))
+          end
+        end
+
+        # The identities a record has in external systems, which the Admin API
+        # reads from the raw params (Admin::Concerns::ExternalReferences).
+        def external_references
+          attribute :external_references, :hash, permit: false, description: <<~TEXT.squish
+            Identities the record has in external systems, keyed by system: the same
+            `{ system: external_id }` map the Admin API renders, so what you read can be
+            sent straight back. Systems you do not name keep the reference they have.
+            A list of `{ system, external_id }` entries is accepted too.
+          TEXT
+        end
+
+        # Adds the attributes of another schema, for endpoints that extend a
+        # shared set.
+        #
+        # @param other [RequestSchema, Class]
+        def include_attributes(other)
+          RequestSchema.resolve(other).fields.each_value { |field| add(field) }
+        end
+
+        # Marks attributes this schema took from another as required, for an
+        # endpoint whose model needs what the shared set leaves optional.
+        #
+        # @param names [Array<Symbol>]
+        # @param on [Symbol, nil] `:create` to require them only when creating
+        # @return [void]
+        def require_attributes(*names, on: nil)
+          raise ArgumentError, '`on:` is :create' if on && on != :create
+
+          names.each do |name|
+            field = fields.fetch(name) { raise ArgumentError, "#{name} is not an attribute of this schema" }
+            fields[name] = field.required_copy(on)
+          end
+          @permit_lists = nil
+        end
+
+        # The `params.permit` list for an action.
+        #
+        # @param action [Symbol, String, nil] `create` or `update`; nil
+        #   accepts every field
+        # @return [Array<Symbol, Hash>]
+        def permit_list(action = nil)
+          action = action&.to_sym
+          (@permit_lists ||= {})[action] ||= build_permit_list(action).freeze
+        end
+
+        # The JSON Schema of the request body for an action.
+        #
+        # @param action [Symbol, String, nil]
+        # @return [Hash]
+        def json_schema(action = nil)
+          action = action&.to_sym
+          fields = fields_for(action)
+          required = fields.select { |field| field.required_on?(action) }.map { |field| field.name.to_s }
+
+          schema = { type: :object, properties: fields.to_h { |field| [field.name, property_schema(field)] } }
+          schema[:required] = required if required.any?
+          schema
+        end
+
+        # The component name published for an action.
+        #
+        # @param action [Symbol, String]
+        # @return [String]
+        def component_name(action)
+          return name if name.end_with?('Params')
+
+          "#{name.camelize}#{action.to_s.camelize}Params"
+        end
+
+        # Every named shape this schema reaches, nested ones included.
+        #
+        # @return [Array<RequestSchema>]
+        def shapes
+          fields.each_value.flat_map do |field|
+            next [] unless field.schema
+
+            nested = field.schema.shapes
+            shape?(field.schema) ? [field.schema, *nested] : nested
+          end.uniq
+        end
+
+        # The ISO code lists this schema's fields reach, nested ones included,
+        # as the components they publish.
+        #
+        # @return [Hash{String => Hash}]
+        def code_lists
+          fields.each_value.each_with_object({}) do |field, lists|
+            lists.merge!(field.schema.code_lists) if field.schema
+            next unless CODE_LISTS.key?(field.kind)
+
+            name, values = CODE_LISTS[field.kind]
+            lists[name] = { type: :string, enum: values.call }
+          end
+        end
+
+        def shape?(schema)
+          schema.name.present?
+        end
+
+        private
+
+        def nested_schema(type, of:, shape:, as:, &block)
+          return RequestSchema.resolve(shape) if shape
+          return RequestSchema.resolve(of) if of.is_a?(Class) || of.is_a?(RequestSchema)
+          return unless block
+
+          as ? RequestSchema.shape(as, &block) : RequestSchema.new(&block)
+        end
+
+        def add_array(name, of, nested, options)
+          return add(Field.new(name, :object, schema: nested, array: true, **options)) if nested
+
+          unless of.is_a?(Symbol) && KINDS.key?(of)
+            raise ArgumentError, "#{name}: an :array needs `of:` a scalar type or a shape, or a block of attributes"
+          end
+          # Rails permits a list of scalars, never a list of any-key hashes.
+          if of == :any && options.fetch(:permit, true)
+            raise ArgumentError, "#{name}: a list of :any values cannot be permitted; declare its items or use `permit: false`"
+          end
+
+          add(Field.new(name, of, array: true, **options))
+        end
+
+        def add(field)
+          raise ArgumentError, "#{field.name} is declared twice" if fields.key?(field.name)
+
+          @permit_lists = nil
+          fields[field.name] = field
+        end
+
+        def build_permit_list(action)
+          scalars = []
+          nested = []
+
+          fields_for(action).each do |field|
+            next unless field.permit
+
+            if field.schema
+              nested << { field.name => field.schema.permit_list }
+            elsif field.free_object?
+              nested << { field.name => {} }
+            elsif field.kind == :any
+              # A value of any JSON type: a scalar, a list or a hash.
+              scalars << field.name
+              nested << { field.name => [] } << { field.name => {} }
+            elsif field.array
+              nested << { field.name => [] }
+            else
+              scalars << field.name
+            end
+          end
+
+          scalars + nested
+        end
+
+
+        def fields_for(action)
+          fields.values.select { |field| field.accepted_on?(action) }
+        end
+
+        def property_schema(field)
+          item = item_schema(field)
+          description = [field.description, (OPEN_LIST_NOTE if field.open), deprecation_note(field)].compact.join(' ').presence
+          documentation = { description: description, example: field.example }.compact
+          documentation[:deprecated] = true if field.deprecated
+
+          if field.array
+            schema = { type: :array, items: item }.merge(documentation)
+            schema[:nullable] = true if field.nullable
+            return schema
+          end
+
+          # A $ref ignores the keys beside it, so a described or nullable
+          # reference wraps it.
+          if item.key?(:$ref) && (documentation.any? || field.nullable)
+            item = { allOf: [item] }
+          end
+
+          item = item.merge(documentation)
+          item[:nullable] = true if field.nullable
+          item
+        end
+
+        def deprecation_note(field)
+          "Deprecated: #{field.deprecated}" if field.deprecated
+        end
+
+        def item_schema(field)
+          return { '$ref': "#/components/schemas/#{CODE_LISTS[field.kind].first}" } if CODE_LISTS.key?(field.kind)
+
+          if field.schema
+            return { '$ref': "#/components/schemas/#{field.schema.name}" } if shape?(field.schema)
+
+            return field.schema.json_schema
+          end
+          return { type: :object, additionalProperties: true } if field.free_object?
+
+          schema = KINDS.fetch(field.kind).dup
+          schema[:format] = field.format if field.format
+          return schema unless field.enum
+          return schema.merge(enum: field.enum) unless field.open
+
+          # The same open list the serializers publish (`enum_type_name`):
+          # clients autocomplete the built-in values and still accept any other.
+          { anyOf: [schema.merge(enum: field.enum), schema] }
+        end
+      end
+    end
+  end
+end

data/app/services/spree/webhooks/deliver_webhook.rb

@@ -90,10 +90,14 @@ module Spree
         http_options = { open_timeout: TIMEOUT, read_timeout: TIMEOUT, verify_mode: ssl_verify_mode }
 
         # SSRF protection is disabled in development so webhooks can reach
-        # localhost / host.docker.internal (the storefront running on the host).
-        if Rails.env.development?
+        # localhost / host.docker.internal (the storefront running on the host),
+        # and for hosts the operator explicitly trusts
+        # (Spree::Api::Config.webhooks_allowed_internal_hosts).
+        if Rails.env.development? || Spree::WebhookEndpoint.allowed_internal_host?(@delivery.url)
           uri = URI.parse(@delivery.url)
-          http = Net::HTTP.new(uri.host, uri.port)
+          # No proxy, as SsrfFilter: an egress proxy from the environment would
+          # carry this in-cluster (or localhost) request out of the network.
+          http = Net::HTTP.new(uri.hostname, uri.port, nil)
           http.use_ssl = uri.scheme == 'https'
           http_options.each { |k, v| http.send(:"#{k}=", v) }
 

data/app/subscribers/spree/webhook_event_subscriber.rb

@@ -17,19 +17,12 @@ module Spree
   class WebhookEventSubscriber < Spree::Subscriber
     subscribes_to '*'
 
-    # Admin and seller auth events carry live credentials (password reset
-    # tokens) and have no legitimate external consumer — core delivers those
-    # emails itself. Never forward them to webhook endpoints, including '*'
-    # subscriptions.
-    NON_DELIVERABLE_EVENTS = %w[
-      admin_user.password_reset_requested
-      seller_user.password_reset_requested
-    ].freeze
-
     def handle(event)
       return unless Spree::Api::Config.webhooks_enabled
       return if event.store_id.blank?
-      return if NON_DELIVERABLE_EVENTS.include?(event.name)
+      # Events declared `webhook: false` (staff and seller password reset
+      # requests) never leave Spree, whatever an endpoint subscribes to.
+      return unless Spree::Events.catalog.webhook?(event.name)
 
       # Only load the columns we need for matching and delivery
       endpoints = Spree::WebhookEndpoint

data/config/initializers/pagy.rb

@@ -5,4 +5,4 @@
 Pagy::OPTIONS[:limit] = 25
 
 # Maximum number of items per page
-Pagy::OPTIONS[:max_limit] = 100
+Pagy::OPTIONS[:client_limit] = 100

data/config/initializers/typelizer.rb

@@ -15,18 +15,16 @@ Rails.application.config.after_initialize do
     config.plugin_configs = {
       alba: {
         ts_mapper: Typelizer::SerializerPlugins::Alba::ALBA_TS_MAPPER.merge(
-          'iso8601' => { type: :string }
+          'iso8601' => { type: :string },
+          'string' => { type: :string }
         )
       }
     }
 
-    # Serializers that exist only for Admin API or events — no Store API controller
+    # Serializers that exist only for the Admin API. Event serializers stay in:
+    # they describe the `data` of the typed webhook events the Store SDK ships.
     store_excluded = %w[
-      Asset CartPromotion OrderPromotion
-      StockLevel StockMovement StockTransfer
-      Report Export Import ImportRow
-      TaxCategory Exchange ExchangeLineItem
-      SupplierEvent PurchaseOrderEvent StockReceiptEvent
+      Asset CartPromotion OrderPromotion Report TaxCategory
     ].to_set
 
     # Store SDK — no prefix, package provides namespace
@@ -34,7 +32,7 @@ Rails.application.config.after_initialize do
       c.output_dir = api_root.join('../../packages/sdk/src/types/generated')
       c.reject_class = ->(serializer:) {
         name = serializer.name.to_s
-        name.include?('::Admin::') || name.include?('::Seller::') ||
+        !name.start_with?('Spree::Api::V3::') || name.include?('::Admin::') || name.include?('::Seller::') ||
           store_excluded.include?(name.sub(/\ASpree::Api::V3::/, '').sub(/Serializer\z/, ''))
       }
       c.serializer_name_mapper = ->(serializer) {
@@ -77,7 +75,7 @@ Rails.application.config.after_initialize do
     # serializer this branch inherits references them, so their types still
     # have to exist in the package.
     store_nested_for_seller = %w[
-      Address Category CustomField OptionType OptionValue Price PriceHistory Seller
+      Category CustomField OptionType OptionValue Seller
     ].to_set
 
     config.writer(:seller) do |c|

data/config/locales/ar.yml

@@ -0,0 +1,15 @@
+---
+ar:
+  spree:
+    api:
+      cannot_delete: لا يمكن حذف %{model}
+      current_password_invalid: كلمة المرور الحالية غير صحيحة أو مفقودة
+      newsletter_verification_token_invalid: رمز التحقق من النشرة الإخبارية غير صالح أو انتهت صلاحيته.
+      password_reset_requested: إذا كان هناك حساب مرتبط بهذا البريد الإلكتروني، فقد تم إرسال تعليمات إعادة تعيين كلمة المرور.
+      password_reset_token_invalid: رمز إعادة تعيين كلمة المرور غير صالح أو انتهت صلاحيته.
+      record_not_found: "%{model} غير موجود"
+      unauthorized: أنت غير مخوّل لتنفيذ هذا الإجراء.
+      v3:
+        payments:
+          method_unavailable: طريقة الدفع هذه غير متاحة لهذا الطلب.
+          session_required: تتطلب طريقة الدفع هذه جلسة دفع. استخدم نقطة نهاية جلسات الدفع بدلًا من ذلك.

data/config/locales/be.yml

@@ -0,0 +1,15 @@
+---
+be:
+  spree:
+    api:
+      cannot_delete: "%{model} немагчыма выдаліць"
+      current_password_invalid: Бягучы пароль няправільны або адсутнічае
+      newsletter_verification_token_invalid: Токен пацверджання рассылкі няправільны або яго тэрмін дзеяння скончыўся.
+      password_reset_requested: Калі для гэтай электроннай пошты існуе ўліковы запіс, інструкцыі па скіду пароля былі адпраўлены.
+      password_reset_token_invalid: Токен скіду пароля няправільны або яго тэрмін дзеяння скончыўся.
+      record_not_found: "%{model} не знойдзена"
+      unauthorized: Вы не маеце дазволу на выкананне гэтага дзеяння.
+      v3:
+        payments:
+          method_unavailable: Гэты спосаб аплаты недаступны для гэтага заказу.
+          session_required: Гэты спосаб аплаты патрабуе плацёжнай сесіі. Замест гэтага скарыстайцеся канчатковым пунктам плацёжных сесій.

data/config/locales/bg.yml

@@ -0,0 +1,15 @@
+---
+bg:
+  spree:
+    api:
+      cannot_delete: "%{model} не може да бъде изтрит"
+      current_password_invalid: Текущата парола е невалидна или липсва
+      newsletter_verification_token_invalid: Токенът за потвърждение на бюлетина е невалиден или е изтекъл.
+      password_reset_requested: Ако съществува акаунт за този имейл, бяха изпратени инструкции за нулиране на паролата.
+      password_reset_token_invalid: Токенът за нулиране на паролата е невалиден или е изтекъл.
+      record_not_found: "%{model} не е намерен"
+      unauthorized: Нямате право да извършвате това действие.
+      v3:
+        payments:
+          method_unavailable: Този начин на плащане не е наличен за тази поръчка.
+          session_required: Този начин на плащане изисква платежна сесия. Вместо това използвайте крайната точка за платежни сесии.

data/config/locales/ca.yml

@@ -0,0 +1,15 @@
+---
+ca:
+  spree:
+    api:
+      cannot_delete: No es pot eliminar %{model}
+      current_password_invalid: La contrasenya actual no és vàlida o falta
+      newsletter_verification_token_invalid: El token de verificació del butlletí no és vàlid o ha caducat.
+      password_reset_requested: Si existeix un compte per a aquest correu electrònic, s'han enviat les instruccions per restablir la contrasenya.
+      password_reset_token_invalid: El token de restabliment de contrasenya no és vàlid o ha caducat.
+      record_not_found: No s'ha trobat %{model}
+      unauthorized: No teniu autorització per dur a terme aquesta acció.
+      v3:
+        payments:
+          method_unavailable: Aquest mètode de pagament no està disponible per a aquesta comanda.
+          session_required: Aquest mètode de pagament requereix una sessió de pagament. Utilitzeu el punt de connexió de sessions de pagament.

data/config/locales/cs.yml

@@ -0,0 +1,15 @@
+---
+cs:
+  spree:
+    api:
+      cannot_delete: "%{model} nelze odstranit"
+      current_password_invalid: Aktuální heslo je neplatné nebo chybí
+      newsletter_verification_token_invalid: Ověřovací token newsletteru je neplatný nebo vypršela jeho platnost.
+      password_reset_requested: Pokud pro tento e-mail existuje účet, byly odeslány pokyny k obnovení hesla.
+      password_reset_token_invalid: Token pro obnovení hesla je neplatný nebo vypršela jeho platnost.
+      record_not_found: "%{model} nebyl nalezen"
+      unauthorized: Nemáte oprávnění provést tuto akci.
+      v3:
+        payments:
+          method_unavailable: Tato platební metoda není pro tuto objednávku dostupná.
+          session_required: Tato platební metoda vyžaduje platební relaci. Použijte prosím endpoint platebních relací.

data/config/locales/da.yml

@@ -0,0 +1,15 @@
+---
+da:
+  spree:
+    api:
+      cannot_delete: "%{model} kan ikke slettes"
+      current_password_invalid: Den nuværende adgangskode er ugyldig eller mangler
+      newsletter_verification_token_invalid: Bekræftelsestokenet for nyhedsbrevet er ugyldigt eller er udløbet.
+      password_reset_requested: Hvis der findes en konto for den e-mail, er instruktioner til nulstilling af adgangskode blevet sendt.
+      password_reset_token_invalid: Tokenet til nulstilling af adgangskode er ugyldigt eller er udløbet.
+      record_not_found: "%{model} blev ikke fundet"
+      unauthorized: Du har ikke tilladelse til at udføre denne handling.
+      v3:
+        payments:
+          method_unavailable: Denne betalingsmetode er ikke tilgængelig for denne ordre.
+          session_required: Denne betalingsmetode kræver en betalingssession. Brug i stedet endepunktet for betalingssessioner.

data/config/locales/de-CH.yml

@@ -0,0 +1,11 @@
+---
+de-CH:
+  spree:
+    api:
+      newsletter_verification_token_invalid: Der Newsletter-Bestätigungstoken ist ungültig oder abgelaufen.
+      password_reset_requested: Falls für diese E-Mail-Adresse ein Konto besteht, wurden Anweisungen zum Zurücksetzen des Passworts versendet.
+      password_reset_token_invalid: Der Token zum Zurücksetzen des Passworts ist ungültig oder abgelaufen.
+      v3:
+        payments:
+          method_unavailable: Diese Zahlungsart ist für diese Bestellung nicht verfügbar.
+          session_required: Diese Zahlungsart erfordert eine Zahlungssitzung. Verwenden Sie stattdessen den Endpunkt für Zahlungssitzungen.

data/config/locales/de.yml

@@ -0,0 +1,15 @@
+---
+de:
+  spree:
+    api:
+      cannot_delete: "%{model} kann nicht gelöscht werden"
+      current_password_invalid: Aktuelles Passwort ist ungültig oder fehlt
+      newsletter_verification_token_invalid: Das Newsletter-Bestätigungstoken ist ungültig oder abgelaufen.
+      password_reset_requested: Falls ein Konto für diese E-Mail-Adresse besteht, wurden Anweisungen zum Zurücksetzen des Passworts versendet.
+      password_reset_token_invalid: Das Token zum Zurücksetzen des Passworts ist ungültig oder abgelaufen.
+      record_not_found: "%{model} nicht gefunden"
+      unauthorized: Sie sind nicht berechtigt, diese Aktion auszuführen.
+      v3:
+        payments:
+          method_unavailable: Diese Zahlungsmethode ist für diese Bestellung nicht verfügbar.
+          session_required: Diese Zahlungsmethode erfordert eine Zahlungssitzung. Verwenden Sie stattdessen den Endpunkt für Zahlungssitzungen.

data/config/locales/el.yml

@@ -0,0 +1,15 @@
+---
+el:
+  spree:
+    api:
+      cannot_delete: Δεν είναι δυνατή η διαγραφή του %{model}
+      current_password_invalid: Ο τρέχων κωδικός πρόσβασης είναι μη έγκυρος ή λείπει
+      newsletter_verification_token_invalid: Το token επαλήθευσης ενημερωτικού δελτίου είναι μη έγκυρο ή έχει λήξει.
+      password_reset_requested: Αν υπάρχει λογαριασμός για αυτό το email, έχουν σταλεί οδηγίες επαναφοράς κωδικού πρόσβασης.
+      password_reset_token_invalid: Το token επαναφοράς κωδικού πρόσβασης είναι μη έγκυρο ή έχει λήξει.
+      record_not_found: Δεν βρέθηκε %{model}
+      unauthorized: Δεν έχετε εξουσιοδότηση να εκτελέσετε αυτή την ενέργεια.
+      v3:
+        payments:
+          method_unavailable: Αυτή η μέθοδος πληρωμής δεν είναι διαθέσιμη για αυτή την παραγγελία.
+          session_required: Αυτή η μέθοδος πληρωμής απαιτεί μια συνεδρία πληρωμής. Χρησιμοποιήστε αντ' αυτού το σημείο πρόσβασης συνεδριών πληρωμής.