Chain Protocol SB Datex-II V3
The description of the technical interface for Situation Publications (Situatieberichten or SB) is documented in the chain protocol-SB, described in the underlying paragraphs. This protocol aims to describe how systems for the exchange of DATEX II v3.x connect and exchange data with a payload of the type situationPublication. Exchange 2020 is used for the exchange. The so-called Stateful Push protocol is used. Compared to the European protocol, only delta Synchronization Push is currently not supported.
In the examples below, it is assumed that NDW is the supplier. When NDW is the receiver, the 'ID of the supplier' replaces 'NLNDW' in the 'nationalIdentifier' element.
Data exchange is based on SOAP (version 1.1) over HTTP (version 1.1). For the described method, compression must be used to limit the amount of data traffic. The HTTP header "Accept-Encoding: gzip" should be used for this purpose.
Payload
The payload contains the actual DATEX II message with the situation information.
Exchange Information
The exchangeInformation pertains to the exchange between the Supplier and the Client. Using informationManagement, situations can be ended or cancelled. The tables in the paragraphs below contain references such as sd x.x.x. These refer to components in the sequence diagrams as well as to the included XML examples.
Push Method
Systems within the SB chain have an interface available to "push" data to a receiving party. The system of this party must be built to work with the "Exchange 2020 Chain Protocol WSDL".
WSDL descriptions can be found here.
The push method contains several components described below. These include:
- Administration
- Start Connection and Deliver Data
- Maintain Connection
- Close Connection or Fail
- Request Snapshot
- Refusal of Data
Administration
Both the supplying (Supplier) and receiving (Client) parties maintain an offline administration. The supplying system records the following:
- ClientD
- End Point where the receiving system wants to receive the data
The receiving system records the following:
- SupplierID
- End Point where the supplying system wants to receive the registration
Start Connection and Deliver Data
The client state is 'offline'. The supplying system (Supplier) indicates that it is ready for delivery by sending an openSession message to the receiving system.
sd 1.0 openSession
| Elements within exchangeInformation | Value |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Country, and ID of Supplier |
| exchangeStatus | openingSession |
XML Example
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
</ex:dynamicInformation>
</stp:openSessionInput>
</soap:Body>
</soap:Envelope>
The supplying system will do this every 10 minutes until the receiving system responds or until it is manually overridden.
The receiving system responds in one of the following three ways:
- Success Snapshot on openSession
- Success Ack on openSession
- Fail on openSession
Success Snapshot on openSession
In this case, when the receiving system receives an Exchange openSession message, it will send back an Exchange snapshotSynchronizationRequest message containing a Session ID. The supplying system will then set the client state to 'online'.
sd 1.1.1 return snapshotSynchronizationRequest
| Elements within exchangeInformation | Value |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Country, and ID of Supplier |
| exchangeStatus | openingSession |
| returnStatus | snapshotSynchronisationRequest |
| sessionID | Session ID, determined by client |
XML Example
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
The supplying system will then generate a snapshot, which is sent to the receiving party with an ExchangeInformation (payloadDelivery). The data is contained in a payload of the type 'situationPublication'.
sd 1.1.2 payloadDelivery Snapshot
| Elements within payload | |
|---|---|
| All relevant situations | situation |
| Elements within exchangeInformation | Value |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Country, and ID of supplier |
| updateMethod | snapshot |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Example
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:updateMethod>snapshot</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putSnapshotDataInput>
</soap:Body>
</soap:Envelope>
The receiving system responds with an 'ack' message confirming that the snapshot has been received correctly.
sd 1.1.3 return ack
| Elements within exchangeInformation | Value |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Country, and ID of supplier |
| exchangeStatus | Online |
| returnStatus | Ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Example
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
The supplying system then exits the 'Supplier Status offline Open Session' loop and proceeds to the next sequence diagram, 'Maintain Connection' (see the next chapter).
Fail on openSession
When the receiving system sends a fail response to the openSession or if no response is received at all, the supplying system will continue to attempt to establish a connection every ten minutes.
sd 1.2.1 return fail
| Elements within exchangeInformation | Value |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Country, and ID of supplier |
| exchangeStatus | openingSession |
| returnStatus | fail |
| returnStatusReason | optional extra information |
| codedInvalidityReason | e.g.: other |
| sessionID | Session ID, previously obtained with OpenSession |
XML Example
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>optional extra reason information</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>other</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
Maintain Connection
The connection between the supplying system and the receiving system will be maintained by the supplying system. There are two scenarios: 'Data Ready for Payload Push' and 'no data keepAlive'.
Data ready for payload push
If an update to the data occurs within one minute of the last sent message, it will be sent immediately using an allElementUpdate message, with the data contained in a payload of the type situationPublication.
sd 2.1.1 allElementUpdate
| Elements within payload | |
|---|---|
| All updated situations | situation |
| Elements within exchangeInformation | Value |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| operatingMode | onOccurence |
| updateMethod | allElementUpdate |
| supplierOrCisRequester internationalIdentifier | Country, and ID of supplier |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Example
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:operatingMode>onOccurrence</ex:operatingMode>
<ex:updateMethod>allElementUpdate</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putDataInput>
</soap:Body>
</soap:Envelope>
sd 2.1.2 return ack
| Elements within exchangeInformation | Value |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Country, and ID of supplier |
| exchangeStatus | online |
| returnStatus | ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Example
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>Exchange2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
No data keepAlive
If no update to the data is available one minute after sending the last message, the supplying system will send a keep-alive message. The system will continue to send this message every minute until an update to the data is available and an allElementUpdate is sent (as described in the previous paragraph).
sd 2.2.1 keepAlive
| Elements within exchangeInformation | Value |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Country, and ID of supplier |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Example
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveInput>
</soap:Body>
</soap:Envelope>
sd 2.2.2 return ack
| Elements within exchangeInformation | Value |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Country, and ID of supplier |
| exchangeStatus | online |
| returnStatus | ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Example
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
CloseSession or Fail
When the receiving system wants to terminate the connection, it must send a closeSessionRequest in response to a push message or a keepAlive message. The supplying system will then respond with a closeSession message. The receiving system will react similarly if a message is rejected by the receiving system (fail).
Additionally, if the receiving system causes a timeout for the supplying system, the supplying system will send a closeSession.
After confirmation or timeout, the supplying system will set the session to 'offline', making the connection inactive and stopping any further data transmission.
sd 3.1 return closeSessionRequest
| Elements within exchangeInformation | Value |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | Exchange 2020 |
| supplierOrCisRequester internationalIdentifier | Country, and ID of supplier |
| exchangeStatus | closingSession |
| returnStatus | closeSessionRequest |
| sessionID | Session ID, previously obtained with OpenSession |
XML Example closeSessionRequest after putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
XML Example closeSessionRequest after putSnapshotDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
XML Example closeSessionRequest after keepAliveInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
sd 3.2 return fail
| Elements within exchangeInformation | Value |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Country, and ID of supplier |
| exchangeStatus | online |
| returnStatus | fail |
| returnStatusReason | Optional explanation |
| codedInvalidityReason | e.g.: invalidMessage |
| sessionID | Session ID, previously obtained with OpenSession |
XML Example after putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>XSD validation error at: line 110</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>invalidMessage</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
XML Example after putSnapshotDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>XSD validation error at: line 110</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>invalidMessage</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
sd 3.3 closeSession
| Elements within exchangeInformation | Value |
|---|---|
| messageType | closeSession |
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Country, and ID of supplier |
| exchangeStatus | closingSession |
| sessionID | Session ID, previously obtained with OpenSession |
XML Example
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:closeSessionInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:closeSessionInput>
</soap:Body>
</soap:Envelope>
sd 3.4 return ack
| Elements within exchangeInformation | Value |
|---|---|
| messageType | return |
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Country, and ID of supplier |
| exchangeStatus | offline |
| returnStatus | ack |
XML Example
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:closeSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>offline</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:closeSessionOutput>
</soap:Body>
</soap:Envelope>
Snapshot Request
When a receiving system needs a snapshot to understand the current situation for any reason, it can send a return message with a snapshotSynchronizationRequest in response to any message. The supplying system will generate a snapshot as a result of this request, send it to the receiving system, and then continue with the 'maintain Connection' process. This request can only be made when the session is 'online'. Otherwise, the connection must first be re-established.
Note
If no snapshot is received within two requests, the session will be closed by the receiving system. This will also force a snapshot synchronization.
sd 4.1 return snapshotSynchronizationRequest
| Elements within exchangeInformation | Value |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Country, and ID of supplier |
| exchangeStatus | online |
| returnStatus | snapshotSynchronisationRequest |
XML Example after keepAliveInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
XML Example after openSessionInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
XML Example after putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
The supplying system will then generate a snapshot with all relevant situations, which is sent to the receiving party along with an ExchangeInformation (payloadDelivery). The data is contained in a payload of the type 'situationPublication'.
sd 4.2 payloadDelivery Snapshot
| Elements within payload | |
|---|---|
| All relevant situations | situation |
| Elements within exchangeInformation | Value |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Country, and ID of supplier |
| updateMethod | snapshot |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Example
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:updateMethod>snapshot</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putSnapshotDataInput>
</soap:Body>
</soap:Envelope>
The receiving system responds with an 'ack' message confirming that the snapshot has been received correctly.
InformationManagement
The elementReference element in the informationManagedResourceList section of the InformationManagement section is used to provide the technical information status of a situation, situation component, configuration, or other publication type. From this, it can be determined whether the object referenced is expected to have further updates or not.
| Element | Type | Mandatory | Domain |
|---|---|---|---|
| elementReference | ElementReference | Yes | n/a |
| managementStatus | ManagementTypeEnum | Yes | cancelled, closed, dataChainIssue, outOfRange |
| reference | Reference | Yes | Describes the reference to the object to which the management status applies. |
| d2ElementType | D2ElementTypeEnum | Yes | measurementSite, measurementSiteTable, situation, situationRecord, vmsController, vmsControllerTable |
| managementStatusChangeTime | DateTime | Yes | Describes the time at which the management status was changed. |
InformationManagement Situation Publications (Situatieberichten)
Situations and situation components are technically closed or cancelled using the InformationManagement section. This applies to both the situations themselves and to the underlying individual situation components. In addition to this technical closure, when an event is actually ended, the payload with the situation and situation components is also sent again. This payload update includes the final end time of the event in the validity section under overallEndTime. This end time update is always sent before or simultaneously with the provision of the technical end time in InformationManagement, and never later.
Information provision about an event that has not yet actually ended and for which a situation/situation component was previously sent can be suspended. This may apply in cases of a data chain issue (dataChainIssue) or when the event no longer meets publication criteria (outOfRange). If any of these cases occur, it will be indicated using the InformationManagement section, with the reason for the suspension included in the managementStatus element. Unlike a true technical closure, in these cases no payload is sent with an actual end time in the validity section under overallEndTime. Once the actual event is definitively ended, the information provision for the situation/situation component is concluded in the same manner as described in the previous paragraph.
If a suspended event, as described in the previous paragraph, becomes relevant for publication again, the previously used situation/situation component will be reintroduced into the publication with the same ID and a higher version.
Examples of InformationManagement Situation Publications:
XML Example situation ended
Ketenprotocol Datex-II V3
Vanaf DATEXII versie 3 wordt er in elke keten gewerkt met het Exchange 2020 Ketenprotocol WSDL. De beschrijving van de technische interface voor al onze datauitwissellingen wordt hieronder daarom in een generiek protocol beschreven. Dit protocol is bedoeld om een beschrijving te geven hoe systemen voor de uitwisseling van DATEX II v3.x met elkaar verbinden en data dienen uit te wisselen met payload van verschillende types. Zie de lijst hieronder voor voorbeelden van payloads van de verschillende types.
- SituationPublication
- MeasurementSiteTablePublication
- measuredDataPublication
- VmsTablePublication
- VmsPublication
Let op
MSI en DRIPS maken beiden gebruik van de VMSTP en de VMSP
Er wordt gebruikt gemaakt van het zogenaamde Stateful Push protocol. Ten opzichte van het Europese protocol wordt op dit moment alleen delta Synchronization Push niet ondersteund. In de onderstaande voorbeelden wordt er vanuit gegaan dat NDW de leverancier is. Wanneer NDW de ontvanger is, komt dus op de plaats van 'NLNDW' in het element 'nationalIdentifier' het 'ID van de leverancier' te staan.
Uitwisseling van gegevens geschiedt op basis van SOAP (versie 1.1) over HTTP (versie 1.1). Voor de beschreven methode geldt dat er gebruik gemaakt moet worden van compressie om de hoeveelheid data verkeer te beperken. Hiervoor dient de HTTP header “Accept-Encoding: gzip” gebruikt te worden.
Payload
De payload bevat het daadwerkelijke DATEX II bericht met de informatie betreffende het gekozen type.
Exchange Information
De exchangeInformation gaat over de uitwisseling tussen de Supplier en de Client. Met behulp van informationManagement kunnen er wijzigingen, beëindigingen of annuleringen worden beschreven. In de onderstaande paragrafen staan tabellen met verwijzingen als sd x.x.x. Dit verwijst zowel naar de onderdelen in de sequence diagrammen als naar de meegeleverde XML-voorbeelden.
Push Methode
Systemen binnen een keten hebben een interface beschikbaar om data te "pushen" naar een afnemende partij. Het systeem van deze partij moet gebouwd zijn om te werken met "Exchange 2020 Ketenprotocol WSDL".
WSDL-omschrijvingen zijn hier te vinden.
De push methode bevat een aantal onderdelen die hier onder beschreven worden. Het gaat om:
- Administratie
- Start Connection and Deliver Data
- Maintain Connection
- Close Connection or Fail
- Request Snapshot
- Weigeren van data
Administratie
Zowel de aanleverende (Supplier) als de afnemende (Client) partij houden een offline administratie bij. Hierin staat geregistreerd bij het aanleverend systeem:
- AfnemerID
- End Point waarop het afnemende systeem de data wil ontvangen
Hierin staat geregistreerd bij het afnemende systeem:
- LeverancierID
- End Point waarop de het aanleverend systeem de registratie wil ontvangen
1 Start Connection and Deliver Data
De client state is 'offline'. Het aanleverend systeem (Supplier) maakt kenbaar dat het klaar is voor levering door een openSession bericht te sturen naar het afnemend systeem.
sd 1.0 openSession
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | openingSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
</ex:dynamicInformation>
</stp:openSessionInput>
</soap:Body>
</soap:Envelope>
Dit zal het aanleverende systeem elke 10 minuten doen net zolang tot het afnemende systeem reageert of tot dit handmatig overruled wordt. Na handmatige overruling moet de aanvraag natuurlijk ook weer gestart worden.
Het afnemende systeem reageert op een van de drie volgende mogelijkheden:
- Succes Snapshot on openSession
- Succes Ack on openSession
- Fail on openSession
1.1 Succes Snapshot on openSession
In dit geval zal het afnemend systeem, wanneer het een Exchange openSession bericht ontvangt, een Exchange snapshotSynchronizationRequest bericht terugsturen, met daarin een Sessie ID, waarna het leverende systeem de client State naar 'online' zet.
sd 1.1.1 return snapshotSynchronizationRequest
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | openingSession |
| returnStatus | snapshotSynchronisationRequest |
| sessionID | Session ID, determined by client |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
Hierna wordt er door het leverende systeem een snapshot gegenereerd wat met een ExchangeInformation(payloadDelivery) naar de afnemende partij wordt gestuurd. De gegevens bevinden zich in een payload van het van toepassing zijnde type.
sd 1.1.2 payloadDelivery Snapshot
| Elementen binnen payload | |
|---|---|
| Alle relevante situaties | situation |
| Alle MST informatie | measurementSiteTablePublication |
| Alle minuut metingen | measuredDataPublication |
| Alle relevante VMS controllers | vmsControllerTable |
| Status van alle revante VMS controllers | vmsControllerStatus |
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| updateMethod | snapshot |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:updateMethod>snapshot</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putSnapshotDataInput>
</soap:Body>
</soap:Envelope>
Let op
Op de puntjes in bovenstaand voorbeeld is de invulling van de payload verschillend; afhankelijk of het om MSTP, MDP, SB, VMSCST of VMSCS gaat.
Het ontvangende systeem reageert met een 'ack'-bericht dat het snapshot correct is ontvangen.
sd 1.1.3 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | Online |
| returnStatus | Ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
Hierna gaat het leverende systeem uit de loop 'Supplier Status offline Open Session' en gaat deze naar het volgende sequence diagram 'Maintain Connection' (zie het volgende hoofdstuk).
1.2 Success Ack on openSession
sd 1.2.1 return Ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | Online |
| returnStatus | Ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
Hierna gaat het leverende systeem uit de loop 'Supplier Status offline Open Session' en gaat deze naar het volgende sequence diagram 'Maintain Connection' (zie het volgende hoofdstuk).
1.3 Fail on openSession
Wanneer het afnemend systeem een fail terugstuurt op de openSession of er helemaal geen antwoord komt, blijft het aanleverende systeem elke tien minuten proberen een verbinding op te zetten.
sd 1.3.1 return fail
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | openingSession |
| returnStatus | fail |
| returnStatusReason | optionele extra informatie |
| codedInvalidityReason | bv: other |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>optional extra reason information</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>other</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
2 Maintain Connection
De verbinding tussen het aanleverend systeem en het afnemend systeem zal worden onderhouden door het aanleverend systeem. Er zijn twee scenarios: - 'Data Ready for Payload Push' - 'no data keepAlive'
2.1 Data ready for payload push
Wanneer er binnen één minuut na het laatst verstuurde bericht een update op de data is, zal deze direct verstuurd worden door middel van een allElementUpdate bericht waarbij de data zich bevindt in een payload van het betreffende type.
sd 2.1.1 allElementUpdate
| Elementen binnen payload | |
|---|---|
| Alle geüpdatete situaties | situation |
| Alle geüpdatete Measurementsites | measurementSiteTablePublication |
| Alle gemeten informatie | measuredDataPublication |
| Alle geüpdatete VMS controllers | vmsControllerTable |
| geüpdatete status van alle VMS controllers | vmsControllerStatus |
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| operatingMode | onOccurence |
| updateMethod | allElementUpdate |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:operatingMode>onOccurrence</ex:operatingMode>
<ex:updateMethod>allElementUpdate</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putDataInput>
</soap:Body>
</soap:Envelope>
Let op
Op de puntjes in bovenstaand voorbeeld is de invulling van de payload verschillend; afhankelijk of het om MSTP, MDP, SB, VMSCST of VMSCS gaat.
sd 2.1.2 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>Exchange2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
2.2 No data keepAlive
Wanneer er één minuut na het versturen van het laatste bericht nog geen update op de data te versturen is, zal het aanleverende systeem een keep-alive bericht sturen. Dit zal het systeem elke minuut blijven doen totdat er een update op de data is en er een allElementUpdate verstuurd wordt (de vorige paragraaf).
sd 2.2.1 keepAlive
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveInput>
</soap:Body>
</soap:Envelope>
sd 2.2.2 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
3 CloseSession or Fail
Wanneer het ontvangende systeem de verbinding wil verbreken, dient deze een closeSessionRequest sturen als reactie op een pushbericht of een keepAlive-bericht. Het aanleverende systeem reageert dan met een closeSession bericht. Het ontvangende systeem reageert hetzelfde wanneer een bericht geweigerd wordt door het ontvangende systeem (fail).
Ook wanneer het ontvangende systeem voor een timeout zorgt bij het aanleverende systeem, zal het aanleverende systeem een closeSession sturen.
Het aanleverende systeem zal na bevestiging of timeout de sessie naar 'offline' zetten, zo wordt de verbinding inactief en zal er geen data meer verstuurd worden.
sd 3.1 return closeSessionRequest
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | Exchange 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | closingSession |
| returnStatus | closeSessionRequest |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld closeSessionRequest na putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld closeSessionRequest na putSnapshotDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld closeSessionRequest na keepAliveInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
sd 3.2 fail on push / keep alive: return fail
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | fail |
| returnStatusReason | Optionele toelichting |
| codedInvalidityReason | bv: invalidMessage |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld na putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>XSD validation error at: line 110</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>invalidMessage</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld na putSnapshotDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>XSD validation error at: line 110</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>invalidMessage</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
sd 3.3 closeSession
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| messageType | closeSession |
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | closingSession |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:closeSessionInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:closeSessionInput>
</soap:Body>
</soap:Envelope>
sd 3.4 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| messageType | return |
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | offline |
| returnStatus | ack |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:closeSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>offline</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:closeSessionOutput>
</soap:Body>
</soap:Envelope>
Snapshot Request
Wanneer een ontvangend systeem, om wat voor reden dan ook, een snapshot nodig heeft om de huidige situatie weer te weten, kan deze op elk bericht een return bericht sturen met een snapshotSynchronizationRequest. Het aanleverende systeem zal als gevolg van dit verzoek een snapshot genereren en daarna deze naar het ontvangende systeem sturen en daarna doorgaan met de 'maintain Connection'. Dit verzoek kan alleen plaats vinden wanneer de session op 'online' staat. Anders moet eerst de verbinding weer opgezet worden.
Let op
Als er binnen twee aanvragen geen snapshot is ontvangen zal de sessie worden gesloten door het afnemende systeem. Op deze manier zal er ook een snapshot synchronisatie worden geforceerd.
sd 4.1 return snapshotSynchronizationRequest
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | snapshotSynchronisationRequest |
XML Voorbeeld na keepAliveInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld na openSessionInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld na putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
Hierna wordt er door het leverende systeem een volledige snapshot gegenereerd dat samen met een ExchangeInformation(payloadDelivery) naar de afnemende partij wordt gestuurd. De gegevens bevinden zich in een payload van het betreffende type.
sd 4.2 payloadDelivery Snapshot
| Elementen binnen payload | |
|---|---|
| Alle relevante situaties | situation |
| Alle MST informatie | measurementSiteTablePublication |
| Alle minuut metingen | measuredDataPublication |
| Alle relevante VMS controllers | vmsControllerTable |
| Status van alle revante VMS controllers | vmsControllerStatus |
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| updateMethod | snapshot |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:updateMethod>snapshot</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putSnapshotDataInput>
</soap:Body>
</soap:Envelope>
Let op
Op de puntjes in bovenstaand voorbeeld is de invulling van de payload verschillend; afhankelijk of het om MSTP, MDP, SB, VMSCST of VMSCS gaat.
Het ontvangende systeem reageert met een 'ack'-bericht dat het snapshot correct is ontvangen.
InformationManagement
Het element elementReference in het onderdeel informationManagedResourceList van de InformationManagement sectie wordt gebruikt om de technische informatiestatus van een publicatietype te geven. Hieruit is vervolgens af te leiden of van het object waarnaar gerefeerd wordt nog een vervolg te verwachten is, of niet.
| Element | Type | Verplicht | Domein |
|---|---|---|---|
| elementReference | ElementReference | Ja | nvt |
| managementStatus | ManagementTypeEnum | Ja | cancelled, closed, dataChainIssue, outOfRange |
| reference | Reference | Ja | Beschrijft de referentie naar het betreffende object waarop de managementstatus van toepassing is. |
| d2ElementType | D2ElementTypeEnum | Ja | measurementSite, measurementSiteTable, situation, situationRecord, vmsController, vmsControllerTable |
| managementStatusChangeTime | DateTime | Ja | Beschrijft het tijdstip waarop de managementstatus is gewijzigd. |
InformationManagement Situatieberichten
Situaties en situatieonderdelen worden met behulp van het onderdeel InformationManagement technisch beëindigd (closed) of geannuleerd (cancelled). Dit geldt voor zowel de situaties zelf, als voor de onderliggende individuele situatieonderdelen. Naast deze technische beëindiging wordt op het moment dat een gebeurtenis in werkelijkheid is beëindigd, aanvullend op het informationManagement onderdeel ook de payload met de situatie en situatieonderdelen nogmaals wordt verstuurd. In deze payload update wordt ook de definitieve eindtijd van de gebeurtenis opgenomen in het validity-onderdeel overallEndTime. Deze update van de eindtijd wordt altijd vóór of tegelijk met het verstrekken van de technische eindtijd in informationManagement verstuurd. Nooit later.
De informatieverstrekking over een gebeurtenis die in werkelijkheid nog niet is beëindigd en waarvoor eerder een situatie/situatieonderdeel is uitgestuurd, kan worden opgeschort. Dit kan van toepassing zijn bij een dataketenissue (dataChainIssue), of wanneer de betreffende gebeurtenis niet langer aan de voorwaarden van publicatie voldoet (outOfRange). Als een van deze gevallen optreedt dan wordt dit met behulp van het InformationManagement onderdeel aangegeven, waarbij de reden van de opschorting wordt opgenomen het element ManagementStatus. In tegenstelling tot een daadwerkelijke technische beëindiging wordt in deze gevallen géén payload meegstuurd met een daadwerkelijke eindtijd in het validity-onderdeel overallEndTime. Zodra de werkelijke gebeurtenis definitief is beëindigd wordt de informatieverstrekking van de/het situatie/situatieonderdeel afgesloten op dezelfde wijze zoals in de vorige paragraaf beschreven.
Indien een opgeschorte gebeurtenis zoals in de vorige paragraaf beschreven weer relevant wordt voor publicatie, wordt de/het eerder gebruikte situatie/situatieonderdeel weer opgenomen in de publicatie met dezelfde id en een hogere versie.
de voorbeelden staan hier.
InformationManagement VMS
VMS-controller-tables en VMS-controllers worden met behulp van het onderdeel InformationManagement verwijderd. Dit geldt voor zowel de VMS-controller-table zelf, als voor de onderliggende individuele VMS-controllers.
de voorbeelden staan hier
InformationManagement MSTP
Hier wordt dezelfde logica gevolgd als die van VMS; MTPS en measurementsiterecords worden met behulp van het onderdeel InformationManagement verwijderdt. Dit geldt dus zowel voor de MSTP zelf, als voor de onderliggende records.
de voorbeelden voor MSTP en MDP staan hier
Ketentest
Het Exchange 2020 ketenprotocol beschrijft hoe een verbinding tot stand komt en dekt foutsituaties in de verbinding af, mits het protocol correct geïmplementeerd wordt.
Uitvoeren teststappen aansluiten leverancier
Het testscenario kent afzonderlijke teststappen die gericht zijn op het testen van geïsoleerde functionaliteiten. De eerste teststap binnen het testscenario is het sturen van een openSession bericht.
| Nummer | Tijdstip | Actie leverancier | record versie | Actie NDW | Veld exchangeStatus |
Veld returnStatus |
|---|---|---|---|---|---|---|
| 0 | Verstuur openSession |
Verifieer ontvangst openSession en automatische opening van nieuwe sessie. Response met nieuwe sessie en in het element sesssionId het nieuwe sessie ID |
openingSession |
snapshotSynchronisationRequest |
||
| 1 | Verstuur snapshot met ontvangen sessionID uit openSession response |
1 | Verifieer ontvangst snapshot en verwerking van payload. |
online |
ack |
|
| 2 | Verstuur allElementUpdate met ontvangen sessionID uit openSession response |
2 | Verifieer ontvangst allElementUpdate en verwerking van payload. |
online |
ack |
|
| 3 | Verstuur alleElementUpdate of keepAlive |
Insturen van snapshotSynchronizationRequest op ontvanger. Eerst volgende aanvraag geeft correcte response voor exchange status |
online |
snapshotSynchronisationRequest |
||
| 4 | Verstuur snapshot met ontvangen sessionID uit openSession response |
2 | Verifieer ontvangst snapshot en verwerking van payload. |
online |
ack |
|
| 5 | Doorlopen levenscyclus situation (start, updates, beëindiging) met 1 of meer records | ++ | Verifieer doorlopen alle stappen, inclusief versie verhoging, timestamps en afmeldingen | |||
| 6 | Verstuur allElementUpdate of keepAlive |
Insturen van closeSessionRequest op ontvanger en op eerst volgende aanvragen sessie sluiten. |
closingSession |
|||
| 7 | Openzetten nieuwe sessie en insturen van snapshot | 2 | Verifieer ontvangst openSession en openen van nieuwe sessie. Verifieer ontvangst snapshot en verwerking van snapshot |
|||
| 8 | Verstuur closeSession met ontvangen sessionID uit openSession response |
Verifieer ontvangst closeSesssion en sluit de sessie af. Teruggeven van exchangeStatus closingSession en returnStatus: ack |
closingSession |
ack |
||
| 9 | Verstuur openSession |
Verifieer ontvangst openSession en automatische opening van nieuwe sessie. Response met nieuwe sessie en in het element sesssionId het nieuwe sessie ID |
openingSession |
ack |
Storing verbinding
Het doel van deze teststap in het scenario is om storingen in de verbinding te simuleren en te verifiëren dat de leverancier weer data begint te leveren.
De eerste stap is testen van een storing aan de kant van de provider, de tweede test uitval van NDW.
Uitval leverancier
| Nummer | Tijdstip | Actie leverancier | record versie | Actie NDW | Veld exchangeStatus |
Veld returnStatus |
|---|---|---|---|---|---|---|
| 0 | Stopt sessie zonder versturen van closeSession |
Na 1 minuut word sessie afgemeld in ontvanger | offline |
fail |
||
| 1 | Herstel verbinding met openSession, stuur snapshot |
Verifieer openSession en ontvangst snapshot |
Uitval NDW
| Nummer | Tijdstip | Actie leverancier | record versie | Actie NDW | Veld exchangeStatus |
Veld returnStatus |
|---|---|---|---|---|---|---|
| 0 | - | Geforceerd session status aanpassen naar offline. | offline |
fail |
||
| 1 | Herstel verbinding met openSession, stuur snapshot na ontvangst van bericht met exchangeStatus offline |
Verifieer openSession en ontvangst snapshot |
Duurtest
In dit laatste deel moet de leverancier aantonen dat zijn datalevering stabiel is. Het systeem moet 24 uur lang data leveren aan het NDW. NDW beheer controleert na de 24 uur of er in die tijd onderbrekingen in de verbinding zijn geweest.
XML Example situationRecord ended
Ketenprotocol Datex-II V3
Vanaf DATEXII versie 3 wordt er in elke keten gewerkt met het Exchange 2020 Ketenprotocol WSDL. De beschrijving van de technische interface voor al onze datauitwissellingen wordt hieronder daarom in een generiek protocol beschreven. Dit protocol is bedoeld om een beschrijving te geven hoe systemen voor de uitwisseling van DATEX II v3.x met elkaar verbinden en data dienen uit te wisselen met payload van verschillende types. Zie de lijst hieronder voor voorbeelden van payloads van de verschillende types.
- SituationPublication
- MeasurementSiteTablePublication
- measuredDataPublication
- VmsTablePublication
- VmsPublication
Let op
MSI en DRIPS maken beiden gebruik van de VMSTP en de VMSP
Er wordt gebruikt gemaakt van het zogenaamde Stateful Push protocol. Ten opzichte van het Europese protocol wordt op dit moment alleen delta Synchronization Push niet ondersteund. In de onderstaande voorbeelden wordt er vanuit gegaan dat NDW de leverancier is. Wanneer NDW de ontvanger is, komt dus op de plaats van 'NLNDW' in het element 'nationalIdentifier' het 'ID van de leverancier' te staan.
Uitwisseling van gegevens geschiedt op basis van SOAP (versie 1.1) over HTTP (versie 1.1). Voor de beschreven methode geldt dat er gebruik gemaakt moet worden van compressie om de hoeveelheid data verkeer te beperken. Hiervoor dient de HTTP header “Accept-Encoding: gzip” gebruikt te worden.
Payload
De payload bevat het daadwerkelijke DATEX II bericht met de informatie betreffende het gekozen type.
Exchange Information
De exchangeInformation gaat over de uitwisseling tussen de Supplier en de Client. Met behulp van informationManagement kunnen er wijzigingen, beëindigingen of annuleringen worden beschreven. In de onderstaande paragrafen staan tabellen met verwijzingen als sd x.x.x. Dit verwijst zowel naar de onderdelen in de sequence diagrammen als naar de meegeleverde XML-voorbeelden.
Push Methode
Systemen binnen een keten hebben een interface beschikbaar om data te "pushen" naar een afnemende partij. Het systeem van deze partij moet gebouwd zijn om te werken met "Exchange 2020 Ketenprotocol WSDL".
WSDL-omschrijvingen zijn hier te vinden.
De push methode bevat een aantal onderdelen die hier onder beschreven worden. Het gaat om:
- Administratie
- Start Connection and Deliver Data
- Maintain Connection
- Close Connection or Fail
- Request Snapshot
- Weigeren van data
Administratie
Zowel de aanleverende (Supplier) als de afnemende (Client) partij houden een offline administratie bij. Hierin staat geregistreerd bij het aanleverend systeem:
- AfnemerID
- End Point waarop het afnemende systeem de data wil ontvangen
Hierin staat geregistreerd bij het afnemende systeem:
- LeverancierID
- End Point waarop de het aanleverend systeem de registratie wil ontvangen
1 Start Connection and Deliver Data
De client state is 'offline'. Het aanleverend systeem (Supplier) maakt kenbaar dat het klaar is voor levering door een openSession bericht te sturen naar het afnemend systeem.
sd 1.0 openSession
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | openingSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
</ex:dynamicInformation>
</stp:openSessionInput>
</soap:Body>
</soap:Envelope>
Dit zal het aanleverende systeem elke 10 minuten doen net zolang tot het afnemende systeem reageert of tot dit handmatig overruled wordt. Na handmatige overruling moet de aanvraag natuurlijk ook weer gestart worden.
Het afnemende systeem reageert op een van de drie volgende mogelijkheden:
- Succes Snapshot on openSession
- Succes Ack on openSession
- Fail on openSession
1.1 Succes Snapshot on openSession
In dit geval zal het afnemend systeem, wanneer het een Exchange openSession bericht ontvangt, een Exchange snapshotSynchronizationRequest bericht terugsturen, met daarin een Sessie ID, waarna het leverende systeem de client State naar 'online' zet.
sd 1.1.1 return snapshotSynchronizationRequest
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | openingSession |
| returnStatus | snapshotSynchronisationRequest |
| sessionID | Session ID, determined by client |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
Hierna wordt er door het leverende systeem een snapshot gegenereerd wat met een ExchangeInformation(payloadDelivery) naar de afnemende partij wordt gestuurd. De gegevens bevinden zich in een payload van het van toepassing zijnde type.
sd 1.1.2 payloadDelivery Snapshot
| Elementen binnen payload | |
|---|---|
| Alle relevante situaties | situation |
| Alle MST informatie | measurementSiteTablePublication |
| Alle minuut metingen | measuredDataPublication |
| Alle relevante VMS controllers | vmsControllerTable |
| Status van alle revante VMS controllers | vmsControllerStatus |
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| updateMethod | snapshot |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:updateMethod>snapshot</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putSnapshotDataInput>
</soap:Body>
</soap:Envelope>
Let op
Op de puntjes in bovenstaand voorbeeld is de invulling van de payload verschillend; afhankelijk of het om MSTP, MDP, SB, VMSCST of VMSCS gaat.
Het ontvangende systeem reageert met een 'ack'-bericht dat het snapshot correct is ontvangen.
sd 1.1.3 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | Online |
| returnStatus | Ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
Hierna gaat het leverende systeem uit de loop 'Supplier Status offline Open Session' en gaat deze naar het volgende sequence diagram 'Maintain Connection' (zie het volgende hoofdstuk).
1.2 Success Ack on openSession
sd 1.2.1 return Ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | Online |
| returnStatus | Ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
Hierna gaat het leverende systeem uit de loop 'Supplier Status offline Open Session' en gaat deze naar het volgende sequence diagram 'Maintain Connection' (zie het volgende hoofdstuk).
1.3 Fail on openSession
Wanneer het afnemend systeem een fail terugstuurt op de openSession of er helemaal geen antwoord komt, blijft het aanleverende systeem elke tien minuten proberen een verbinding op te zetten.
sd 1.3.1 return fail
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | openingSession |
| returnStatus | fail |
| returnStatusReason | optionele extra informatie |
| codedInvalidityReason | bv: other |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>optional extra reason information</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>other</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
2 Maintain Connection
De verbinding tussen het aanleverend systeem en het afnemend systeem zal worden onderhouden door het aanleverend systeem. Er zijn twee scenarios: - 'Data Ready for Payload Push' - 'no data keepAlive'
2.1 Data ready for payload push
Wanneer er binnen één minuut na het laatst verstuurde bericht een update op de data is, zal deze direct verstuurd worden door middel van een allElementUpdate bericht waarbij de data zich bevindt in een payload van het betreffende type.
sd 2.1.1 allElementUpdate
| Elementen binnen payload | |
|---|---|
| Alle geüpdatete situaties | situation |
| Alle geüpdatete Measurementsites | measurementSiteTablePublication |
| Alle gemeten informatie | measuredDataPublication |
| Alle geüpdatete VMS controllers | vmsControllerTable |
| geüpdatete status van alle VMS controllers | vmsControllerStatus |
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| operatingMode | onOccurence |
| updateMethod | allElementUpdate |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:operatingMode>onOccurrence</ex:operatingMode>
<ex:updateMethod>allElementUpdate</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putDataInput>
</soap:Body>
</soap:Envelope>
Let op
Op de puntjes in bovenstaand voorbeeld is de invulling van de payload verschillend; afhankelijk of het om MSTP, MDP, SB, VMSCST of VMSCS gaat.
sd 2.1.2 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>Exchange2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
2.2 No data keepAlive
Wanneer er één minuut na het versturen van het laatste bericht nog geen update op de data te versturen is, zal het aanleverende systeem een keep-alive bericht sturen. Dit zal het systeem elke minuut blijven doen totdat er een update op de data is en er een allElementUpdate verstuurd wordt (de vorige paragraaf).
sd 2.2.1 keepAlive
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveInput>
</soap:Body>
</soap:Envelope>
sd 2.2.2 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
3 CloseSession or Fail
Wanneer het ontvangende systeem de verbinding wil verbreken, dient deze een closeSessionRequest sturen als reactie op een pushbericht of een keepAlive-bericht. Het aanleverende systeem reageert dan met een closeSession bericht. Het ontvangende systeem reageert hetzelfde wanneer een bericht geweigerd wordt door het ontvangende systeem (fail).
Ook wanneer het ontvangende systeem voor een timeout zorgt bij het aanleverende systeem, zal het aanleverende systeem een closeSession sturen.
Het aanleverende systeem zal na bevestiging of timeout de sessie naar 'offline' zetten, zo wordt de verbinding inactief en zal er geen data meer verstuurd worden.
sd 3.1 return closeSessionRequest
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | Exchange 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | closingSession |
| returnStatus | closeSessionRequest |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld closeSessionRequest na putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld closeSessionRequest na putSnapshotDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld closeSessionRequest na keepAliveInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
sd 3.2 fail on push / keep alive: return fail
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | fail |
| returnStatusReason | Optionele toelichting |
| codedInvalidityReason | bv: invalidMessage |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld na putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>XSD validation error at: line 110</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>invalidMessage</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld na putSnapshotDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>XSD validation error at: line 110</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>invalidMessage</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
sd 3.3 closeSession
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| messageType | closeSession |
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | closingSession |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:closeSessionInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:closeSessionInput>
</soap:Body>
</soap:Envelope>
sd 3.4 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| messageType | return |
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | offline |
| returnStatus | ack |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:closeSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>offline</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:closeSessionOutput>
</soap:Body>
</soap:Envelope>
Snapshot Request
Wanneer een ontvangend systeem, om wat voor reden dan ook, een snapshot nodig heeft om de huidige situatie weer te weten, kan deze op elk bericht een return bericht sturen met een snapshotSynchronizationRequest. Het aanleverende systeem zal als gevolg van dit verzoek een snapshot genereren en daarna deze naar het ontvangende systeem sturen en daarna doorgaan met de 'maintain Connection'. Dit verzoek kan alleen plaats vinden wanneer de session op 'online' staat. Anders moet eerst de verbinding weer opgezet worden.
Let op
Als er binnen twee aanvragen geen snapshot is ontvangen zal de sessie worden gesloten door het afnemende systeem. Op deze manier zal er ook een snapshot synchronisatie worden geforceerd.
sd 4.1 return snapshotSynchronizationRequest
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | snapshotSynchronisationRequest |
XML Voorbeeld na keepAliveInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld na openSessionInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld na putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
Hierna wordt er door het leverende systeem een volledige snapshot gegenereerd dat samen met een ExchangeInformation(payloadDelivery) naar de afnemende partij wordt gestuurd. De gegevens bevinden zich in een payload van het betreffende type.
sd 4.2 payloadDelivery Snapshot
| Elementen binnen payload | |
|---|---|
| Alle relevante situaties | situation |
| Alle MST informatie | measurementSiteTablePublication |
| Alle minuut metingen | measuredDataPublication |
| Alle relevante VMS controllers | vmsControllerTable |
| Status van alle revante VMS controllers | vmsControllerStatus |
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| updateMethod | snapshot |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:updateMethod>snapshot</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putSnapshotDataInput>
</soap:Body>
</soap:Envelope>
Let op
Op de puntjes in bovenstaand voorbeeld is de invulling van de payload verschillend; afhankelijk of het om MSTP, MDP, SB, VMSCST of VMSCS gaat.
Het ontvangende systeem reageert met een 'ack'-bericht dat het snapshot correct is ontvangen.
InformationManagement
Het element elementReference in het onderdeel informationManagedResourceList van de InformationManagement sectie wordt gebruikt om de technische informatiestatus van een publicatietype te geven. Hieruit is vervolgens af te leiden of van het object waarnaar gerefeerd wordt nog een vervolg te verwachten is, of niet.
| Element | Type | Verplicht | Domein |
|---|---|---|---|
| elementReference | ElementReference | Ja | nvt |
| managementStatus | ManagementTypeEnum | Ja | cancelled, closed, dataChainIssue, outOfRange |
| reference | Reference | Ja | Beschrijft de referentie naar het betreffende object waarop de managementstatus van toepassing is. |
| d2ElementType | D2ElementTypeEnum | Ja | measurementSite, measurementSiteTable, situation, situationRecord, vmsController, vmsControllerTable |
| managementStatusChangeTime | DateTime | Ja | Beschrijft het tijdstip waarop de managementstatus is gewijzigd. |
InformationManagement Situatieberichten
Situaties en situatieonderdelen worden met behulp van het onderdeel InformationManagement technisch beëindigd (closed) of geannuleerd (cancelled). Dit geldt voor zowel de situaties zelf, als voor de onderliggende individuele situatieonderdelen. Naast deze technische beëindiging wordt op het moment dat een gebeurtenis in werkelijkheid is beëindigd, aanvullend op het informationManagement onderdeel ook de payload met de situatie en situatieonderdelen nogmaals wordt verstuurd. In deze payload update wordt ook de definitieve eindtijd van de gebeurtenis opgenomen in het validity-onderdeel overallEndTime. Deze update van de eindtijd wordt altijd vóór of tegelijk met het verstrekken van de technische eindtijd in informationManagement verstuurd. Nooit later.
De informatieverstrekking over een gebeurtenis die in werkelijkheid nog niet is beëindigd en waarvoor eerder een situatie/situatieonderdeel is uitgestuurd, kan worden opgeschort. Dit kan van toepassing zijn bij een dataketenissue (dataChainIssue), of wanneer de betreffende gebeurtenis niet langer aan de voorwaarden van publicatie voldoet (outOfRange). Als een van deze gevallen optreedt dan wordt dit met behulp van het InformationManagement onderdeel aangegeven, waarbij de reden van de opschorting wordt opgenomen het element ManagementStatus. In tegenstelling tot een daadwerkelijke technische beëindiging wordt in deze gevallen géén payload meegstuurd met een daadwerkelijke eindtijd in het validity-onderdeel overallEndTime. Zodra de werkelijke gebeurtenis definitief is beëindigd wordt de informatieverstrekking van de/het situatie/situatieonderdeel afgesloten op dezelfde wijze zoals in de vorige paragraaf beschreven.
Indien een opgeschorte gebeurtenis zoals in de vorige paragraaf beschreven weer relevant wordt voor publicatie, wordt de/het eerder gebruikte situatie/situatieonderdeel weer opgenomen in de publicatie met dezelfde id en een hogere versie.
de voorbeelden staan hier.
InformationManagement VMS
VMS-controller-tables en VMS-controllers worden met behulp van het onderdeel InformationManagement verwijderd. Dit geldt voor zowel de VMS-controller-table zelf, als voor de onderliggende individuele VMS-controllers.
de voorbeelden staan hier
InformationManagement MSTP
Hier wordt dezelfde logica gevolgd als die van VMS; MTPS en measurementsiterecords worden met behulp van het onderdeel InformationManagement verwijderdt. Dit geldt dus zowel voor de MSTP zelf, als voor de onderliggende records.
de voorbeelden voor MSTP en MDP staan hier
Ketentest
Het Exchange 2020 ketenprotocol beschrijft hoe een verbinding tot stand komt en dekt foutsituaties in de verbinding af, mits het protocol correct geïmplementeerd wordt.
Uitvoeren teststappen aansluiten leverancier
Het testscenario kent afzonderlijke teststappen die gericht zijn op het testen van geïsoleerde functionaliteiten. De eerste teststap binnen het testscenario is het sturen van een openSession bericht.
| Nummer | Tijdstip | Actie leverancier | record versie | Actie NDW | Veld exchangeStatus |
Veld returnStatus |
|---|---|---|---|---|---|---|
| 0 | Verstuur openSession |
Verifieer ontvangst openSession en automatische opening van nieuwe sessie. Response met nieuwe sessie en in het element sesssionId het nieuwe sessie ID |
openingSession |
snapshotSynchronisationRequest |
||
| 1 | Verstuur snapshot met ontvangen sessionID uit openSession response |
1 | Verifieer ontvangst snapshot en verwerking van payload. |
online |
ack |
|
| 2 | Verstuur allElementUpdate met ontvangen sessionID uit openSession response |
2 | Verifieer ontvangst allElementUpdate en verwerking van payload. |
online |
ack |
|
| 3 | Verstuur alleElementUpdate of keepAlive |
Insturen van snapshotSynchronizationRequest op ontvanger. Eerst volgende aanvraag geeft correcte response voor exchange status |
online |
snapshotSynchronisationRequest |
||
| 4 | Verstuur snapshot met ontvangen sessionID uit openSession response |
2 | Verifieer ontvangst snapshot en verwerking van payload. |
online |
ack |
|
| 5 | Doorlopen levenscyclus situation (start, updates, beëindiging) met 1 of meer records | ++ | Verifieer doorlopen alle stappen, inclusief versie verhoging, timestamps en afmeldingen | |||
| 6 | Verstuur allElementUpdate of keepAlive |
Insturen van closeSessionRequest op ontvanger en op eerst volgende aanvragen sessie sluiten. |
closingSession |
|||
| 7 | Openzetten nieuwe sessie en insturen van snapshot | 2 | Verifieer ontvangst openSession en openen van nieuwe sessie. Verifieer ontvangst snapshot en verwerking van snapshot |
|||
| 8 | Verstuur closeSession met ontvangen sessionID uit openSession response |
Verifieer ontvangst closeSesssion en sluit de sessie af. Teruggeven van exchangeStatus closingSession en returnStatus: ack |
closingSession |
ack |
||
| 9 | Verstuur openSession |
Verifieer ontvangst openSession en automatische opening van nieuwe sessie. Response met nieuwe sessie en in het element sesssionId het nieuwe sessie ID |
openingSession |
ack |
Storing verbinding
Het doel van deze teststap in het scenario is om storingen in de verbinding te simuleren en te verifiëren dat de leverancier weer data begint te leveren.
De eerste stap is testen van een storing aan de kant van de provider, de tweede test uitval van NDW.
Uitval leverancier
| Nummer | Tijdstip | Actie leverancier | record versie | Actie NDW | Veld exchangeStatus |
Veld returnStatus |
|---|---|---|---|---|---|---|
| 0 | Stopt sessie zonder versturen van closeSession |
Na 1 minuut word sessie afgemeld in ontvanger | offline |
fail |
||
| 1 | Herstel verbinding met openSession, stuur snapshot |
Verifieer openSession en ontvangst snapshot |
Uitval NDW
| Nummer | Tijdstip | Actie leverancier | record versie | Actie NDW | Veld exchangeStatus |
Veld returnStatus |
|---|---|---|---|---|---|---|
| 0 | - | Geforceerd session status aanpassen naar offline. | offline |
fail |
||
| 1 | Herstel verbinding met openSession, stuur snapshot na ontvangst van bericht met exchangeStatus offline |
Verifieer openSession en ontvangst snapshot |
Duurtest
In dit laatste deel moet de leverancier aantonen dat zijn datalevering stabiel is. Het systeem moet 24 uur lang data leveren aan het NDW. NDW beheer controleert na de 24 uur of er in die tijd onderbrekingen in de verbinding zijn geweest.
XML Example cancelled
Ketenprotocol Datex-II V3
Vanaf DATEXII versie 3 wordt er in elke keten gewerkt met het Exchange 2020 Ketenprotocol WSDL. De beschrijving van de technische interface voor al onze datauitwissellingen wordt hieronder daarom in een generiek protocol beschreven. Dit protocol is bedoeld om een beschrijving te geven hoe systemen voor de uitwisseling van DATEX II v3.x met elkaar verbinden en data dienen uit te wisselen met payload van verschillende types. Zie de lijst hieronder voor voorbeelden van payloads van de verschillende types.
- SituationPublication
- MeasurementSiteTablePublication
- measuredDataPublication
- VmsTablePublication
- VmsPublication
Let op
MSI en DRIPS maken beiden gebruik van de VMSTP en de VMSP
Er wordt gebruikt gemaakt van het zogenaamde Stateful Push protocol. Ten opzichte van het Europese protocol wordt op dit moment alleen delta Synchronization Push niet ondersteund. In de onderstaande voorbeelden wordt er vanuit gegaan dat NDW de leverancier is. Wanneer NDW de ontvanger is, komt dus op de plaats van 'NLNDW' in het element 'nationalIdentifier' het 'ID van de leverancier' te staan.
Uitwisseling van gegevens geschiedt op basis van SOAP (versie 1.1) over HTTP (versie 1.1). Voor de beschreven methode geldt dat er gebruik gemaakt moet worden van compressie om de hoeveelheid data verkeer te beperken. Hiervoor dient de HTTP header “Accept-Encoding: gzip” gebruikt te worden.
Payload
De payload bevat het daadwerkelijke DATEX II bericht met de informatie betreffende het gekozen type.
Exchange Information
De exchangeInformation gaat over de uitwisseling tussen de Supplier en de Client. Met behulp van informationManagement kunnen er wijzigingen, beëindigingen of annuleringen worden beschreven. In de onderstaande paragrafen staan tabellen met verwijzingen als sd x.x.x. Dit verwijst zowel naar de onderdelen in de sequence diagrammen als naar de meegeleverde XML-voorbeelden.
Push Methode
Systemen binnen een keten hebben een interface beschikbaar om data te "pushen" naar een afnemende partij. Het systeem van deze partij moet gebouwd zijn om te werken met "Exchange 2020 Ketenprotocol WSDL".
WSDL-omschrijvingen zijn hier te vinden.
De push methode bevat een aantal onderdelen die hier onder beschreven worden. Het gaat om:
- Administratie
- Start Connection and Deliver Data
- Maintain Connection
- Close Connection or Fail
- Request Snapshot
- Weigeren van data
Administratie
Zowel de aanleverende (Supplier) als de afnemende (Client) partij houden een offline administratie bij. Hierin staat geregistreerd bij het aanleverend systeem:
- AfnemerID
- End Point waarop het afnemende systeem de data wil ontvangen
Hierin staat geregistreerd bij het afnemende systeem:
- LeverancierID
- End Point waarop de het aanleverend systeem de registratie wil ontvangen
1 Start Connection and Deliver Data
De client state is 'offline'. Het aanleverend systeem (Supplier) maakt kenbaar dat het klaar is voor levering door een openSession bericht te sturen naar het afnemend systeem.
sd 1.0 openSession
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | openingSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
</ex:dynamicInformation>
</stp:openSessionInput>
</soap:Body>
</soap:Envelope>
Dit zal het aanleverende systeem elke 10 minuten doen net zolang tot het afnemende systeem reageert of tot dit handmatig overruled wordt. Na handmatige overruling moet de aanvraag natuurlijk ook weer gestart worden.
Het afnemende systeem reageert op een van de drie volgende mogelijkheden:
- Succes Snapshot on openSession
- Succes Ack on openSession
- Fail on openSession
1.1 Succes Snapshot on openSession
In dit geval zal het afnemend systeem, wanneer het een Exchange openSession bericht ontvangt, een Exchange snapshotSynchronizationRequest bericht terugsturen, met daarin een Sessie ID, waarna het leverende systeem de client State naar 'online' zet.
sd 1.1.1 return snapshotSynchronizationRequest
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | openingSession |
| returnStatus | snapshotSynchronisationRequest |
| sessionID | Session ID, determined by client |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
Hierna wordt er door het leverende systeem een snapshot gegenereerd wat met een ExchangeInformation(payloadDelivery) naar de afnemende partij wordt gestuurd. De gegevens bevinden zich in een payload van het van toepassing zijnde type.
sd 1.1.2 payloadDelivery Snapshot
| Elementen binnen payload | |
|---|---|
| Alle relevante situaties | situation |
| Alle MST informatie | measurementSiteTablePublication |
| Alle minuut metingen | measuredDataPublication |
| Alle relevante VMS controllers | vmsControllerTable |
| Status van alle revante VMS controllers | vmsControllerStatus |
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| updateMethod | snapshot |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:updateMethod>snapshot</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putSnapshotDataInput>
</soap:Body>
</soap:Envelope>
Let op
Op de puntjes in bovenstaand voorbeeld is de invulling van de payload verschillend; afhankelijk of het om MSTP, MDP, SB, VMSCST of VMSCS gaat.
Het ontvangende systeem reageert met een 'ack'-bericht dat het snapshot correct is ontvangen.
sd 1.1.3 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | Online |
| returnStatus | Ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
Hierna gaat het leverende systeem uit de loop 'Supplier Status offline Open Session' en gaat deze naar het volgende sequence diagram 'Maintain Connection' (zie het volgende hoofdstuk).
1.2 Success Ack on openSession
sd 1.2.1 return Ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | Online |
| returnStatus | Ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
Hierna gaat het leverende systeem uit de loop 'Supplier Status offline Open Session' en gaat deze naar het volgende sequence diagram 'Maintain Connection' (zie het volgende hoofdstuk).
1.3 Fail on openSession
Wanneer het afnemend systeem een fail terugstuurt op de openSession of er helemaal geen antwoord komt, blijft het aanleverende systeem elke tien minuten proberen een verbinding op te zetten.
sd 1.3.1 return fail
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | openingSession |
| returnStatus | fail |
| returnStatusReason | optionele extra informatie |
| codedInvalidityReason | bv: other |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>optional extra reason information</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>other</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
2 Maintain Connection
De verbinding tussen het aanleverend systeem en het afnemend systeem zal worden onderhouden door het aanleverend systeem. Er zijn twee scenarios: - 'Data Ready for Payload Push' - 'no data keepAlive'
2.1 Data ready for payload push
Wanneer er binnen één minuut na het laatst verstuurde bericht een update op de data is, zal deze direct verstuurd worden door middel van een allElementUpdate bericht waarbij de data zich bevindt in een payload van het betreffende type.
sd 2.1.1 allElementUpdate
| Elementen binnen payload | |
|---|---|
| Alle geüpdatete situaties | situation |
| Alle geüpdatete Measurementsites | measurementSiteTablePublication |
| Alle gemeten informatie | measuredDataPublication |
| Alle geüpdatete VMS controllers | vmsControllerTable |
| geüpdatete status van alle VMS controllers | vmsControllerStatus |
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| operatingMode | onOccurence |
| updateMethod | allElementUpdate |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:operatingMode>onOccurrence</ex:operatingMode>
<ex:updateMethod>allElementUpdate</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putDataInput>
</soap:Body>
</soap:Envelope>
Let op
Op de puntjes in bovenstaand voorbeeld is de invulling van de payload verschillend; afhankelijk of het om MSTP, MDP, SB, VMSCST of VMSCS gaat.
sd 2.1.2 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>Exchange2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
2.2 No data keepAlive
Wanneer er één minuut na het versturen van het laatste bericht nog geen update op de data te versturen is, zal het aanleverende systeem een keep-alive bericht sturen. Dit zal het systeem elke minuut blijven doen totdat er een update op de data is en er een allElementUpdate verstuurd wordt (de vorige paragraaf).
sd 2.2.1 keepAlive
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveInput>
</soap:Body>
</soap:Envelope>
sd 2.2.2 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
3 CloseSession or Fail
Wanneer het ontvangende systeem de verbinding wil verbreken, dient deze een closeSessionRequest sturen als reactie op een pushbericht of een keepAlive-bericht. Het aanleverende systeem reageert dan met een closeSession bericht. Het ontvangende systeem reageert hetzelfde wanneer een bericht geweigerd wordt door het ontvangende systeem (fail).
Ook wanneer het ontvangende systeem voor een timeout zorgt bij het aanleverende systeem, zal het aanleverende systeem een closeSession sturen.
Het aanleverende systeem zal na bevestiging of timeout de sessie naar 'offline' zetten, zo wordt de verbinding inactief en zal er geen data meer verstuurd worden.
sd 3.1 return closeSessionRequest
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | Exchange 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | closingSession |
| returnStatus | closeSessionRequest |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld closeSessionRequest na putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld closeSessionRequest na putSnapshotDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld closeSessionRequest na keepAliveInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
sd 3.2 fail on push / keep alive: return fail
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | fail |
| returnStatusReason | Optionele toelichting |
| codedInvalidityReason | bv: invalidMessage |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld na putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>XSD validation error at: line 110</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>invalidMessage</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld na putSnapshotDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>XSD validation error at: line 110</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>invalidMessage</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
sd 3.3 closeSession
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| messageType | closeSession |
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | closingSession |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:closeSessionInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:closeSessionInput>
</soap:Body>
</soap:Envelope>
sd 3.4 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| messageType | return |
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | offline |
| returnStatus | ack |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:closeSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>offline</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:closeSessionOutput>
</soap:Body>
</soap:Envelope>
Snapshot Request
Wanneer een ontvangend systeem, om wat voor reden dan ook, een snapshot nodig heeft om de huidige situatie weer te weten, kan deze op elk bericht een return bericht sturen met een snapshotSynchronizationRequest. Het aanleverende systeem zal als gevolg van dit verzoek een snapshot genereren en daarna deze naar het ontvangende systeem sturen en daarna doorgaan met de 'maintain Connection'. Dit verzoek kan alleen plaats vinden wanneer de session op 'online' staat. Anders moet eerst de verbinding weer opgezet worden.
Let op
Als er binnen twee aanvragen geen snapshot is ontvangen zal de sessie worden gesloten door het afnemende systeem. Op deze manier zal er ook een snapshot synchronisatie worden geforceerd.
sd 4.1 return snapshotSynchronizationRequest
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | snapshotSynchronisationRequest |
XML Voorbeeld na keepAliveInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld na openSessionInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld na putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
Hierna wordt er door het leverende systeem een volledige snapshot gegenereerd dat samen met een ExchangeInformation(payloadDelivery) naar de afnemende partij wordt gestuurd. De gegevens bevinden zich in een payload van het betreffende type.
sd 4.2 payloadDelivery Snapshot
| Elementen binnen payload | |
|---|---|
| Alle relevante situaties | situation |
| Alle MST informatie | measurementSiteTablePublication |
| Alle minuut metingen | measuredDataPublication |
| Alle relevante VMS controllers | vmsControllerTable |
| Status van alle revante VMS controllers | vmsControllerStatus |
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| updateMethod | snapshot |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:updateMethod>snapshot</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putSnapshotDataInput>
</soap:Body>
</soap:Envelope>
Let op
Op de puntjes in bovenstaand voorbeeld is de invulling van de payload verschillend; afhankelijk of het om MSTP, MDP, SB, VMSCST of VMSCS gaat.
Het ontvangende systeem reageert met een 'ack'-bericht dat het snapshot correct is ontvangen.
InformationManagement
Het element elementReference in het onderdeel informationManagedResourceList van de InformationManagement sectie wordt gebruikt om de technische informatiestatus van een publicatietype te geven. Hieruit is vervolgens af te leiden of van het object waarnaar gerefeerd wordt nog een vervolg te verwachten is, of niet.
| Element | Type | Verplicht | Domein |
|---|---|---|---|
| elementReference | ElementReference | Ja | nvt |
| managementStatus | ManagementTypeEnum | Ja | cancelled, closed, dataChainIssue, outOfRange |
| reference | Reference | Ja | Beschrijft de referentie naar het betreffende object waarop de managementstatus van toepassing is. |
| d2ElementType | D2ElementTypeEnum | Ja | measurementSite, measurementSiteTable, situation, situationRecord, vmsController, vmsControllerTable |
| managementStatusChangeTime | DateTime | Ja | Beschrijft het tijdstip waarop de managementstatus is gewijzigd. |
InformationManagement Situatieberichten
Situaties en situatieonderdelen worden met behulp van het onderdeel InformationManagement technisch beëindigd (closed) of geannuleerd (cancelled). Dit geldt voor zowel de situaties zelf, als voor de onderliggende individuele situatieonderdelen. Naast deze technische beëindiging wordt op het moment dat een gebeurtenis in werkelijkheid is beëindigd, aanvullend op het informationManagement onderdeel ook de payload met de situatie en situatieonderdelen nogmaals wordt verstuurd. In deze payload update wordt ook de definitieve eindtijd van de gebeurtenis opgenomen in het validity-onderdeel overallEndTime. Deze update van de eindtijd wordt altijd vóór of tegelijk met het verstrekken van de technische eindtijd in informationManagement verstuurd. Nooit later.
De informatieverstrekking over een gebeurtenis die in werkelijkheid nog niet is beëindigd en waarvoor eerder een situatie/situatieonderdeel is uitgestuurd, kan worden opgeschort. Dit kan van toepassing zijn bij een dataketenissue (dataChainIssue), of wanneer de betreffende gebeurtenis niet langer aan de voorwaarden van publicatie voldoet (outOfRange). Als een van deze gevallen optreedt dan wordt dit met behulp van het InformationManagement onderdeel aangegeven, waarbij de reden van de opschorting wordt opgenomen het element ManagementStatus. In tegenstelling tot een daadwerkelijke technische beëindiging wordt in deze gevallen géén payload meegstuurd met een daadwerkelijke eindtijd in het validity-onderdeel overallEndTime. Zodra de werkelijke gebeurtenis definitief is beëindigd wordt de informatieverstrekking van de/het situatie/situatieonderdeel afgesloten op dezelfde wijze zoals in de vorige paragraaf beschreven.
Indien een opgeschorte gebeurtenis zoals in de vorige paragraaf beschreven weer relevant wordt voor publicatie, wordt de/het eerder gebruikte situatie/situatieonderdeel weer opgenomen in de publicatie met dezelfde id en een hogere versie.
de voorbeelden staan hier.
InformationManagement VMS
VMS-controller-tables en VMS-controllers worden met behulp van het onderdeel InformationManagement verwijderd. Dit geldt voor zowel de VMS-controller-table zelf, als voor de onderliggende individuele VMS-controllers.
de voorbeelden staan hier
InformationManagement MSTP
Hier wordt dezelfde logica gevolgd als die van VMS; MTPS en measurementsiterecords worden met behulp van het onderdeel InformationManagement verwijderdt. Dit geldt dus zowel voor de MSTP zelf, als voor de onderliggende records.
de voorbeelden voor MSTP en MDP staan hier
Ketentest
Het Exchange 2020 ketenprotocol beschrijft hoe een verbinding tot stand komt en dekt foutsituaties in de verbinding af, mits het protocol correct geïmplementeerd wordt.
Uitvoeren teststappen aansluiten leverancier
Het testscenario kent afzonderlijke teststappen die gericht zijn op het testen van geïsoleerde functionaliteiten. De eerste teststap binnen het testscenario is het sturen van een openSession bericht.
| Nummer | Tijdstip | Actie leverancier | record versie | Actie NDW | Veld exchangeStatus |
Veld returnStatus |
|---|---|---|---|---|---|---|
| 0 | Verstuur openSession |
Verifieer ontvangst openSession en automatische opening van nieuwe sessie. Response met nieuwe sessie en in het element sesssionId het nieuwe sessie ID |
openingSession |
snapshotSynchronisationRequest |
||
| 1 | Verstuur snapshot met ontvangen sessionID uit openSession response |
1 | Verifieer ontvangst snapshot en verwerking van payload. |
online |
ack |
|
| 2 | Verstuur allElementUpdate met ontvangen sessionID uit openSession response |
2 | Verifieer ontvangst allElementUpdate en verwerking van payload. |
online |
ack |
|
| 3 | Verstuur alleElementUpdate of keepAlive |
Insturen van snapshotSynchronizationRequest op ontvanger. Eerst volgende aanvraag geeft correcte response voor exchange status |
online |
snapshotSynchronisationRequest |
||
| 4 | Verstuur snapshot met ontvangen sessionID uit openSession response |
2 | Verifieer ontvangst snapshot en verwerking van payload. |
online |
ack |
|
| 5 | Doorlopen levenscyclus situation (start, updates, beëindiging) met 1 of meer records | ++ | Verifieer doorlopen alle stappen, inclusief versie verhoging, timestamps en afmeldingen | |||
| 6 | Verstuur allElementUpdate of keepAlive |
Insturen van closeSessionRequest op ontvanger en op eerst volgende aanvragen sessie sluiten. |
closingSession |
|||
| 7 | Openzetten nieuwe sessie en insturen van snapshot | 2 | Verifieer ontvangst openSession en openen van nieuwe sessie. Verifieer ontvangst snapshot en verwerking van snapshot |
|||
| 8 | Verstuur closeSession met ontvangen sessionID uit openSession response |
Verifieer ontvangst closeSesssion en sluit de sessie af. Teruggeven van exchangeStatus closingSession en returnStatus: ack |
closingSession |
ack |
||
| 9 | Verstuur openSession |
Verifieer ontvangst openSession en automatische opening van nieuwe sessie. Response met nieuwe sessie en in het element sesssionId het nieuwe sessie ID |
openingSession |
ack |
Storing verbinding
Het doel van deze teststap in het scenario is om storingen in de verbinding te simuleren en te verifiëren dat de leverancier weer data begint te leveren.
De eerste stap is testen van een storing aan de kant van de provider, de tweede test uitval van NDW.
Uitval leverancier
| Nummer | Tijdstip | Actie leverancier | record versie | Actie NDW | Veld exchangeStatus |
Veld returnStatus |
|---|---|---|---|---|---|---|
| 0 | Stopt sessie zonder versturen van closeSession |
Na 1 minuut word sessie afgemeld in ontvanger | offline |
fail |
||
| 1 | Herstel verbinding met openSession, stuur snapshot |
Verifieer openSession en ontvangst snapshot |
Uitval NDW
| Nummer | Tijdstip | Actie leverancier | record versie | Actie NDW | Veld exchangeStatus |
Veld returnStatus |
|---|---|---|---|---|---|---|
| 0 | - | Geforceerd session status aanpassen naar offline. | offline |
fail |
||
| 1 | Herstel verbinding met openSession, stuur snapshot na ontvangst van bericht met exchangeStatus offline |
Verifieer openSession en ontvangst snapshot |
Duurtest
In dit laatste deel moet de leverancier aantonen dat zijn datalevering stabiel is. Het systeem moet 24 uur lang data leveren aan het NDW. NDW beheer controleert na de 24 uur of er in die tijd onderbrekingen in de verbinding zijn geweest.
XML Example datachain issue
Ketenprotocol Datex-II V3
Vanaf DATEXII versie 3 wordt er in elke keten gewerkt met het Exchange 2020 Ketenprotocol WSDL. De beschrijving van de technische interface voor al onze datauitwissellingen wordt hieronder daarom in een generiek protocol beschreven. Dit protocol is bedoeld om een beschrijving te geven hoe systemen voor de uitwisseling van DATEX II v3.x met elkaar verbinden en data dienen uit te wisselen met payload van verschillende types. Zie de lijst hieronder voor voorbeelden van payloads van de verschillende types.
- SituationPublication
- MeasurementSiteTablePublication
- measuredDataPublication
- VmsTablePublication
- VmsPublication
Let op
MSI en DRIPS maken beiden gebruik van de VMSTP en de VMSP
Er wordt gebruikt gemaakt van het zogenaamde Stateful Push protocol. Ten opzichte van het Europese protocol wordt op dit moment alleen delta Synchronization Push niet ondersteund. In de onderstaande voorbeelden wordt er vanuit gegaan dat NDW de leverancier is. Wanneer NDW de ontvanger is, komt dus op de plaats van 'NLNDW' in het element 'nationalIdentifier' het 'ID van de leverancier' te staan.
Uitwisseling van gegevens geschiedt op basis van SOAP (versie 1.1) over HTTP (versie 1.1). Voor de beschreven methode geldt dat er gebruik gemaakt moet worden van compressie om de hoeveelheid data verkeer te beperken. Hiervoor dient de HTTP header “Accept-Encoding: gzip” gebruikt te worden.
Payload
De payload bevat het daadwerkelijke DATEX II bericht met de informatie betreffende het gekozen type.
Exchange Information
De exchangeInformation gaat over de uitwisseling tussen de Supplier en de Client. Met behulp van informationManagement kunnen er wijzigingen, beëindigingen of annuleringen worden beschreven. In de onderstaande paragrafen staan tabellen met verwijzingen als sd x.x.x. Dit verwijst zowel naar de onderdelen in de sequence diagrammen als naar de meegeleverde XML-voorbeelden.
Push Methode
Systemen binnen een keten hebben een interface beschikbaar om data te "pushen" naar een afnemende partij. Het systeem van deze partij moet gebouwd zijn om te werken met "Exchange 2020 Ketenprotocol WSDL".
WSDL-omschrijvingen zijn hier te vinden.
De push methode bevat een aantal onderdelen die hier onder beschreven worden. Het gaat om:
- Administratie
- Start Connection and Deliver Data
- Maintain Connection
- Close Connection or Fail
- Request Snapshot
- Weigeren van data
Administratie
Zowel de aanleverende (Supplier) als de afnemende (Client) partij houden een offline administratie bij. Hierin staat geregistreerd bij het aanleverend systeem:
- AfnemerID
- End Point waarop het afnemende systeem de data wil ontvangen
Hierin staat geregistreerd bij het afnemende systeem:
- LeverancierID
- End Point waarop de het aanleverend systeem de registratie wil ontvangen
1 Start Connection and Deliver Data
De client state is 'offline'. Het aanleverend systeem (Supplier) maakt kenbaar dat het klaar is voor levering door een openSession bericht te sturen naar het afnemend systeem.
sd 1.0 openSession
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | openingSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
</ex:dynamicInformation>
</stp:openSessionInput>
</soap:Body>
</soap:Envelope>
Dit zal het aanleverende systeem elke 10 minuten doen net zolang tot het afnemende systeem reageert of tot dit handmatig overruled wordt. Na handmatige overruling moet de aanvraag natuurlijk ook weer gestart worden.
Het afnemende systeem reageert op een van de drie volgende mogelijkheden:
- Succes Snapshot on openSession
- Succes Ack on openSession
- Fail on openSession
1.1 Succes Snapshot on openSession
In dit geval zal het afnemend systeem, wanneer het een Exchange openSession bericht ontvangt, een Exchange snapshotSynchronizationRequest bericht terugsturen, met daarin een Sessie ID, waarna het leverende systeem de client State naar 'online' zet.
sd 1.1.1 return snapshotSynchronizationRequest
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | openingSession |
| returnStatus | snapshotSynchronisationRequest |
| sessionID | Session ID, determined by client |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
Hierna wordt er door het leverende systeem een snapshot gegenereerd wat met een ExchangeInformation(payloadDelivery) naar de afnemende partij wordt gestuurd. De gegevens bevinden zich in een payload van het van toepassing zijnde type.
sd 1.1.2 payloadDelivery Snapshot
| Elementen binnen payload | |
|---|---|
| Alle relevante situaties | situation |
| Alle MST informatie | measurementSiteTablePublication |
| Alle minuut metingen | measuredDataPublication |
| Alle relevante VMS controllers | vmsControllerTable |
| Status van alle revante VMS controllers | vmsControllerStatus |
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| updateMethod | snapshot |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:updateMethod>snapshot</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putSnapshotDataInput>
</soap:Body>
</soap:Envelope>
Let op
Op de puntjes in bovenstaand voorbeeld is de invulling van de payload verschillend; afhankelijk of het om MSTP, MDP, SB, VMSCST of VMSCS gaat.
Het ontvangende systeem reageert met een 'ack'-bericht dat het snapshot correct is ontvangen.
sd 1.1.3 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | Online |
| returnStatus | Ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
Hierna gaat het leverende systeem uit de loop 'Supplier Status offline Open Session' en gaat deze naar het volgende sequence diagram 'Maintain Connection' (zie het volgende hoofdstuk).
1.2 Success Ack on openSession
sd 1.2.1 return Ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | Online |
| returnStatus | Ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
Hierna gaat het leverende systeem uit de loop 'Supplier Status offline Open Session' en gaat deze naar het volgende sequence diagram 'Maintain Connection' (zie het volgende hoofdstuk).
1.3 Fail on openSession
Wanneer het afnemend systeem een fail terugstuurt op de openSession of er helemaal geen antwoord komt, blijft het aanleverende systeem elke tien minuten proberen een verbinding op te zetten.
sd 1.3.1 return fail
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | openingSession |
| returnStatus | fail |
| returnStatusReason | optionele extra informatie |
| codedInvalidityReason | bv: other |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>optional extra reason information</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>other</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
2 Maintain Connection
De verbinding tussen het aanleverend systeem en het afnemend systeem zal worden onderhouden door het aanleverend systeem. Er zijn twee scenarios: - 'Data Ready for Payload Push' - 'no data keepAlive'
2.1 Data ready for payload push
Wanneer er binnen één minuut na het laatst verstuurde bericht een update op de data is, zal deze direct verstuurd worden door middel van een allElementUpdate bericht waarbij de data zich bevindt in een payload van het betreffende type.
sd 2.1.1 allElementUpdate
| Elementen binnen payload | |
|---|---|
| Alle geüpdatete situaties | situation |
| Alle geüpdatete Measurementsites | measurementSiteTablePublication |
| Alle gemeten informatie | measuredDataPublication |
| Alle geüpdatete VMS controllers | vmsControllerTable |
| geüpdatete status van alle VMS controllers | vmsControllerStatus |
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| operatingMode | onOccurence |
| updateMethod | allElementUpdate |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:operatingMode>onOccurrence</ex:operatingMode>
<ex:updateMethod>allElementUpdate</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putDataInput>
</soap:Body>
</soap:Envelope>
Let op
Op de puntjes in bovenstaand voorbeeld is de invulling van de payload verschillend; afhankelijk of het om MSTP, MDP, SB, VMSCST of VMSCS gaat.
sd 2.1.2 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>Exchange2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
2.2 No data keepAlive
Wanneer er één minuut na het versturen van het laatste bericht nog geen update op de data te versturen is, zal het aanleverende systeem een keep-alive bericht sturen. Dit zal het systeem elke minuut blijven doen totdat er een update op de data is en er een allElementUpdate verstuurd wordt (de vorige paragraaf).
sd 2.2.1 keepAlive
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveInput>
</soap:Body>
</soap:Envelope>
sd 2.2.2 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
3 CloseSession or Fail
Wanneer het ontvangende systeem de verbinding wil verbreken, dient deze een closeSessionRequest sturen als reactie op een pushbericht of een keepAlive-bericht. Het aanleverende systeem reageert dan met een closeSession bericht. Het ontvangende systeem reageert hetzelfde wanneer een bericht geweigerd wordt door het ontvangende systeem (fail).
Ook wanneer het ontvangende systeem voor een timeout zorgt bij het aanleverende systeem, zal het aanleverende systeem een closeSession sturen.
Het aanleverende systeem zal na bevestiging of timeout de sessie naar 'offline' zetten, zo wordt de verbinding inactief en zal er geen data meer verstuurd worden.
sd 3.1 return closeSessionRequest
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | Exchange 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | closingSession |
| returnStatus | closeSessionRequest |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld closeSessionRequest na putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld closeSessionRequest na putSnapshotDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld closeSessionRequest na keepAliveInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
sd 3.2 fail on push / keep alive: return fail
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | fail |
| returnStatusReason | Optionele toelichting |
| codedInvalidityReason | bv: invalidMessage |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld na putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>XSD validation error at: line 110</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>invalidMessage</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld na putSnapshotDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>XSD validation error at: line 110</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>invalidMessage</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
sd 3.3 closeSession
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| messageType | closeSession |
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | closingSession |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:closeSessionInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:closeSessionInput>
</soap:Body>
</soap:Envelope>
sd 3.4 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| messageType | return |
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | offline |
| returnStatus | ack |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:closeSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>offline</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:closeSessionOutput>
</soap:Body>
</soap:Envelope>
Snapshot Request
Wanneer een ontvangend systeem, om wat voor reden dan ook, een snapshot nodig heeft om de huidige situatie weer te weten, kan deze op elk bericht een return bericht sturen met een snapshotSynchronizationRequest. Het aanleverende systeem zal als gevolg van dit verzoek een snapshot genereren en daarna deze naar het ontvangende systeem sturen en daarna doorgaan met de 'maintain Connection'. Dit verzoek kan alleen plaats vinden wanneer de session op 'online' staat. Anders moet eerst de verbinding weer opgezet worden.
Let op
Als er binnen twee aanvragen geen snapshot is ontvangen zal de sessie worden gesloten door het afnemende systeem. Op deze manier zal er ook een snapshot synchronisatie worden geforceerd.
sd 4.1 return snapshotSynchronizationRequest
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | snapshotSynchronisationRequest |
XML Voorbeeld na keepAliveInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld na openSessionInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld na putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
Hierna wordt er door het leverende systeem een volledige snapshot gegenereerd dat samen met een ExchangeInformation(payloadDelivery) naar de afnemende partij wordt gestuurd. De gegevens bevinden zich in een payload van het betreffende type.
sd 4.2 payloadDelivery Snapshot
| Elementen binnen payload | |
|---|---|
| Alle relevante situaties | situation |
| Alle MST informatie | measurementSiteTablePublication |
| Alle minuut metingen | measuredDataPublication |
| Alle relevante VMS controllers | vmsControllerTable |
| Status van alle revante VMS controllers | vmsControllerStatus |
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| updateMethod | snapshot |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:updateMethod>snapshot</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putSnapshotDataInput>
</soap:Body>
</soap:Envelope>
Let op
Op de puntjes in bovenstaand voorbeeld is de invulling van de payload verschillend; afhankelijk of het om MSTP, MDP, SB, VMSCST of VMSCS gaat.
Het ontvangende systeem reageert met een 'ack'-bericht dat het snapshot correct is ontvangen.
InformationManagement
Het element elementReference in het onderdeel informationManagedResourceList van de InformationManagement sectie wordt gebruikt om de technische informatiestatus van een publicatietype te geven. Hieruit is vervolgens af te leiden of van het object waarnaar gerefeerd wordt nog een vervolg te verwachten is, of niet.
| Element | Type | Verplicht | Domein |
|---|---|---|---|
| elementReference | ElementReference | Ja | nvt |
| managementStatus | ManagementTypeEnum | Ja | cancelled, closed, dataChainIssue, outOfRange |
| reference | Reference | Ja | Beschrijft de referentie naar het betreffende object waarop de managementstatus van toepassing is. |
| d2ElementType | D2ElementTypeEnum | Ja | measurementSite, measurementSiteTable, situation, situationRecord, vmsController, vmsControllerTable |
| managementStatusChangeTime | DateTime | Ja | Beschrijft het tijdstip waarop de managementstatus is gewijzigd. |
InformationManagement Situatieberichten
Situaties en situatieonderdelen worden met behulp van het onderdeel InformationManagement technisch beëindigd (closed) of geannuleerd (cancelled). Dit geldt voor zowel de situaties zelf, als voor de onderliggende individuele situatieonderdelen. Naast deze technische beëindiging wordt op het moment dat een gebeurtenis in werkelijkheid is beëindigd, aanvullend op het informationManagement onderdeel ook de payload met de situatie en situatieonderdelen nogmaals wordt verstuurd. In deze payload update wordt ook de definitieve eindtijd van de gebeurtenis opgenomen in het validity-onderdeel overallEndTime. Deze update van de eindtijd wordt altijd vóór of tegelijk met het verstrekken van de technische eindtijd in informationManagement verstuurd. Nooit later.
De informatieverstrekking over een gebeurtenis die in werkelijkheid nog niet is beëindigd en waarvoor eerder een situatie/situatieonderdeel is uitgestuurd, kan worden opgeschort. Dit kan van toepassing zijn bij een dataketenissue (dataChainIssue), of wanneer de betreffende gebeurtenis niet langer aan de voorwaarden van publicatie voldoet (outOfRange). Als een van deze gevallen optreedt dan wordt dit met behulp van het InformationManagement onderdeel aangegeven, waarbij de reden van de opschorting wordt opgenomen het element ManagementStatus. In tegenstelling tot een daadwerkelijke technische beëindiging wordt in deze gevallen géén payload meegstuurd met een daadwerkelijke eindtijd in het validity-onderdeel overallEndTime. Zodra de werkelijke gebeurtenis definitief is beëindigd wordt de informatieverstrekking van de/het situatie/situatieonderdeel afgesloten op dezelfde wijze zoals in de vorige paragraaf beschreven.
Indien een opgeschorte gebeurtenis zoals in de vorige paragraaf beschreven weer relevant wordt voor publicatie, wordt de/het eerder gebruikte situatie/situatieonderdeel weer opgenomen in de publicatie met dezelfde id en een hogere versie.
de voorbeelden staan hier.
InformationManagement VMS
VMS-controller-tables en VMS-controllers worden met behulp van het onderdeel InformationManagement verwijderd. Dit geldt voor zowel de VMS-controller-table zelf, als voor de onderliggende individuele VMS-controllers.
de voorbeelden staan hier
InformationManagement MSTP
Hier wordt dezelfde logica gevolgd als die van VMS; MTPS en measurementsiterecords worden met behulp van het onderdeel InformationManagement verwijderdt. Dit geldt dus zowel voor de MSTP zelf, als voor de onderliggende records.
de voorbeelden voor MSTP en MDP staan hier
Ketentest
Het Exchange 2020 ketenprotocol beschrijft hoe een verbinding tot stand komt en dekt foutsituaties in de verbinding af, mits het protocol correct geïmplementeerd wordt.
Uitvoeren teststappen aansluiten leverancier
Het testscenario kent afzonderlijke teststappen die gericht zijn op het testen van geïsoleerde functionaliteiten. De eerste teststap binnen het testscenario is het sturen van een openSession bericht.
| Nummer | Tijdstip | Actie leverancier | record versie | Actie NDW | Veld exchangeStatus |
Veld returnStatus |
|---|---|---|---|---|---|---|
| 0 | Verstuur openSession |
Verifieer ontvangst openSession en automatische opening van nieuwe sessie. Response met nieuwe sessie en in het element sesssionId het nieuwe sessie ID |
openingSession |
snapshotSynchronisationRequest |
||
| 1 | Verstuur snapshot met ontvangen sessionID uit openSession response |
1 | Verifieer ontvangst snapshot en verwerking van payload. |
online |
ack |
|
| 2 | Verstuur allElementUpdate met ontvangen sessionID uit openSession response |
2 | Verifieer ontvangst allElementUpdate en verwerking van payload. |
online |
ack |
|
| 3 | Verstuur alleElementUpdate of keepAlive |
Insturen van snapshotSynchronizationRequest op ontvanger. Eerst volgende aanvraag geeft correcte response voor exchange status |
online |
snapshotSynchronisationRequest |
||
| 4 | Verstuur snapshot met ontvangen sessionID uit openSession response |
2 | Verifieer ontvangst snapshot en verwerking van payload. |
online |
ack |
|
| 5 | Doorlopen levenscyclus situation (start, updates, beëindiging) met 1 of meer records | ++ | Verifieer doorlopen alle stappen, inclusief versie verhoging, timestamps en afmeldingen | |||
| 6 | Verstuur allElementUpdate of keepAlive |
Insturen van closeSessionRequest op ontvanger en op eerst volgende aanvragen sessie sluiten. |
closingSession |
|||
| 7 | Openzetten nieuwe sessie en insturen van snapshot | 2 | Verifieer ontvangst openSession en openen van nieuwe sessie. Verifieer ontvangst snapshot en verwerking van snapshot |
|||
| 8 | Verstuur closeSession met ontvangen sessionID uit openSession response |
Verifieer ontvangst closeSesssion en sluit de sessie af. Teruggeven van exchangeStatus closingSession en returnStatus: ack |
closingSession |
ack |
||
| 9 | Verstuur openSession |
Verifieer ontvangst openSession en automatische opening van nieuwe sessie. Response met nieuwe sessie en in het element sesssionId het nieuwe sessie ID |
openingSession |
ack |
Storing verbinding
Het doel van deze teststap in het scenario is om storingen in de verbinding te simuleren en te verifiëren dat de leverancier weer data begint te leveren.
De eerste stap is testen van een storing aan de kant van de provider, de tweede test uitval van NDW.
Uitval leverancier
| Nummer | Tijdstip | Actie leverancier | record versie | Actie NDW | Veld exchangeStatus |
Veld returnStatus |
|---|---|---|---|---|---|---|
| 0 | Stopt sessie zonder versturen van closeSession |
Na 1 minuut word sessie afgemeld in ontvanger | offline |
fail |
||
| 1 | Herstel verbinding met openSession, stuur snapshot |
Verifieer openSession en ontvangst snapshot |
Uitval NDW
| Nummer | Tijdstip | Actie leverancier | record versie | Actie NDW | Veld exchangeStatus |
Veld returnStatus |
|---|---|---|---|---|---|---|
| 0 | - | Geforceerd session status aanpassen naar offline. | offline |
fail |
||
| 1 | Herstel verbinding met openSession, stuur snapshot na ontvangst van bericht met exchangeStatus offline |
Verifieer openSession en ontvangst snapshot |
Duurtest
In dit laatste deel moet de leverancier aantonen dat zijn datalevering stabiel is. Het systeem moet 24 uur lang data leveren aan het NDW. NDW beheer controleert na de 24 uur of er in die tijd onderbrekingen in de verbinding zijn geweest.
XML Example out of range
Ketenprotocol Datex-II V3
Vanaf DATEXII versie 3 wordt er in elke keten gewerkt met het Exchange 2020 Ketenprotocol WSDL. De beschrijving van de technische interface voor al onze datauitwissellingen wordt hieronder daarom in een generiek protocol beschreven. Dit protocol is bedoeld om een beschrijving te geven hoe systemen voor de uitwisseling van DATEX II v3.x met elkaar verbinden en data dienen uit te wisselen met payload van verschillende types. Zie de lijst hieronder voor voorbeelden van payloads van de verschillende types.
- SituationPublication
- MeasurementSiteTablePublication
- measuredDataPublication
- VmsTablePublication
- VmsPublication
Let op
MSI en DRIPS maken beiden gebruik van de VMSTP en de VMSP
Er wordt gebruikt gemaakt van het zogenaamde Stateful Push protocol. Ten opzichte van het Europese protocol wordt op dit moment alleen delta Synchronization Push niet ondersteund. In de onderstaande voorbeelden wordt er vanuit gegaan dat NDW de leverancier is. Wanneer NDW de ontvanger is, komt dus op de plaats van 'NLNDW' in het element 'nationalIdentifier' het 'ID van de leverancier' te staan.
Uitwisseling van gegevens geschiedt op basis van SOAP (versie 1.1) over HTTP (versie 1.1). Voor de beschreven methode geldt dat er gebruik gemaakt moet worden van compressie om de hoeveelheid data verkeer te beperken. Hiervoor dient de HTTP header “Accept-Encoding: gzip” gebruikt te worden.
Payload
De payload bevat het daadwerkelijke DATEX II bericht met de informatie betreffende het gekozen type.
Exchange Information
De exchangeInformation gaat over de uitwisseling tussen de Supplier en de Client. Met behulp van informationManagement kunnen er wijzigingen, beëindigingen of annuleringen worden beschreven. In de onderstaande paragrafen staan tabellen met verwijzingen als sd x.x.x. Dit verwijst zowel naar de onderdelen in de sequence diagrammen als naar de meegeleverde XML-voorbeelden.
Push Methode
Systemen binnen een keten hebben een interface beschikbaar om data te "pushen" naar een afnemende partij. Het systeem van deze partij moet gebouwd zijn om te werken met "Exchange 2020 Ketenprotocol WSDL".
WSDL-omschrijvingen zijn hier te vinden.
De push methode bevat een aantal onderdelen die hier onder beschreven worden. Het gaat om:
- Administratie
- Start Connection and Deliver Data
- Maintain Connection
- Close Connection or Fail
- Request Snapshot
- Weigeren van data
Administratie
Zowel de aanleverende (Supplier) als de afnemende (Client) partij houden een offline administratie bij. Hierin staat geregistreerd bij het aanleverend systeem:
- AfnemerID
- End Point waarop het afnemende systeem de data wil ontvangen
Hierin staat geregistreerd bij het afnemende systeem:
- LeverancierID
- End Point waarop de het aanleverend systeem de registratie wil ontvangen
1 Start Connection and Deliver Data
De client state is 'offline'. Het aanleverend systeem (Supplier) maakt kenbaar dat het klaar is voor levering door een openSession bericht te sturen naar het afnemend systeem.
sd 1.0 openSession
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | openingSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
</ex:dynamicInformation>
</stp:openSessionInput>
</soap:Body>
</soap:Envelope>
Dit zal het aanleverende systeem elke 10 minuten doen net zolang tot het afnemende systeem reageert of tot dit handmatig overruled wordt. Na handmatige overruling moet de aanvraag natuurlijk ook weer gestart worden.
Het afnemende systeem reageert op een van de drie volgende mogelijkheden:
- Succes Snapshot on openSession
- Succes Ack on openSession
- Fail on openSession
1.1 Succes Snapshot on openSession
In dit geval zal het afnemend systeem, wanneer het een Exchange openSession bericht ontvangt, een Exchange snapshotSynchronizationRequest bericht terugsturen, met daarin een Sessie ID, waarna het leverende systeem de client State naar 'online' zet.
sd 1.1.1 return snapshotSynchronizationRequest
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | openingSession |
| returnStatus | snapshotSynchronisationRequest |
| sessionID | Session ID, determined by client |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
Hierna wordt er door het leverende systeem een snapshot gegenereerd wat met een ExchangeInformation(payloadDelivery) naar de afnemende partij wordt gestuurd. De gegevens bevinden zich in een payload van het van toepassing zijnde type.
sd 1.1.2 payloadDelivery Snapshot
| Elementen binnen payload | |
|---|---|
| Alle relevante situaties | situation |
| Alle MST informatie | measurementSiteTablePublication |
| Alle minuut metingen | measuredDataPublication |
| Alle relevante VMS controllers | vmsControllerTable |
| Status van alle revante VMS controllers | vmsControllerStatus |
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| updateMethod | snapshot |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:updateMethod>snapshot</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putSnapshotDataInput>
</soap:Body>
</soap:Envelope>
Let op
Op de puntjes in bovenstaand voorbeeld is de invulling van de payload verschillend; afhankelijk of het om MSTP, MDP, SB, VMSCST of VMSCS gaat.
Het ontvangende systeem reageert met een 'ack'-bericht dat het snapshot correct is ontvangen.
sd 1.1.3 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | Online |
| returnStatus | Ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
Hierna gaat het leverende systeem uit de loop 'Supplier Status offline Open Session' en gaat deze naar het volgende sequence diagram 'Maintain Connection' (zie het volgende hoofdstuk).
1.2 Success Ack on openSession
sd 1.2.1 return Ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | Online |
| returnStatus | Ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
Hierna gaat het leverende systeem uit de loop 'Supplier Status offline Open Session' en gaat deze naar het volgende sequence diagram 'Maintain Connection' (zie het volgende hoofdstuk).
1.3 Fail on openSession
Wanneer het afnemend systeem een fail terugstuurt op de openSession of er helemaal geen antwoord komt, blijft het aanleverende systeem elke tien minuten proberen een verbinding op te zetten.
sd 1.3.1 return fail
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | openingSession |
| returnStatus | fail |
| returnStatusReason | optionele extra informatie |
| codedInvalidityReason | bv: other |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>openingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>optional extra reason information</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>other</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
2 Maintain Connection
De verbinding tussen het aanleverend systeem en het afnemend systeem zal worden onderhouden door het aanleverend systeem. Er zijn twee scenarios: - 'Data Ready for Payload Push' - 'no data keepAlive'
2.1 Data ready for payload push
Wanneer er binnen één minuut na het laatst verstuurde bericht een update op de data is, zal deze direct verstuurd worden door middel van een allElementUpdate bericht waarbij de data zich bevindt in een payload van het betreffende type.
sd 2.1.1 allElementUpdate
| Elementen binnen payload | |
|---|---|
| Alle geüpdatete situaties | situation |
| Alle geüpdatete Measurementsites | measurementSiteTablePublication |
| Alle gemeten informatie | measuredDataPublication |
| Alle geüpdatete VMS controllers | vmsControllerTable |
| geüpdatete status van alle VMS controllers | vmsControllerStatus |
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| operatingMode | onOccurence |
| updateMethod | allElementUpdate |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:operatingMode>onOccurrence</ex:operatingMode>
<ex:updateMethod>allElementUpdate</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putDataInput>
</soap:Body>
</soap:Envelope>
Let op
Op de puntjes in bovenstaand voorbeeld is de invulling van de payload verschillend; afhankelijk of het om MSTP, MDP, SB, VMSCST of VMSCS gaat.
sd 2.1.2 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>Exchange2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
2.2 No data keepAlive
Wanneer er één minuut na het versturen van het laatste bericht nog geen update op de data te versturen is, zal het aanleverende systeem een keep-alive bericht sturen. Dit zal het systeem elke minuut blijven doen totdat er een update op de data is en er een allElementUpdate verstuurd wordt (de vorige paragraaf).
sd 2.2.1 keepAlive
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveInput>
</soap:Body>
</soap:Envelope>
sd 2.2.2 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | ack |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
3 CloseSession or Fail
Wanneer het ontvangende systeem de verbinding wil verbreken, dient deze een closeSessionRequest sturen als reactie op een pushbericht of een keepAlive-bericht. Het aanleverende systeem reageert dan met een closeSession bericht. Het ontvangende systeem reageert hetzelfde wanneer een bericht geweigerd wordt door het ontvangende systeem (fail).
Ook wanneer het ontvangende systeem voor een timeout zorgt bij het aanleverende systeem, zal het aanleverende systeem een closeSession sturen.
Het aanleverende systeem zal na bevestiging of timeout de sessie naar 'offline' zetten, zo wordt de verbinding inactief en zal er geen data meer verstuurd worden.
sd 3.1 return closeSessionRequest
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | Exchange 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | closingSession |
| returnStatus | closeSessionRequest |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld closeSessionRequest na putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld closeSessionRequest na putSnapshotDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld closeSessionRequest na keepAliveInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>closeSessionRequest</ex:returnStatus>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
sd 3.2 fail on push / keep alive: return fail
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | fail |
| returnStatusReason | Optionele toelichting |
| codedInvalidityReason | bv: invalidMessage |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld na putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>XSD validation error at: line 110</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>invalidMessage</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld na putSnapshotDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>fail</ex:returnStatus>
<ex:returnStatusReason>
<com:values>
<com:value>XSD validation error at: line 110</com:value>
</com:values>
</ex:returnStatusReason>
<ex:codedInvalidityReason>invalidMessage</ex:codedInvalidityReason>
</ex:returnInformation>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:putSnapshotDataOutput>
</soap:Body>
</soap:Envelope>
sd 3.3 closeSession
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| messageType | closeSession |
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | closingSession |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:closeSessionInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>closingSession</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-04T10:06:11.308965Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</stp:closeSessionInput>
</soap:Body>
</soap:Envelope>
sd 3.4 return ack
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| messageType | return |
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | offline |
| returnStatus | ack |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:closeSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>offline</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>ack</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:closeSessionOutput>
</soap:Body>
</soap:Envelope>
Snapshot Request
Wanneer een ontvangend systeem, om wat voor reden dan ook, een snapshot nodig heeft om de huidige situatie weer te weten, kan deze op elk bericht een return bericht sturen met een snapshotSynchronizationRequest. Het aanleverende systeem zal als gevolg van dit verzoek een snapshot genereren en daarna deze naar het ontvangende systeem sturen en daarna doorgaan met de 'maintain Connection'. Dit verzoek kan alleen plaats vinden wanneer de session op 'online' staat. Anders moet eerst de verbinding weer opgezet worden.
Let op
Als er binnen twee aanvragen geen snapshot is ontvangen zal de sessie worden gesloten door het afnemende systeem. Op deze manier zal er ook een snapshot synchronisatie worden geforceerd.
sd 4.1 return snapshotSynchronizationRequest
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| exchangeStatus | online |
| returnStatus | snapshotSynchronisationRequest |
XML Voorbeeld na keepAliveInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:keepAliveOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:keepAliveOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld na openSessionInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:openSessionOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:openSessionOutput>
</soap:Body>
</soap:Envelope>
XML Voorbeeld na putDataInput
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putDataOutput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
xmlns:com="http://datex2.eu/schema/3/common"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-03-17T19:56:16.266+01:00</ex:messageGenerationTimestamp>
<ex:returnInformation>
<ex:returnStatus>snapshotSynchronisationRequest</ex:returnStatus>
</ex:returnInformation>
</ex:dynamicInformation>
</stp:putDataOutput>
</soap:Body>
</soap:Envelope>
Hierna wordt er door het leverende systeem een volledige snapshot gegenereerd dat samen met een ExchangeInformation(payloadDelivery) naar de afnemende partij wordt gestuurd. De gegevens bevinden zich in een payload van het betreffende type.
sd 4.2 payloadDelivery Snapshot
| Elementen binnen payload | |
|---|---|
| Alle relevante situaties | situation |
| Alle MST informatie | measurementSiteTablePublication |
| Alle minuut metingen | measuredDataPublication |
| Alle relevante VMS controllers | vmsControllerTable |
| Status van alle revante VMS controllers | vmsControllerStatus |
| Elementen binnen exchangeInformation | Waarde |
|---|---|
| codedExchangeProtocol | statefulPush |
| exchangeSpecificationVersion | 2020 |
| supplierOrCisRequester internationalIdentifier | Land, en ID van leverancier |
| updateMethod | snapshot |
| exchangeStatus | online |
| sessionID | Session ID, previously obtained with OpenSession |
XML Voorbeeld
<?xml version='1.0' encoding='UTF-8'?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<stp:putSnapshotDataInput xmlns:stp="http://datex2.eu/wsdl/statefulPush/2020"
xmlns:mes="http://datex2.eu/schema/3/messageContainer"
modelBaseVersion="3">
<mes:payload xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:com="http://datex2.eu/schema/3/common"
xmlns:loc="http://datex2.eu/schema/3/location"
...
lang="nl" modelBaseVersion="3">
...
</mes:payload>
<mes:exchangeInformation xmlns:ex="http://datex2.eu/schema/3/exchangeInformation"
modelBaseVersion="3">
<ex:exchangeContext>
<ex:codedExchangeProtocol>statefulPush</ex:codedExchangeProtocol>
<ex:exchangeSpecificationVersion>2020</ex:exchangeSpecificationVersion>
<ex:updateMethod>snapshot</ex:updateMethod>
<ex:supplierOrCisRequester>
<ex:internationalIdentifier>
<com:country>NL</com:country>
<com:nationalIdentifier>NLNDW</com:nationalIdentifier>
</ex:internationalIdentifier>
</ex:supplierOrCisRequester>
</ex:exchangeContext>
<ex:dynamicInformation>
<ex:exchangeStatus>online</ex:exchangeStatus>
<ex:messageGenerationTimestamp>2021-08-11T07:56:57.374114Z</ex:messageGenerationTimestamp>
<ex:sessionInformation>
<ex:sessionID>7892634986</ex:sessionID>
</ex:sessionInformation>
</ex:dynamicInformation>
</mes:exchangeInformation>
</stp:putSnapshotDataInput>
</soap:Body>
</soap:Envelope>
Let op
Op de puntjes in bovenstaand voorbeeld is de invulling van de payload verschillend; afhankelijk of het om MSTP, MDP, SB, VMSCST of VMSCS gaat.
Het ontvangende systeem reageert met een 'ack'-bericht dat het snapshot correct is ontvangen.
InformationManagement
Het element elementReference in het onderdeel informationManagedResourceList van de InformationManagement sectie wordt gebruikt om de technische informatiestatus van een publicatietype te geven. Hieruit is vervolgens af te leiden of van het object waarnaar gerefeerd wordt nog een vervolg te verwachten is, of niet.
| Element | Type | Verplicht | Domein |
|---|---|---|---|
| elementReference | ElementReference | Ja | nvt |
| managementStatus | ManagementTypeEnum | Ja | cancelled, closed, dataChainIssue, outOfRange |
| reference | Reference | Ja | Beschrijft de referentie naar het betreffende object waarop de managementstatus van toepassing is. |
| d2ElementType | D2ElementTypeEnum | Ja | measurementSite, measurementSiteTable, situation, situationRecord, vmsController, vmsControllerTable |
| managementStatusChangeTime | DateTime | Ja | Beschrijft het tijdstip waarop de managementstatus is gewijzigd. |
InformationManagement Situatieberichten
Situaties en situatieonderdelen worden met behulp van het onderdeel InformationManagement technisch beëindigd (closed) of geannuleerd (cancelled). Dit geldt voor zowel de situaties zelf, als voor de onderliggende individuele situatieonderdelen. Naast deze technische beëindiging wordt op het moment dat een gebeurtenis in werkelijkheid is beëindigd, aanvullend op het informationManagement onderdeel ook de payload met de situatie en situatieonderdelen nogmaals wordt verstuurd. In deze payload update wordt ook de definitieve eindtijd van de gebeurtenis opgenomen in het validity-onderdeel overallEndTime. Deze update van de eindtijd wordt altijd vóór of tegelijk met het verstrekken van de technische eindtijd in informationManagement verstuurd. Nooit later.
De informatieverstrekking over een gebeurtenis die in werkelijkheid nog niet is beëindigd en waarvoor eerder een situatie/situatieonderdeel is uitgestuurd, kan worden opgeschort. Dit kan van toepassing zijn bij een dataketenissue (dataChainIssue), of wanneer de betreffende gebeurtenis niet langer aan de voorwaarden van publicatie voldoet (outOfRange). Als een van deze gevallen optreedt dan wordt dit met behulp van het InformationManagement onderdeel aangegeven, waarbij de reden van de opschorting wordt opgenomen het element ManagementStatus. In tegenstelling tot een daadwerkelijke technische beëindiging wordt in deze gevallen géén payload meegstuurd met een daadwerkelijke eindtijd in het validity-onderdeel overallEndTime. Zodra de werkelijke gebeurtenis definitief is beëindigd wordt de informatieverstrekking van de/het situatie/situatieonderdeel afgesloten op dezelfde wijze zoals in de vorige paragraaf beschreven.
Indien een opgeschorte gebeurtenis zoals in de vorige paragraaf beschreven weer relevant wordt voor publicatie, wordt de/het eerder gebruikte situatie/situatieonderdeel weer opgenomen in de publicatie met dezelfde id en een hogere versie.
de voorbeelden staan hier.
InformationManagement VMS
VMS-controller-tables en VMS-controllers worden met behulp van het onderdeel InformationManagement verwijderd. Dit geldt voor zowel de VMS-controller-table zelf, als voor de onderliggende individuele VMS-controllers.
de voorbeelden staan hier
InformationManagement MSTP
Hier wordt dezelfde logica gevolgd als die van VMS; MTPS en measurementsiterecords worden met behulp van het onderdeel InformationManagement verwijderdt. Dit geldt dus zowel voor de MSTP zelf, als voor de onderliggende records.
de voorbeelden voor MSTP en MDP staan hier
Ketentest
Het Exchange 2020 ketenprotocol beschrijft hoe een verbinding tot stand komt en dekt foutsituaties in de verbinding af, mits het protocol correct geïmplementeerd wordt.
Uitvoeren teststappen aansluiten leverancier
Het testscenario kent afzonderlijke teststappen die gericht zijn op het testen van geïsoleerde functionaliteiten. De eerste teststap binnen het testscenario is het sturen van een openSession bericht.
| Nummer | Tijdstip | Actie leverancier | record versie | Actie NDW | Veld exchangeStatus |
Veld returnStatus |
|---|---|---|---|---|---|---|
| 0 | Verstuur openSession |
Verifieer ontvangst openSession en automatische opening van nieuwe sessie. Response met nieuwe sessie en in het element sesssionId het nieuwe sessie ID |
openingSession |
snapshotSynchronisationRequest |
||
| 1 | Verstuur snapshot met ontvangen sessionID uit openSession response |
1 | Verifieer ontvangst snapshot en verwerking van payload. |
online |
ack |
|
| 2 | Verstuur allElementUpdate met ontvangen sessionID uit openSession response |
2 | Verifieer ontvangst allElementUpdate en verwerking van payload. |
online |
ack |
|
| 3 | Verstuur alleElementUpdate of keepAlive |
Insturen van snapshotSynchronizationRequest op ontvanger. Eerst volgende aanvraag geeft correcte response voor exchange status |
online |
snapshotSynchronisationRequest |
||
| 4 | Verstuur snapshot met ontvangen sessionID uit openSession response |
2 | Verifieer ontvangst snapshot en verwerking van payload. |
online |
ack |
|
| 5 | Doorlopen levenscyclus situation (start, updates, beëindiging) met 1 of meer records | ++ | Verifieer doorlopen alle stappen, inclusief versie verhoging, timestamps en afmeldingen | |||
| 6 | Verstuur allElementUpdate of keepAlive |
Insturen van closeSessionRequest op ontvanger en op eerst volgende aanvragen sessie sluiten. |
closingSession |
|||
| 7 | Openzetten nieuwe sessie en insturen van snapshot | 2 | Verifieer ontvangst openSession en openen van nieuwe sessie. Verifieer ontvangst snapshot en verwerking van snapshot |
|||
| 8 | Verstuur closeSession met ontvangen sessionID uit openSession response |
Verifieer ontvangst closeSesssion en sluit de sessie af. Teruggeven van exchangeStatus closingSession en returnStatus: ack |
closingSession |
ack |
||
| 9 | Verstuur openSession |
Verifieer ontvangst openSession en automatische opening van nieuwe sessie. Response met nieuwe sessie en in het element sesssionId het nieuwe sessie ID |
openingSession |
ack |
Storing verbinding
Het doel van deze teststap in het scenario is om storingen in de verbinding te simuleren en te verifiëren dat de leverancier weer data begint te leveren.
De eerste stap is testen van een storing aan de kant van de provider, de tweede test uitval van NDW.
Uitval leverancier
| Nummer | Tijdstip | Actie leverancier | record versie | Actie NDW | Veld exchangeStatus |
Veld returnStatus |
|---|---|---|---|---|---|---|
| 0 | Stopt sessie zonder versturen van closeSession |
Na 1 minuut word sessie afgemeld in ontvanger | offline |
fail |
||
| 1 | Herstel verbinding met openSession, stuur snapshot |
Verifieer openSession en ontvangst snapshot |
Uitval NDW
| Nummer | Tijdstip | Actie leverancier | record versie | Actie NDW | Veld exchangeStatus |
Veld returnStatus |
|---|---|---|---|---|---|---|
| 0 | - | Geforceerd session status aanpassen naar offline. | offline |
fail |
||
| 1 | Herstel verbinding met openSession, stuur snapshot na ontvangst van bericht met exchangeStatus offline |
Verifieer openSession en ontvangst snapshot |
Duurtest
In dit laatste deel moet de leverancier aantonen dat zijn datalevering stabiel is. Het systeem moet 24 uur lang data leveren aan het NDW. NDW beheer controleert na de 24 uur of er in die tijd onderbrekingen in de verbinding zijn geweest.
Go back to the previous page