spree-kashflow 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2346845707634b7353b64e8d2a982136ead6009e47f7b1ea5b94d1e905b5455
-  data.tar.gz: 2a238745c13d9cd5a6cf0fde8e2854b2a7bc9c12c3ad35df25e396ea0d8a7159
+  metadata.gz: bf3ea17173c688a2ae5facaa72f582c02b2bb56b3d013d4d64e7467104b200b6
+  data.tar.gz: 14b81280691c79a6d6501cb4ae1e173a1e094be9c504bf90bcfb7de9cb40bc93
 SHA512:
-  metadata.gz: ff74935654982f15a9094b50b36a26d1507705b33955444df4d9490c7511d51008c6c01cd92c42ff036475f5eb7d5ad475e820aa3ddee699fe9c35d895681956
-  data.tar.gz: ecca24ec4c22aef839778a214b0a62e206588836810cb012ac762151e08ef9aed538a5e0c5b8c5a8c90ca21151658003b644691437ac19e4a8244d68a8b46438
+  metadata.gz: 4909476c53475670965c33e28bf2ec279e7551bbac94a7a43ddd3777d72577569eb84ec7fc9d216f23afa79c7e2989efef18a3deb8757fea76c20fdc04c51d2e
+  data.tar.gz: 289bc0e640aab7cea52cb96c2b019a00dd11e9bc010035b45056d947990152317755863978b5d16e071b5196a19ffc24429d9544c1fd9de7dfd34244a300f19e

data/CHANGELOG.md

@@ -1,5 +1,49 @@
 # Changelog
 
+## 0.1.3
+
+- **Fix: `upsert_customer` only ever inserted.** KashFlow publishes no
+  `InsertOrUpdateCustomer`, and the client called `InsertCustomer`
+  unconditionally with no lookup. 0.1.1 made customer codes stable per customer
+  — which is what keeps one KashFlow customer per Spree customer rather than one
+  per order — and that turned the missing lookup into a hard failure: the insert
+  succeeded exactly once, and the same customer's *second* order was rejected
+  with `Customer Code is not unique`, posting no invoice. `upsert_customer` now
+  looks the code up with `GetCustomer` and either `UpdateCustomer`s the existing
+  record or `InsertCustomer`s a new one, so it is idempotent across repeated
+  syncs.
+- `CustomerID` is prepended to the update payload rather than merged onto the
+  end, because it is the first element of the WSDL's `Customer` sequence and an
+  ASMX endpoint enforcing that sequence drops or mis-binds an out-of-order
+  element rather than raising — an update whose id was dropped would write to
+  the wrong customer, or to none, and still return successfully.
+- How KashFlow signals "no such customer" on `GetCustomer` is undocumented, so
+  both plausible shapes are treated as absent: an empty result, and an in-band
+  business rejection. Only `ApiError` is swallowed; an authentication or
+  transport failure keeps propagating rather than being read as "absent" and
+  turned back into a duplicate insert.
+
+## 0.1.2
+
+- **Fix: every order sync still failed against a live KashFlow account**, now on
+  the invoice rather than the customer. KashFlow types every date field in the
+  WSDL as `s:dateTime`, and its .NET `XmlSerializer` rejected the whole envelope
+  with `The string '2026-08-18 10:53:48 UTC' is not a valid AllXsd value` —
+  no invoice created, and the fault naming only a character offset. Gyoku
+  type-switches with `Module#===`, so `ActiveSupport::TimeWithZone` (a
+  delegator, not a `Time` subclass) fell through to `to_s`; plain `Time` did
+  too, and `Date` emitted an xsd `date` rather than a `dateTime`. Since
+  `Time.current` and Active Record datetime attributes all return
+  `TimeWithZone`, this was the default path, affecting `InvoiceDate`, `DueDate`
+  and `PayDate` on orders and `InvoiceDate` / `DueDate` on refunds.
+  `Client#call` now normalises every temporal value in an outgoing message to
+  UTC xsd `dateTime`, so the wire format is owned by the one class that touches
+  the wire and any date field added later is correct by default.
+- Assert the *serialised* SOAP body for temporal values. The suite doubled the
+  client and asserted the payload Hash, where a `TimeWithZone` looks correct
+  right up until it reaches the wire — which is why 0.1.1 shipped with this
+  defect behind a green build.
+
 ## 0.1.1
 
 - **Fix: every order sync failed against a live KashFlow account.** The customer

data/lib/spree/kashflow/client.rb

@@ -87,14 +87,28 @@ module Spree
       end
 
       ##
-      # Creates or updates a customer in KashFlow.
+      # Creates or updates a customer in KashFlow, keyed on the customer `Code`.
       #
-      # @param payload [Hash] a KashFlow `Customer` structure
-      # @return [Integer] the KashFlow customer id
+      # KashFlow publishes no `InsertOrUpdateCustomer`, so an upsert is a lookup
+      # followed by an `UpdateCustomer` or an `InsertCustomer`. The lookup is not
+      # optional: customer codes are stable per customer (that is what keeps one
+      # KashFlow customer per Spree customer rather than one per order), so an
+      # unconditional insert succeeds exactly once and every subsequent order for
+      # that customer is rejected with "Customer Code is not unique" — with no
+      # invoice posted.
+      #
+      # @param payload [Hash] a KashFlow `Customer` structure, whose `"Code"`
+      #   identifies the customer
+      # @return [Integer] the KashFlow customer id, existing or newly assigned
       # @raise [Spree::Kashflow::ApiError] when the request fails, or when
       #   KashFlow returns no usable customer id
+      # @raise [Spree::Kashflow::AuthenticationError] when KashFlow rejects the
+      #   credentials
       #
       def upsert_customer(payload)
+        existing_id = customer_id_for_code(payload["Code"])
+        return update_customer(existing_id, payload) if existing_id
+
         response = call(:insert_customer, {"custr" => payload})
         result = response.dig("InsertCustomerResponse", "InsertCustomerResult")
         assert_identifier!(result, "customer id")
@@ -182,7 +196,8 @@ module Spree
       #
       def call(operation, message = {})
         credentials = {"UserName" => @username, "Password" => @password}
-        response = savon_client.call(operation, message: credentials.merge(message))
+        body = coerce_temporal(credentials.merge(message))
+        response = savon_client.call(operation, message: body)
         body = response.body
         assert_status!(body)
         body
@@ -195,6 +210,97 @@ module Spree
         raise TransportError, e.message
       end
 
+      ##
+      # Looks a customer up by its KashFlow `Code`.
+      #
+      # How KashFlow signals "no such customer" here is undocumented, and no
+      # spec that stubs the SOAP layer can settle it, so both shapes it can
+      # plausibly take are treated as absent: an empty `GetCustomerResult`, and
+      # an in-band business rejection. Only {ApiError} is swallowed — an
+      # authentication or transport failure must keep propagating, since
+      # reading either as "absent" would turn it into a duplicate insert and
+      # put the caller back on the collision this method exists to avoid.
+      #
+      # @param code [String, nil] the KashFlow customer code
+      # @return [Integer, nil] the customer id, or nil when no customer holds
+      #   that code
+      #
+      def customer_id_for_code(code)
+        return nil if code.to_s.strip.empty?
+
+        result = call(:get_customer, {"CustomerCode" => code})
+          .dig("GetCustomerResponse", "GetCustomerResult")
+        return nil unless result.is_a?(Hash)
+
+        identifier = result["CustomerID"].to_i
+        identifier.zero? ? nil : identifier
+      rescue ApiError
+        nil
+      end
+
+      ##
+      # Updates an existing KashFlow customer in place.
+      #
+      # `CustomerID` is prepended rather than merged onto the end because it is
+      # the first element of the WSDL's `Customer` sequence, and an ASMX
+      # endpoint enforcing that sequence drops or mis-binds an out-of-order
+      # element rather than raising — an update whose id was dropped would write
+      # to the wrong customer, or to none, and still return successfully.
+      #
+      # `UpdateCustomerResult` is a `s:string`, not the customer id, so the id
+      # is carried over from the lookup instead of being read off the response.
+      #
+      # @param identifier [Integer] the KashFlow customer id
+      # @param payload [Hash] a KashFlow `Customer` structure
+      # @return [Integer] the customer id that was updated
+      #
+      def update_customer(identifier, payload)
+        call(:update_customer, {"custr" => {"CustomerID" => identifier}.merge(payload)})
+        identifier
+      end
+
+      ##
+      # Rewrites every temporal value in an outgoing message to xsd `dateTime`.
+      #
+      # KashFlow types every date field in the WSDL as `s:dateTime`, and its
+      # .NET `XmlSerializer` rejects the *entire* envelope with a
+      # `FormatException` ("is not a valid AllXsd value") when one of them is
+      # not valid xsd — the invoice is never created, and the fault names only
+      # a character offset, not the field.
+      #
+      # Gyoku cannot be relied on to do this. It type-switches with
+      # `case/when`, i.e. `Module#===`, so:
+      # - `ActiveSupport::TimeWithZone` is a *delegator*, not a `Time`
+      #   subclass, and misses the branch entirely -> `to_s`
+      #   ("2026-08-18 10:53:48 UTC").
+      # - plain `Time` is likewise emitted via `to_s` by Gyoku 1.4.
+      # - `Date` serialises as `2026-08-18`, an xsd `date`, not the `dateTime`
+      #   the schema asks for.
+      #
+      # `Time.current` and every Active Record datetime attribute return
+      # `TimeWithZone`, so the broken path was the default one, which is why
+      # every caller was affected. Normalising here rather than at each call
+      # site keeps the wire format owned by the one class that touches the
+      # wire, and means a date field added to any future payload is correct
+      # without the author having to know this.
+      #
+      # Values are converted to UTC first so the instant is preserved and the
+      # emitted form is unambiguous (`...Z`) regardless of the app's zone.
+      #
+      # @param value [Object] any message value; Hashes and Arrays are walked
+      # @return [Object] the value with temporals replaced by xsd strings
+      #
+      def coerce_temporal(value)
+        case value
+        when Hash then value.transform_values { |element| coerce_temporal(element) }
+        when Array then value.map { |element| coerce_temporal(element) }
+        when ActiveSupport::TimeWithZone, Time then value.utc.xmlschema
+        when DateTime then value.to_time.utc.xmlschema
+        when Date then value.to_time(:utc).xmlschema
+        else value
+        end
+      end
+
       ##
       # KashFlow reports business-level rejections *in band*: the SOAP call
       # succeeds at HTTP 200 with an empty result element and a `Status` /

data/lib/spree/kashflow/version.rb

@@ -2,6 +2,6 @@
 
 module Spree
   module Kashflow
-    VERSION = "0.1.1"
+    VERSION = "0.1.3"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spree-kashflow
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Aypex