> ## Documentation Index
> Fetch the complete documentation index at: https://dokumentation.websale.de/llms.txt
> Use this file to discover all available pages before exploring further.

# EJD- (JSON-Schnittstelle)

> JSON-Daten im Template lesen, durchlaufen, ändern und neu erzeugen: eigene Dateien vom FTP-Zugang, intern vorliegende Daten und selbst gebaute JSON-Objekte.

Mit der JSON-Schnittstelle bringt ein Template Daten in den Shop, die nicht aus den Produktdaten stammen: eine Nährwerttabelle je Artikel, Umsatzzahlen für den angemeldeten Kunden, die Antwort eines Zahlungsdienstleisters. Umgekehrt baut sie auch JSON auf, das der Shop an ein Tracking- oder Fremdsystem weitergibt.

Die Tags mit dem Präfix `EJD-` (External JSON Data) sind der Zugang dazu. Sie decken drei Aufgaben ab.

| Aufgabe | Einstiegstag |
| - | - |
| eine eigene JSON-Datei vom FTP-Zugang lesen | `EJD-LoadData(global…)` oder `EJD-LoadData(subshop…)` |
| intern vorliegende JSON-Daten lesen | `EJD-LoadData(intern…)` |
| neues JSON im Template aufbauen | `EJD-CreateNewData()` |

Wegweiser: [JSON-Schnittstelle](https://dokumentation.websale.de/v8s/externe-dienste/json-schnittstelle.md)

## Der Ablauf

Jeder Zugriff läuft in drei Schritten: laden, prüfen, zugreifen. Die Daten bekommen beim Laden eine frei gewählte **ID**, über die alle weiteren Tags sie wiederfinden.

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
~EJD-LoadData(global,$PR-Number$.json,jdat)~

{EJD-DataOK(jdat)}
   ~EJD-SetUseID(jdat)~

   Beschreibung: ~EJD-DA-Value(AdditionalInfo.Beschreibung)~
{/EJD-DataOK(jdat)}

{!EJD-DataOK(jdat)}
   <!-- keine Zusatzdaten zu diesem Produkt -->
{/!EJD-DataOK(jdat)}
```

Mehrere JSON-Daten lassen sich gleichzeitig geladen halten. Die ID hält sie auseinander. Deshalb trägt jedes Zugriffs-Tag die ID als letzten Parameter, und `EJD-SetUseID()` erspart es, sie jedes Mal zu wiederholen.

Die Beispiele auf dieser Seite beziehen sich auf diese Datei:

```json theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
{
   "Produktname": "Sportlicher Sneaker",
   "Produktnummer": "A-1234",
   "AdditionalInfo": {
      "Beschreibung": "Moderne Schuhe für jeden Anlass",
      "lieferbar": true,
      "Crosslinks": [ "A-5678", "B-9876", "C-2323" ],
      "Lagerbestand": 42,
      "Preis": 59.95
   }
}
```

## Daten laden

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
~EJD-LoadData(Typ,Pfad,ID)~
```

### Der Typ

| Typ | Woher die Daten kommen |
| - | - |
| `global` | aus dem Hauptverzeichnis des FTP-Zugangs der JSON-Schnittstelle, für alle Subshops gleich |
| `subshop` | aus dem Unterverzeichnis des gerade aufgerufenen Subshops |
| `userdir` | aus einem beliebigen Verzeichnis unterhalb von `benutzer` auf dem FTP-Server des Shops |
| `intern` | aus Daten, die der Shop oder ein Fremdsystem bereits bereithält, ohne Dateizugriff |

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
~EJD-LoadData(global,file.json,jdat)~
~EJD-LoadData(global,unterverzeichnis/file.json,jdat)~
~EJD-LoadData(subshop,file.json,jdat)~
~EJD-LoadData(userdir,navigation/grafiken/JSON/file.json,jdat)~
```

Beim Typ `subshop` wählt der Shop das passende Unterverzeichnis selbst. Im englischen Subshop lädt `~EJD-LoadData(subshop,file.json,jdat)~` also die Datei `/English/file.json`. Dieselbe Zeile im Template funktioniert damit in allen Subshops.

### Der Pfad beim Typ "intern"

Beim Typ `intern` steht im zweiten Parameter keine Datei, sondern die technische Bezeichnung der bereitliegenden Daten.

| Bezeichnung | Inhalt |
| - | - |
| `rawdatainput` | die mit `EJD-SetRawDataInput()` übergebenen Daten |
| `rawdatahexcodedinput` | die mit `EJD-SetRawDataHexCodedInput()` übergebenen Daten |
| `hreflang-start` | hreflang-Angaben zur Startseite der verbundenen Subshops |
| `hreflang-global-start` | dasselbe für alle verbundenen Subshops |
| `hreflang-cat-<CatIndex>` | hreflang-Angaben zu einer Kategorieseite |
| `hreflang-global-cat-<CatIndex>` | dasselbe für alle verbundenen Subshops |
| `hreflang-prod-<ProdIndex>` | hreflang-Angaben zu einer Produktseite |
| `hreflang-global-prod-<ProdIndex>` | dasselbe für alle verbundenen Subshops |

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
~EJD-LoadData(intern,hreflang-cat-$CAT-Index$,href)~
~EJD-LoadData(intern,hreflang-prod-$PR-ProdIndex$,href)~
```

Daneben stellen einzelne Module ihre Antworten bereit.

| Bezeichnung | Modul |
| - | - |
| `PaymorrowGetPaymentTokenResponse` | Paymorrow, Anforderung des PaymentTokens |
| `PaymorrowAuthorizeByRefResponse` | Paymorrow, Autorisierung der Zahlung |
| `PaymorrowDebitAuthorizeByRefResponse` | Paymorrow, Lastschrift |
| `TaxJarTaxesRequest` | TaxJar, Steuerberechnung |
| `TaxJarTaxRateForZIP` | TaxJar, Steuersatz zu einer Postleitzahl |

Weitere Bezeichnungen kommen mit neuen Modulen hinzu und sind bei der WEBSALE AG oder beim jeweiligen Dienstleister zu erfragen.

Bei internen Daten wissen Sie oft nicht im Voraus, welche Felder geliefert werden. `EJD-RawDataOutput()` gibt den kompletten Datensatz aus und ist der schnellste Weg, sich einen Überblick zu verschaffen.

## Prüfen, ob das Laden geklappt hat

`EJD-DataOK()` klammert auf den Erfolg. Als Einzel-Tag gibt es den Fehlercode aus.

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
{EJD-DataOK(jdat)}
   <!-- Daten liegen vor -->
{/EJD-DataOK(jdat)}

{!EJD-DataOK(jdat)}
   <!-- Fehlercode: ~EJD-DataOK(jdat)~ -->
{/!EJD-DataOK(jdat)}
```

| Code | Bedeutung |
| - | - |
| 0 | Daten in Ordnung |
| 1 | unbekannter Wert für den Typ |
| 4 | Dateipfad fehlerhaft oder Datei nicht gefunden |
| 5 | Fehler beim Parsen der Datei |
| 6 | interne JSON-Daten sind leer |
| 7 | unbekannte Bezeichnung beim Typ `intern` |
| 8 | Dateipfad nicht konfiguriert |
| 999 | interner Fehler beim Initialisieren |
| 9999 | ID nicht geladen |

> [!WARNING]
>
> `EJD-DataOK()` braucht die ID immer ausgeschrieben. `EJD-SetUseID()` wirkt hier nicht, denn es steht ja selbst erst innerhalb der Klammerung.

## Die ID einmal setzen

`EJD-SetUseID()` legt die ID fest, die alle folgenden Zugriffs-Tags verwenden, wenn sie selbst keine mitbekommen.

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
{EJD-DataOK(jdat)}
   ~EJD-SetUseID(jdat)~

   Preis: ~EJD-DA-Value(AdditionalInfo.Preis)~
   Bestand: ~EJD-DA-Value(AdditionalInfo.Lagerbestand)~
{/EJD-DataOK(jdat)}
```

Bei allen Zugriffs-, Prüf- und Änderungs-Tags ist die ID deshalb **optional**. Sie ist nur dann nötig, wenn keine Standard-ID gesetzt ist oder wenn Sie zwischen mehreren Datensätzen wechseln.

Die Standard-ID lässt sich beliebig oft neu setzen. Bei mehreren gleichzeitig geladenen Datensätzen wechseln Sie damit hin und her.

## Der Zugriffspfad

Alle Zugriffs-Tags erwarten als ersten Parameter den Pfad zum Element.

| Schreibweise | Bedeutung |
| - | - |
| `Produktname` | ein Element der obersten Ebene |
| `AdditionalInfo.Beschreibung` | ein Element in einem Objekt, Ebenen durch Punkt getrennt |
| `AdditionalInfo.Crosslinks[0]` | das erste Element eines Arrays, gezählt ab 0 |
| leer oder `_root_` | das Wurzelelement selbst |

> [!WARNING]
>
> Array-Elemente werden ab 0 gezählt. Das erste Element ist `[0]`. Deshalb passt `DC-ZeroLoopX` als Schleife über ein Array besser als `DC-LoopX`, das ab 1 zählt.

## Werte lesen

| Tag | Liefert |
| - | - |
| `EJD-DA-Value()` | den Wert des Elements |
| `EJD-DA-NameExists()` | greift, wenn es ein Element mit diesem Namen gibt |
| `EJD-DA-ArrayElements()` | die Anzahl der Elemente eines Arrays |

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
Nummer: ~EJD-DA-Value(Produktnummer,jdat)~
Beschreibung: ~EJD-DA-Value(AdditionalInfo.Beschreibung,jdat)~

{EJD-DA-NameExists(AdditionalInfo.Crosslinks,jdat)}
   Anzahl der Crosslinks: ~EJD-DA-ArrayElements(AdditionalInfo.Crosslinks,jdat)~
{/EJD-DA-NameExists(AdditionalInfo.Crosslinks,jdat)}
```

`EJD-DA-ArrayElements()` greift als Bereichs-Tag nur, wenn das Element wirklich ein Array **und** nicht leer ist. Die Klammerung beantwortet damit in einem Schritt die Frage, ob sich eine Schleife überhaupt lohnt.

### Den Typ eines Werts prüfen

JSON kennt mehrere Werttypen. Acht Bereichs-Tags prüfen, welcher vorliegt.

| Tag | Greift bei |
| - | - |
| `EJD-DA-IsString()` | einer Zeichenkette |
| `EJD-DA-IsNumber()` | einer Ganzzahl |
| `EJD-DA-IsReal()` | einer Fließkommazahl |
| `EJD-DA-IsObject()` | einem Objekt |
| `EJD-DA-IsArray()` | einem Array |
| `EJD-DA-IsTrue()` | dem Wert `true` |
| `EJD-DA-IsFalse()` | dem Wert `false` |
| `EJD-DA-IsNull()` | dem Wert `null` |

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
{EJD-DA-IsTrue(AdditionalInfo.lieferbar,jdat)}
   <span class="lieferbar">sofort lieferbar</span>
{/EJD-DA-IsTrue(AdditionalInfo.lieferbar,jdat)}

{EJD-DA-IsNull(AdditionalInfo.lieferbar,jdat)}
   <span>keine Angabe zur Lieferbarkeit</span>
{/EJD-DA-IsNull(AdditionalInfo.lieferbar,jdat)}
```

> [!WARNING]
>
> Die acht Prüf-Tags sind reine Bereichs-Tags. Als Einzel-Tag geschrieben bleiben sie wirkungslos.

Bei fremden Daten lohnt sich die Typprüfung. Ein Feld, das gestern eine Zahl war und heute `null` ist, lässt eine ungeprüfte Ausgabe sonst leer.

## Werte weiterverwenden

Die Zugriffs-Tags tragen Parameter. Damit lassen sie sich nicht als `$…$` in ein anderes Tag schreiben, denn Tag-in-Tag funktioniert nur mit Einzel-Tags ohne eigenes Argument.

Deshalb merkt sich der Shop bei jedem Zugriff den angesprochenen Namen und Wert. Zwei parameterlose Tags geben sie wieder aus.

| Tag | Liefert |
| - | - |
| `EJD-LastNameAccessed` | den zuletzt angesprochenen Namen |
| `EJD-LastValueAccessed` | den zuletzt angesprochenen Wert |

| Diese Tags merken sich den Namen | Diese Tags merken sich den Wert |
| - | - |
| `EJD-DA-NameExists()`, `EJD-DA-TouchName()` | `EJD-DA-Value()`, `EJD-DA-TouchValue()`, alle acht `EJD-DA-Is…()`, `EJD-DA-ArrayElements()`, `EJD-DA-TouchArrayElements()` |

`EJD-DA-TouchName()`, `EJD-DA-TouchValue()` und `EJD-DA-TouchArrayElements()` gibt es nur dafür: Sie merken sich etwas, ohne selbst etwas auszugeben.

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
~EJD-DA-TouchArrayElements(AdditionalInfo.Crosslinks,jdat)~
~DC-ZeroLoopCross_set($EJD-LastValueAccessed$)~

{@DC-ZeroLoopCross}
   Crosslink ~DC-ZeroLoopCross_position~:
   ~EJD-DA-Value(AdditionalInfo.Crosslinks[$DC-ZeroLoopCross_position$],jdat)~<br>
{/@DC-ZeroLoopCross}
```

Ausgabe:

```text theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
Crosslink 0: A-5678
Crosslink 1: B-9876
Crosslink 2: C-2323
```

Das ist das Standardmuster für Arrays: Anzahl merken, damit eine Zählschleife aufziehen und die Position als Index einsetzen. `DC-ZeroLoopX` zählt ab 0 und passt damit genau auf die Array-Indizes.

Referenz: [DC- (Schleifen)](https://dokumentation.websale.de/v8s/referenz/tags/dc/schleifen.md)

## Über Elemente iterieren

Bei einem Objekt, dessen Schlüssel Sie nicht kennen, hilft keine Zählschleife. `EJD-ElementIterator()` läuft stattdessen über die Kinder eines Elements und gibt deren Namen aus.

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
~EJD-LoadData(global,D200297.json,bezuege)~

{EJD-DataOK(bezuege)}
   ~EJD-SetUseID(bezuege)~

   {@EJD-ElementIterator(Items)}
      Artikel: ~EJD-ElementIterator~<br>
      Letztes Jahr: ~EJD-DA-Value(Items.$EJD-ElementIterator$.Sales PY)~<br>
      Dieses Jahr: ~EJD-DA-Value(Items.$EJD-ElementIterator$.Sales CY)~<br>
   {/@EJD-ElementIterator(Items)}
{/EJD-DataOK(bezuege)}
```

Als Einzel-Tag innerhalb der Schleife gibt `EJD-ElementIterator` den Namen des aktuellen Elements aus. Weil es dann parameterlos ist, lässt es sich als `$EJD-ElementIterator$` in den Zugriffspfad einsetzen. Genau darauf beruht das Muster oben.

> [!WARNING]
>
> Die Schleife lässt sich schachteln, aber nur bis zu einer festen Tiefe von zehn Ebenen. Wird sie überschritten, schreibt der Shop einen kritischen Fehler ins Protokoll und die Schleife läuft nicht an.

## Fließkommazahlen ausgeben

`EJD-SetRealOutputFormat()` legt fest, mit wie vielen Nachkommastellen Fließkommazahlen ausgegeben werden. Zulässig sind 0 bis 6.

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
~EJD-DA-Value(AdditionalInfo.Preis,jdat)~        <!-- 59.95 -->
~EJD-SetRealOutputFormat(4)~
~EJD-DA-Value(AdditionalInfo.Preis,jdat)~        <!-- 59.9500 -->
```

> [!WARNING]
>
> Eine Angabe außerhalb von 0 bis 6 macht das Tag ungültig, die bisherige Einstellung bleibt dann bestehen. Die Einstellung gilt ab der Stelle im Template, an der sie gesetzt wird, und für alle geladenen Datensätze.

## JSON erzeugen und ändern

`EJD-CreateNewData()` legt ein leeres JSON-Objekt an, das Sie im Template füllen.

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
~EJD-CreateNewData(jdat)~
~EJD-DA-SetStringValue(Straße,$A-Street1$,jdat)~
~EJD-RawDataOutput(jdat)~
```

Ausgabe:

```json theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
{ "Straße": "Gutenstetter Str. 2" }
```

| Tag | Setzt den Wert auf |
| - | - |
| `EJD-DA-SetStringValue()` | die angegebene Zeichenkette |
| `EJD-DA-SetNumberValue()` | die angegebene Ganzzahl |
| `EJD-DA-SetRealValue()` | die angegebene Fließkommazahl |
| `EJD-DA-SetToTrue()` | `true` |
| `EJD-DA-SetToFalse()` | `false` |
| `EJD-DA-SetToNull()` | `null` |
| `EJD-DA-SetToEmptyObject()` | ein leeres Objekt |
| `EJD-DA-SetToEmptyArray()` | ein leeres Array |

| Tag | Wirkung |
| - | - |
| `EJD-DA-ArrayExtend()` | hängt ein Element mit dem Wert `null` an ein Array an |
| `EJD-DA-DeleteElement()` | löscht ein Element |

Alle diese Tags funktionieren nicht nur auf neu erzeugten Daten, sondern ebenso auf geladenen. Damit lässt sich eine eingelesene Datei im Template anreichern und anschließend weitergeben.

> [!WARNING]
>
> Existiert der Pfad schon, wird der bisherige Wert ersetzt. Existiert er noch nicht, wird er angelegt, sofern das übergeordnete Element vorhanden ist. `EJD-DA-ArrayExtend()` und `EJD-DA-DeleteElement()` legen dagegen nichts an: Zeigt ihr Pfad ins Leere, melden sie einen Fehler.
>
> Das Wurzelelement lässt sich nur in ein Objekt oder ein Array verwandeln. Jeder Versuch, ihm einen einfachen Wert zu geben, endet mit dem Fehlercode 14.

### Ein Array aufbauen

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
~EJD-CreateNewData(jdat)~
~EJD-DA-SetToEmptyArray(Crosslinks,jdat)~          <!-- { "Crosslinks": [] } -->

~EJD-DA-ArrayExtend(Crosslinks,jdat)~              <!-- [ null ] -->
~EJD-DA-ArrayExtend(Crosslinks,jdat)~              <!-- [ null, null ] -->

~EJD-DA-SetStringValue(Crosslinks[0],A1234,jdat)~
~EJD-DA-SetStringValue(Crosslinks[1],B5678,jdat)~

~EJD-RawDataOutput(jdat)~
```

Ausgabe:

```json theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
{ "Crosslinks": [ "A1234", "B5678" ] }
```

Soll das Wurzelelement selbst ein Array sein, geben Sie als Pfad `_root_` an: `~EJD-DA-SetToEmptyArray(_root_,jdat)~` ergibt `[]`.

### Ein Beispiel aus dem Tracking

Auf der Produktübersichtsseite ein JSON mit Index und Preis aller gezeigten Produkte aufbauen:

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
~EJD-CreateNewData(jdat)~

{EJD-DataOK(jdat)}
   ~EJD-DA-SetToEmptyArray(data,jdat)~
   ~EJD-DA-ArrayExtend(data,jdat)~
   ~EJD-DA-SetToEmptyObject(data[0],jdat)~
   ~EJD-DA-SetStringValue(data[0].event_name,ViewContent,jdat)~

   {CAT-Data}
      ~EJD-DA-SetToEmptyArray(data[0].contents,jdat)~
      ~DC-Int1_set(0)~

      {@PR-Data}
         ~EJD-DA-ArrayExtend(data[0].contents,jdat)~
         ~EJD-DA-SetToEmptyObject(data[0].contents[$DC-Int1$],jdat)~
         ~EJD-DA-SetStringValue(data[0].contents[$DC-Int1$].id,$PR-ProdIndex$,jdat)~

         ~WS-DisablePriceAndNumberFormat~
         ~EJD-DA-SetRealValue(data[0].contents[$DC-Int1$].item_price,$PR-Price$,jdat)~
         ~WS-EnablePriceAndNumberFormat~

         ~DC-Int1_inc~
      {/@PR-Data}
   {/CAT-Data}
{/EJD-DataOK(jdat)}

~EJD-RawDataOutput(jdat)~
```

> [!WARNING]
>
> Schalten Sie die Preisformatierung ab, bevor Sie einen Preis als Zahl übergeben. Sonst kommt er mit Tausendertrennzeichen und Komma an und wird beim Umwandeln in eine Zahl abgeschnitten.

### Prüfen, ob die Änderung geklappt hat

`EJD-ModificationOK` klammert auf den Erfolg der letzten Änderung und gibt als Einzel-Tag den Fehlercode aus.

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
~EJD-DA-SetToFalse(AdditionalInfo.lieferbar,jdat)~

{!EJD-ModificationOK}
   <!-- Fehler: ~EJD-ModificationOK~ -->
{/!EJD-ModificationOK}

~EJD-ResetModificationOK~
```

> [!WARNING]
>
> Der Fehlercode bleibt stehen, auch wenn die nächste Änderung gelingt. Setzen Sie ihn deshalb nach jeder Prüfung mit `EJD-ResetModificationOK` zurück, sonst melden alle folgenden Prüfungen denselben alten Fehler.

| Code | Ursache |
| - | - |
| 0 | in Ordnung |
| 1 | Versuch, einen nicht vorhandenen Array-Eintrag zu ändern |
| 2 | das übergeordnete Element des Pfades existiert nicht |
| 3 bis 5 | interner Speicherfehler |
| 6 | `EJD-DA-ArrayExtend()` oder `EJD-DA-DeleteElement()`: Element existiert nicht |
| 7 | keine Daten mit dieser ID gefunden |
| 8 | die Rohdaten konnten nach der Änderung nicht neu erzeugt werden |
| 9 bis 12 | `EJD-DA-DeleteElement()` fehlgeschlagen |
| 13 | `EJD-DA-ArrayExtend()`: das Element ist kein Array |
| 14 | Versuch, das Wurzelelement in etwas anderes als Objekt oder Array zu ändern |
| 15 | `EJD-DA-SetStringValue()`: der übergebene Wert ließ sich nicht auflösen |

## Rohdaten ein- und ausgeben

| Tag | Wirkung |
| - | - |
| `EJD-RawDataOutput()` | gibt den kompletten Datensatz als JSON aus |
| `EJD-SetRawDataInput()` | übergibt JSON im Klartext an die Schnittstelle |
| `EJD-SetRawDataHexCodedInput()` | übergibt hexcodiertes JSON an die Schnittstelle |

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
~EJD-SetRawDataInput($XYZ-technischeBezeichnung-JSON$)~
~EJD-LoadData(intern,rawdatainput,jdat)~

~EJD-RawDataOutput(jdat)~
```

> [!WARNING]
>
> Die beiden Eingabe-Tags gehören zusammen mit der jeweils passenden Bezeichnung beim Laden: `EJD-SetRawDataInput()` mit `rawdatainput`, `EJD-SetRawDataHexCodedInput()` mit `rawdatahexcodedinput`. Vertauscht liefert die Schnittstelle unbrauchbare Daten, weil hexcodierte Zeichen als Klartext gelesen werden oder umgekehrt.
>
> `EJD-RawDataOutput()` gibt die Daten **ohne HTML-Kodierung** aus. Das ist gewollt, damit gültiges JSON entsteht, macht das Tag aber für fremde Daten gefährlich. Schreiben Sie damit niemals ungeprüfte Fremddaten in den sichtbaren Seiteninhalt. Für die Fehlersuche gehört die Ausgabe in einen HTML-Kommentar, im Livebetrieb in ein Skript-Element oder in eine Schnittstelle.

## Ein JSON Web Token erzeugen

`EJD-GenerateJWT()` signiert die geladenen JSON-Daten und gibt sie als JSON Web Token aus. Damit lassen sich Daten fälschungssicher an ein Fremdsystem übergeben.

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
~EJD-GenerateJWT(SecretID)~
~EJD-GenerateJWT(SecretID,jdat)~
```

| Parameter | Bedeutung |
| - | - |
| SecretID | die Kennung eines Eintrags im Abschnitt `<DesignControl>` der Shopkonfiguration `shop.config` |
| ID | die ID der JSON-Daten, optional bei gesetzter Standard-ID |

Das Geheimnis für die Signatur ist derselbe Konfigurationseintrag, den auch `DC-FPX_hash()` und `DC-FPX_encrypt()` verwenden.

Referenz: Abschnitt `<[DesignControl](/v8s/referenz/konfigurationen/shopkonfiguration-shop-config/grundlagen-und-technik#designcontrol)>`

## Die Tags im Überblick

| Tag | Einzel-Tag | Bereichs-Tag | negatives Bereichs-Tag | Schleifen-Tag |
| - | - | - | - | - |
| `EJD-LoadData()` | ja | – | – | – |
| `EJD-DataOK()` | ja | ja | ja | – |
| `EJD-SetUseID()` | ja | – | – | – |
| `EJD-CreateNewData()` | ja | – | – | – |
| `EJD-SetRealOutputFormat()` | ja | – | – | – |
| `EJD-LastNameAccessed` | ja | ja | ja | – |
| `EJD-LastValueAccessed` | ja | ja | ja | – |
| `EJD-DA-Value()` | ja | ja | ja | – |
| `EJD-DA-TouchValue()` | ja | ja | ja | – |
| `EJD-DA-TouchName()` | ja | ja | ja | – |
| `EJD-DA-NameExists()` | – | ja | ja | – |
| `EJD-DA-ArrayElements()` | ja | ja | ja | – |
| `EJD-DA-TouchArrayElements()` | ja | ja | ja | – |
| `EJD-DA-IsString()` | – | ja | ja | – |
| `EJD-DA-IsNumber()` | – | ja | ja | – |
| `EJD-DA-IsReal()` | – | ja | ja | – |
| `EJD-DA-IsObject()` | – | ja | ja | – |
| `EJD-DA-IsArray()` | – | ja | ja | – |
| `EJD-DA-IsTrue()` | – | ja | ja | – |
| `EJD-DA-IsFalse()` | – | ja | ja | – |
| `EJD-DA-IsNull()` | – | ja | ja | – |
| `EJD-ElementIterator()` | ja | ja | ja | ja |
| `EJD-DA-SetStringValue()` | ja | – | – | – |
| `EJD-DA-SetNumberValue()` | ja | – | – | – |
| `EJD-DA-SetRealValue()` | ja | – | – | – |
| `EJD-DA-SetToTrue()` | ja | – | – | – |
| `EJD-DA-SetToFalse()` | ja | – | – | – |
| `EJD-DA-SetToNull()` | ja | – | – | – |
| `EJD-DA-SetToEmptyObject()` | ja | – | – | – |
| `EJD-DA-SetToEmptyArray()` | ja | – | – | – |
| `EJD-DA-ArrayExtend()` | ja | – | – | – |
| `EJD-DA-DeleteElement()` | ja | – | – | – |
| `EJD-ModificationOK` | ja | ja | ja | – |
| `EJD-ResetModificationOK` | ja | – | – | – |
| `EJD-RawDataOutput()` | ja | ja | ja | – |
| `EJD-SetRawDataInput()` | ja | – | – | – |
| `EJD-SetRawDataHexCodedInput()` | ja | – | – | – |
| `EJD-GenerateJWT()` | ja | – | – | – |

Zulässig sind alle Tags auf allen Templates. Die ID ist bei allen Tags optional, sobald sie mit `EJD-SetUseID()` gesetzt wurde, mit Ausnahme von `EJD-DataOK()` und `EJD-RawDataOutput()`.

## Verwandte Themen

* Wegweiser: [JSON-Schnittstelle](https://dokumentation.websale.de/v8s/externe-dienste/json-schnittstelle.md)
* Wegweiser: href-Attribut
* Referenz: [DC- (Schleifen)](https://dokumentation.websale.de/v8s/referenz/tags/dc/schleifen.md)
* Referenz: [DC- (Freie Parameter und Session-Parameter)](https://dokumentation.websale.de/v8s/referenz/tags/dc/parameter.md)


## Related topics

- [SHIPTRACK- (Sendungsverfolgung)](https://dokumentation.websale.de/v8s/referenz/tags/shiptrack-sendungsverfolgung.md)
- [KLARNA- (Klarna Payments)](https://dokumentation.websale.de/v8s/referenz/tags/klarna-payments.md)
- [PPP- (PayPal PLUS)](https://dokumentation.websale.de/v8s/referenz/tags/ppp-paypal-plus.md)
- [RECAPTCHAV3- (Google reCAPTCHA)](https://dokumentation.websale.de/v8s/referenz/tags/recaptchav3-google-recaptcha.md)
- [PPC- (PayPal Checkout)](https://dokumentation.websale.de/v8s/referenz/tags/ppc-paypal-checkout.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.