> ## 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.

# Kunde, Anmeldung und Konto

> Anmeldung und Registrierung im Template aufbauen: Eingabefelder für E-Mail-Adresse und Passwort, die kombinierte Anmeldung, dauerhafter Login, Bestätigung der E-Mail-Adresse und die Links ins Kundenkonto.

Fast alle Tags dieser Seite bauen Formularfelder. Das klingt eintönig, ist aber der Grund, warum sie so leicht zu lernen sind: Sie folgen fast ausnahmslos demselben Dreierschema. Wer es einmal verstanden hat, kann jedes Feld dieser Seite schreiben, ohne die Einzelbeschreibung zu lesen.

Darum steht dieses Schema am Anfang. Danach folgen die Formulare, die daraus entstehen, von der einfachen Anmeldung über die kombinierte Anmeldung im Bestellablauf bis zur Bestätigung der E-Mail-Adresse. Am Ende stehen die Links, die vom Shop ins Kundenkonto führen.

Referenz: Der Einstieg in das Präfix `WS-` und die Übersicht über die acht Seiten stehen auf [Shop, Seite und Technik](https://dokumentation.websale.de/v8s/referenz/tags/ws/shop-seite-und-technik.md)

## Das Dreierschema

Zu fast jedem Eingabefeld gehören drei Tags.

| Endung | Liefert | Gehört in |
| - | - | - |
| ohne | den bisher eingegebenen Wert | das `value`-Attribut |
| `_input` | den HTML-Namen des Feldes | das `name`-Attribut |
| `_error` | den Fehlerstyle-Suffix | das `class`-Attribut |

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
<input type="text"
       name="~WS-Email_input~"
       value="~WS-Email~"
       class="eingabe~WS-Email_error~">
```

Die Endung `_error` liefert als Einzel-Tag die Zeichenkette `_error` und sonst nichts. Hängen Sie sie an einen Klassennamen, dann heißt die Klasse bei einem Fehler `eingabe_error` und sonst `eingabe`. Damit lässt sich die Fehlerdarstellung vollständig über CSS gestalten, ohne eine zweite Klammerung im Template.

Jedes `_error`-Tag greift zusätzlich als Klammerung, und zwar dann, wenn die Eingabe fehlerhaft ist. Das ist der Weg für eine Fehlermeldung in Worten neben dem Feld.

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
{WS-Email_error}
   <p class="fehler">Bitte geben Sie eine gültige E-Mail-Adresse ein.</p>
{/WS-Email_error}
```

> [!WARNING]
>
> Die Wertetags geben den **zuletzt eingegebenen** Wert zurück, damit der Käufer nach einem Fehler nicht alles neu tippen muss. Für Passwortfelder gilt das ebenfalls. Überlegen Sie bei einem Passwortfeld, ob Sie den Wert wirklich zurückschreiben wollen, oder ob ein leeres Feld die bessere Wahl ist.

## Anmeldung und Registrierung

Dieselben Felder dienen je nach Vorgang unterschiedlichen Zwecken. Das ist der häufigste Stolperstein auf dem Login-Template.

| Tag | Bei der Anmeldung | Beim Ändern |
| - | - | - |
| `WS-Email` | die E-Mail-Adresse des Bestandskunden | die bisherige E-Mail-Adresse |
| `WS-NewEmail` | die E-Mail-Adresse des Neukunden | die neue E-Mail-Adresse |
| `WS-EmailAgain` | – | die Wiederholung der neuen E-Mail-Adresse |
| `WS-PW` | das Passwort des Bestandskunden | das bisherige Passwort |
| `WS-NewPW` | das Passwort des Neukunden | das neue Passwort |
| `WS-PWAgain` | die Wiederholung beim Neukunden | die Wiederholung des neuen Passworts |
| `WS-UserID` | die Benutzerkennung, wenn der Shop damit arbeitet | – |

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
<form action="~FORM-LoginKnownUser~" method="post">
   <input type="text"
          name="~WS-Email_input~"
          value="~WS-Email~"
          class="eingabe~WS-Email_error~">

   <input type="password"
          name="~WS-PW_input~"
          maxlength="64"
          class="eingabe~WS-PW_error~">

   <input type="submit" value="Anmelden">
</form>
```

> [!WARNING]
>
> Das Beispiel auf der bisherigen Seite zu `WS-PW` zeigt ein `input`-Element mit `type="text"`. Ein Passwortfeld muss `type="password"` tragen, sonst steht das Passwort sichtbar auf dem Bildschirm. Die Beispiele zu `WS-NewPW` und `WS-PWAgain` machen es richtig. Oben steht die berichtigte Fassung.

Der Unterschied zwischen `WS-Email` und `WS-NewEmail` ist nicht Alt gegen Neu, sondern Bestandskunde gegen Neukunde. Auf einem Template, das beide Fälle abdeckt, brauchen Sie beide Felder, und sie dürfen nicht dasselbe `name`-Attribut tragen.

`WS-UserID` gehört zu Shops, in denen sich der Käufer nicht über seine E-Mail-Adresse anmeldet, sondern über eine vergebene Kennung. Das ist vor allem im B2B-Bereich üblich. In einem Shop ohne diese Anmeldeart bleiben die drei Tags einfach ungenutzt.

### Die Passwortampel

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
<body>
   ~WS-SecureLoginConfigurationJS~
   ...
</body>
```

`WS-SecureLoginConfigurationJS` gibt den Inhalt des Abschnitts `secure login` der Shopkonfiguration als Skript in die Seite aus. Darüber erfährt die Passwortampel im Browser, welche Regeln für ein gültiges Passwort gelten. Ohne dieses Tag kann die Ampel nichts prüfen.

Das Tag gehört ausschließlich auf die Templates, auf denen der Käufer ein neues Passwort vergibt, also auf die Registrierung und auf die Passwortänderung. Auf der gewöhnlichen Anmeldeseite hat es nichts verloren.

### Passwort vergessen

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
<form action="~FORM-RequestPW~" method="post">
   <input type="text" name="~WS-Email_input~" value="~WS-Email~">
   ~WS-PWRequestZip~
   <input type="submit" value="Passwort zusenden">
</form>
```

`WS-PWRequestZip` erzeugt ein fertiges Eingabefeld für die Postleitzahl. Sie schreiben nur das Tag, nicht das umgebende `input`-Element. Die zusätzliche Abfrage verhindert, dass jemand allein mit einer erratenen E-Mail-Adresse ein Passwort anfordert.

`WS-RequestPWLink` erzeugt den Link auf die Anmeldeseite für diesen Zweck. Es verhält sich wie `WS-LoginLink`, legt aber den Vorgang nicht auf den Bestellablauf fest.

## Angemeldet bleiben

Ein Käufer, der bei jedem Besuch sein Passwort tippen muss, kommt seltener wieder. Zwei Ankreuzfelder bieten ihm an, angemeldet zu bleiben, und sie unterscheiden sich in einem wichtigen Punkt.

| Tag | Automatische Anmeldung | Vor kritischen Aktionen |
| - | - | - |
| `WS-StaySignedIn_input` | ja | erneute Passworteingabe nötig |
| `WS-StayFullySignedIn_input` | ja | keine erneute Eingabe nötig |

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
<form action="~FORM-QuickLogin~" method="post">
   ...
   <label>
      <input type="checkbox" name="~WS-StaySignedIn_input~">
      Angemeldet bleiben
   </label>
</form>
```

> [!WARNING]
>
> Beide Tags müssen **innerhalb** des Anmeldeformulars stehen, also innerhalb von `FORM-LoginNewUser`, `FORM-LoginStart`, `FORM-QuickLogin`, `FORM-CombinedLogin` oder einem anderen Login-Formular. Außerhalb erzeugen sie zwar einen Feldnamen, der aber nie abgeschickt wird.
>
> Bieten Sie `WS-StayFullySignedIn_input` nur an, wenn Sie wissen, dass die Käufer an privaten Geräten einkaufen. In einem Shop, der auch an gemeinsam genutzten Rechnern verwendet wird, ist `WS-StaySignedIn_input` die richtige Wahl, denn dort schützt die Passwortabfrage vor kritischen Aktionen das Konto.

### Erneute Anmeldung vor kritischen Aktionen

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
{WS-UserRequiresReAuthForCritAction}
   <p>Bitte bestätigen Sie zur Sicherheit noch einmal Ihr Passwort.</p>
   <form action="~FORM-ReauthUser~" method="post">
      <input type="password" name="~WS-PW_input~" class="eingabe~WS-PW_error~">
      <input type="submit" value="Bestätigen">
   </form>
{/WS-UserRequiresReAuthForCritAction}

{!WS-UserRequiresReAuthForCritAction}
   ... die eigentliche Seite ...
{/!WS-UserRequiresReAuthForCritAction}
```

`WS-UserRequiresReAuthForCritAction` greift, wenn drei Dinge zugleich zutreffen: Der Käufer wurde automatisch angemeldet, er hat in dieser Sitzung noch kein Passwort eingegeben, und die Seite erfüllt eines der konfigurierten Kriterien für eine kritische Aktion.

> [!WARNING]
>
> Legen Sie empfindliche Inhalte wie Adressdaten, Bankverbindungen oder die Bestellhistorie in die **negative** Klammerung. Sonst sieht ein automatisch angemeldeter Käufer sie, ohne sein Passwort bestätigt zu haben. Das Tag ist auf allen Templates zulässig, genau damit Sie es überall dort einsetzen können, wo es nötig ist.

## Die kombinierte Anmeldung

Im Bestellablauf wird der Käufer vor drei Möglichkeiten gestellt: Anmelden als Bestandskunde, neu registrieren, oder als Gast bestellen. Weil sich das in einem Formular abspielt, gibt es dafür eine eigene Tag-Familie mit regelmäßigem Aufbau.

**Die Auswahl** besteht aus einem Namen und je Möglichkeit aus einem Wert und einer Markierung:

| Tag | Liefert |
| - | - |
| `WS-CombinedLogin_radioname` | den gemeinsamen HTML-Namen der Auswahlknöpfe |
| `WS-CombinedLogin_radiovalue_knownUser` | den Wert für die Anmeldung als Bestandskunde |
| `WS-CombinedLogin_radiovalue_newUser` | den Wert für die Neuregistrierung |
| `WS-CombinedLogin_radiovalue_noLogin` | den Wert für die Bestellung ohne Konto |
| `WS-CombinedLogin_radioselected_knownUser` | `_checked`, wenn diese Möglichkeit gewählt ist |
| `WS-CombinedLogin_radioselected_newUser` | dasselbe für die Neuregistrierung |
| `WS-CombinedLogin_radioselected_noLogin` | dasselbe für die Bestellung ohne Konto |

**Die Felder** folgen wieder dem Dreierschema:

| Feld | Wert | Name | Fehler |
| - | - | - | - |
| E-Mail-Adresse | `WS-CombinedLogin_eMail` | `WS-CombinedLogin_eMail_input` | `WS-CombinedLogin_eMail_error` |
| Passwort Bestandskunde | `WS-CombinedLogin_PWknownUser` | `WS-CombinedLogin_PWknownUser_input` | `WS-CombinedLogin_PWknownUser_error` |
| Passwort Neukunde | `WS-CombinedLogin_PWnewUser` | `WS-CombinedLogin_PWnewUser_input` | `WS-CombinedLogin_PWnewUser_error` |
| Wiederholung Neukunde | `WS-CombinedLogin_PWAgainnewUser` | `WS-CombinedLogin_PWAgainnewUser_input` | `WS-CombinedLogin_PWAgainnewUser_error` |

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
<form action="~FORM-CombinedLogin~" method="post">
   <input type="text"
          name="~WS-CombinedLogin_eMail_input~"
          value="~WS-CombinedLogin_eMail~"
          class="eingabe~WS-CombinedLogin_eMail_error~">

   <label>
      <input type="radio"
             name="~WS-CombinedLogin_radioname~"
             value="~WS-CombinedLogin_radiovalue_knownUser~"
             ~WS-CombinedLogin_radioselected_knownUser~>
      Ich habe bereits ein Konto
   </label>
   {WS-CombinedLogin_radioselected_knownUser}
      <input type="password"
             name="~WS-CombinedLogin_PWknownUser_input~"
             class="eingabe~WS-CombinedLogin_PWknownUser_error~">
   {/WS-CombinedLogin_radioselected_knownUser}

   <label>
      <input type="radio"
             name="~WS-CombinedLogin_radioname~"
             value="~WS-CombinedLogin_radiovalue_newUser~"
             ~WS-CombinedLogin_radioselected_newUser~>
      Ich möchte ein Konto anlegen
   </label>

   <label>
      <input type="radio"
             name="~WS-CombinedLogin_radioname~"
             value="~WS-CombinedLogin_radiovalue_noLogin~"
             ~WS-CombinedLogin_radioselected_noLogin~>
      Ohne Konto bestellen
   </label>

   <input type="submit" value="Weiter">
</form>
```

Die E-Mail-Adresse steht nur einmal im Formular, denn sie wird in allen drei Fällen gebraucht. Nur die Passwortfelder unterscheiden sich.

Die `_radioselected`-Tags liefern als Einzel-Tag `_checked`. Sie gehören deshalb direkt in das `input`-Element, ohne Attributnamen davor. Als Klammerung greifen sie, wenn die jeweilige Möglichkeit gewählt ist. Damit lässt sich das passende Passwortfeld ein- und ausblenden, so wie im Beispiel.

> [!WARNING]
>
> Alle 18 Tags dieser Familie gelten ausschließlich im Bereich `LoginUser` des Login-Templates.

## Registrierung nach einer Gastbestellung

Hat ein Käufer ohne Konto bestellt, lässt sich ihm unmittelbar danach anbieten, aus den eingegebenen Daten ein Konto zu machen.

| Tag | Liefert |
| - | - |
| `WS-CreateAccountAfterGuestOrder_pw` | das eingegebene Passwort |
| `WS-CreateAccountAfterGuestOrder_pw_input` | den HTML-Namen des Passwortfeldes |
| `WS-CreateAccountAfterGuestOrder_pw_error` | den Fehlerstyle-Suffix |
| `WS-CreateAccountAfterGuestOrder_pwagain` | die Wiederholung |
| `WS-CreateAccountAfterGuestOrder_pwagain_input` | deren HTML-Namen |
| `WS-CreateAccountAfterGuestOrder_pwagain_error` | deren Fehlerstyle-Suffix |
| `WS-CreateAccountAfterGuestOrder_cancellink` | den Link zum Abbrechen |

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
{Type-CreateAccountAfterGuestOrder}
   {ST-CreateAccountAfterGuestOrder_method(websale)}
      <input type="password"
             name="~WS-CreateAccountAfterGuestOrder_pw_input~"
             class="eingabe~WS-CreateAccountAfterGuestOrder_pw_error~">
      <input type="password"
             name="~WS-CreateAccountAfterGuestOrder_pwagain_input~"
             class="eingabe~WS-CreateAccountAfterGuestOrder_pwagain_error~">

      <a href="~WS-CreateAccountAfterGuestOrder_cancellink~">Abbrechen</a>
      <input type="submit" name="~BT-CreateAccountAfterGuestOrder~" value="Konto anlegen">
   {/ST-CreateAccountAfterGuestOrder_method(websale)}
{/Type-CreateAccountAfterGuestOrder}
```

Abgefragt wird nur noch das Passwort. Alles andere, von der Adresse bis zur E-Mail-Adresse, hat der Käufer bei der Bestellung bereits eingegeben.

> [!WARNING]
>
> Bieten Sie den Abbruch sichtbar an. Ohne `WS-CreateAccountAfterGuestOrder_cancellink` bleibt dem Käufer kein Weg aus der Registrierung heraus, und er hat gerade erst bestellt.

Die Tags gelten auf der Loginseite und auf der Bestelleingangsbestätigung. Der Abbruch-Link gilt nur auf der Loginseite.

## Anmeldung über ein fremdes Konto

Meldet sich ein Käufer über ein fremdes Konto an, muss das Shopsystem herausfinden, ob dazu schon ein Kundenkonto gehört. Dafür fragt es die E-Mail-Adresse ab und, falls ein Konto existiert, auch das zugehörige Passwort.

| Tag | Liefert |
| - | - |
| `WS-ExternLogin_facebook_connect_email` | die eingegebene E-Mail-Adresse |
| `WS-ExternLogin_facebook_connect_email_input` | deren HTML-Namen |
| `WS-ExternLogin_facebook_connect_email_error` | deren Fehlerstyle-Suffix |
| `WS-ExternLogin_facebook_Connect_pw_input` | den HTML-Namen des Passwortfeldes |
| `WS-ExternLogin_facebook_Connect_pw_error` | dessen Fehlerstyle-Suffix |
| `WS-ExternLogin_facebook_Connect_pw_needed` | greift, wenn ein Passwort nötig ist |

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
{Type-ExternLoginConnectAccounts}
   {ST-ExternLogin_facebook_connect}
      <form action="~FORM-ExternLogin_facebook_connect~" method="post" autocomplete="off">
         <input type="text"
                name="~WS-ExternLogin_facebook_connect_email_input~"
                value="~WS-ExternLogin_facebook_connect_email~"
                class="eingabe~WS-ExternLogin_facebook_connect_email_error~">

         {WS-ExternLogin_facebook_Connect_pw_needed}
            <p>Zu dieser Adresse gibt es bereits ein Konto. Bitte bestätigen Sie es.</p>
            <input type="password"
                   name="~WS-ExternLogin_facebook_Connect_pw_input~"
                   maxlength="64"
                   class="eingabe~WS-ExternLogin_facebook_Connect_pw_error~">
         {/WS-ExternLogin_facebook_Connect_pw_needed}

         <input type="submit" value="Verbinden">
      </form>
   {/ST-ExternLogin_facebook_connect}
{/Type-ExternLoginConnectAccounts}
```

> [!WARNING]
>
> Legen Sie das Passwortfeld in `{WS-ExternLogin_facebook_Connect_pw_needed}`. Gibt es zu der Adresse noch kein Konto, wird kein Passwort gebraucht, und ein trotzdem angezeigtes Feld verwirrt nur.

Achten Sie auf die Groß- und Kleinschreibung: Im E-Mail-Zweig heißt es `connect_email`, im Passwortzweig `Connect_pw` mit großem C. Das ist im Shopsystem so hinterlegt.

## Die E-Mail-Adresse bestätigen

| Tag | Liefert |
| - | - |
| `WS-DoubleOptInLink` | den Aktivierungslink für die verpflichtende Bestätigung |
| `WS-VoluntaryDoubleOptInVerificationLink` | den Link für die freiwillige Bestätigung |
| `WS-RequestVoluntaryDoubleOptInEmailLink` | den Link, mit dem der Käufer diese E-Mail anfordert |
| `WS-RequestDeleteAccountDoubleOptInEmailLink` | den Link, mit dem er die E-Mail zum Löschen seines Kontos anfordert |
| `WS-EmailVerified` | greift, wenn die Adresse bestätigt ist |

**Im E-Mail-Template** steht der Link, der die Adresse bestätigt:

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
<p>
   Bitte bestätigen Sie Ihre E-Mail-Adresse:
   <a href="~WS-DoubleOptInLink~">Adresse bestätigen</a>
</p>
```

**Im Shop** steht der Hinweis auf den noch offenen Stand:

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
{ST-LoggedIn}
   {!WS-EmailVerified}
      <p>
         Ihre E-Mail-Adresse ist noch nicht bestätigt.
         <a href="~WS-RequestVoluntaryDoubleOptInEmailLink~">E-Mail erneut anfordern</a>
      </p>
   {/!WS-EmailVerified}
{/ST-LoggedIn}
```

> [!WARNING]
>
> `WS-EmailVerified` ist nur im angemeldeten Zustand aussagekräftig. Legen Sie es in `{ST-LoggedIn}`, sonst greift die negative Klammerung auch bei jedem nicht angemeldeten Besucher, und der bekommt einen Hinweis zu einem Konto, das er gar nicht hat.

`WS-DoubleOptInLink` und `WS-VoluntaryDoubleOptInVerificationLink` gehören in die E-Mail-Templates, die in den Abschnitten `NewCustomerDoubleOptInMail`, `ChangeEmailDoubleOptInMail` und `CustomerVoluntaryDoubleOptInMail` der Shopkonfiguration festgelegt sind. Die beiden Anforderungs-Links gehören in den Shop.

> [!WARNING]
>
> `WS-RequestDeleteAccountDoubleOptInEmailLink` löst keine Löschung aus, sondern nur den Versand der E-Mail. Gelöscht wird erst, wenn der Käufer den Link in dieser E-Mail anklickt. Formulieren Sie den Text im Template entsprechend, damit niemand den falschen Eindruck bekommt.

### Der Registrierungscode

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
{WS-LoginRegistrationCode}
   <p>Registrierungscode: ~WS-LoginRegistrationCode~</p>
{/WS-LoginRegistrationCode}
```

Arbeitet der Shop mit einem Registrierungscode für Neukunden, gibt `WS-LoginRegistrationCode` den Code aus und klammert danach, ob einer vorliegt. `WS-LoginRegistrationCode_error` liefert den Fehlerstyle-Suffix.

Ist niemand angemeldet und im Konto kein Code hinterlegt, greift das Tag auf den in der Shopkonfiguration hinterlegten Wert zurück.

## Das Kundenkonto

| Tag | Liefert |
| - | - |
| `WS-LastLoginDate` | das Datum der letzten Anmeldung |
| `WS-LastLoginTime` | die zugehörige Uhrzeit |
| `WS-UserCredit` | den Kontostand des Kundenkontos |
| `WS-OrderCount()` | die Anzahl der Bestellungen |
| `WS-SubAccountID` | die Kennung des Unterkontos bei Mehrfachkonten |

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
{WS-LastLoginDate}
   <p>Ihr letzter Besuch war am ~WS-LastLoginDate~ um ~WS-LastLoginTime~ Uhr.</p>
{/WS-LastLoginDate}
```

> [!WARNING]
>
> Nach einer Neuregistrierung liefern `WS-LastLoginDate` und `WS-LastLoginTime` beim **ersten** Besuch nichts, denn es gibt noch keine frühere Anmeldung. Erst ab der zweiten Anmeldung erscheint der Wert. Ohne Klammerung stünde beim ersten Besuch ein Satz mit leerer Lücke auf der Seite.

### Die Anzahl der Bestellungen

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
~WS-OrderCount~             <!-- alle Bestellungen im aktiven Subshop -->
~WS-OrderCount(1y,single)~  <!-- des letzten Jahres, aktiver Subshop -->
~WS-OrderCount(6m,all)~     <!-- der letzten 6 Monate, alle verbundenen Subshops -->
```

| Nr. | Bedeutung | Werte |
| - | - | - |
| 1 | Zeitraum | Zahl plus `d` für Tage, `m` für Monate oder `y` für Jahre |
| 2 | Reichweite | `single` für den aktiven Subshop, `all` für alle verbundenen, Vorgabe `single` |

Ohne Parameter zählt das Tag alle Bestellungen im aktiven Subshop. Die Klammerung greift, wenn es überhaupt Bestellungen gibt, und berücksichtigt dabei denselben Zeitraum.

Die Zählung ist der schnellste Weg, Erstkäufer von Stammkunden zu unterscheiden, ohne die Bestellhistorie zu laden. `{!WS-OrderCount(1y)}` greift bei jedem, der im letzten Jahr nicht gekauft hat.

Es gibt die Kennung des Unterkontos aus und greift als Klammerung, wenn eine vorliegt. In einem Shop ohne Mehrfachkonten bleibt es stumm.

## Links ins Kundenkonto

| Tag | Führt zu |
| - | - |
| `WS-LoginLink` | der Anmeldeseite |
| `WS-LogoutLink` | der Abmeldung |
| `WS-UserAccountLink` | der Kundenkontoübersicht |
| `WS-AddrManageLink` | der Verwaltung der Adressdaten |
| `WS-BankManageLink` | der Verwaltung der Bankverbindungen |
| `WS-AutoLoginManageLink` | der Verwaltung der gespeicherten Anmeldungen |
| `WS-PrimePackagesManage` | der Verwaltung der Prime-Pakete |
| `WS-UserDownloadLink` | dem Downloadbereich des Käufers |
| `WS-SavedBasketsManageLink` | der Verwaltung der gespeicherten Warenkörbe |
| `WS-PPCVaultManageLink` | der Verwaltung der hinterlegten PayPal-Zahlungsmittel |

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
{ST-LoggedIn}
   <a href="~WS-UserAccountLink~">Mein Konto</a>
   <a href="~WS-AddrManageLink~">Adressen</a>
   <a href="~WS-UserDownloadLink~">Meine Downloads</a>
   <a href="~WS-LogoutLink~">Abmelden</a>
{/ST-LoggedIn}

{!ST-LoggedIn}
   <a href="~WS-LoginLink~">Anmelden</a>
{/!ST-LoggedIn}
```

> [!WARNING]
>
> Das Beispiel auf der bisherigen Seite zu `WS-UserDownloadLink` schreibt `<a href="~WS-UserDownloadLink~>` ohne schließendes Anführungszeichen. Das zerlegt das Element im Browser. Oben steht die berichtigte Fassung.

Die meisten dieser Links sind nur für einen angemeldeten Käufer sinnvoll. Legen Sie sie in `{ST-LoggedIn}`, statt sich darauf zu verlassen, dass das Shopsystem den nicht angemeldeten Besucher ohnehin zur Anmeldung schickt.

Drei dieser Tags bringen ihre eigene Prüfung mit und greifen zusätzlich als Klammerung. `WS-BankManageLink` greift nur, wenn das Speichern von Bankverbindungen freigeschaltet ist. `WS-SavedBasketsManageLink` greift nur bei angemeldetem Käufer. `WS-PPCVaultManageLink` greift nur, wenn das Hinterlegen von PayPal-Zahlungsmitteln erlaubt ist.

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
{WS-BankManageLink}
   <a href="~WS-BankManageLink~">Ihre gespeicherten Bankverbindungen</a>
{/WS-BankManageLink}
```

Beide erzeugen eine vollständige Adresse über HTTPS.

`WS-OSBLink` fällt aus der Reihe: Es führt nicht ins Kundenkonto, sondern in den Online-Servicebereich des Shopbetreibers, und es gehört in die Bestelleingangs-E-Mail an den Shopbetreiber. Die Adresse stammt aus der Shopkonfiguration.

## Die Kundensuche des SuperUsers

```html theme={"theme":{"light":"github-light","dark":"github-dark"},"languages":{"custom":["/languages/websale.json"]}}
<form action="~FORM-UserSearch~" method="post">
   <input type="text" name="~WS-UserSearch_Input~" value="~WS-UserSearch~">
   <select name="user_search_type">
      <option value="Name">Name</option>
      <option value="Email">E-Mail-Adresse</option>
      <option value="Number">Kundennummer</option>
   </select>
   <input type="submit" value="Suchen">
</form>

{CAT-AdvData($UserSearch,999)}
   <p>Die Suche ergab ~WS-UserSearchResults~ Treffer.</p>
   ...
{/CAT-AdvData($UserSearch,999)}
```

| Tag | Liefert |
| - | - |
| `WS-UserSearch_Input` | den HTML-Namen des Suchfeldes |
| `WS-UserSearch` | die bisherige Eingabe |
| `WS-UserSearchType` | die gewählte Suchart |
| `WS-UserSearchResults` | die Anzahl der Treffer |
| `WS-SuperUserID` | die Kennung des angemeldeten SuperUsers |

> [!WARNING]
>
> Die Auswahlliste für die Suchart trägt den **festen** Namen `user_search_type`. Dafür gibt es kein eigenes Tag. `WS-UserSearchType` gibt nur den gewählten Wert zurück, damit ein JavaScript die richtige Option wieder markieren kann.
>
> Im Shopsystem und in den eigenen Beispielen der Quelle heißt es `WS-SuperUserID`. Nur diese Schreibweise funktioniert.

Referenz: Die Trefferliste selbst bauen Sie mit den `UL-`Tags, beschrieben auf UL- (SuperUser)

## Die Tags im Überblick

| Tag | Einzel-Tag | Bereichs-Tag | negatives Bereichs-Tag | Schleifen-Tag |
| - | - | - | - | - |
| `WS-UserID`, `WS-Email`, `WS-NewEmail`, `WS-EmailAgain` | ja | – | – | – |
| `WS-PW`, `WS-NewPW`, `WS-PWAgain` | ja | – | – | – |
| alle zugehörigen `_input`-Tags | ja | – | – | – |
| alle zugehörigen `_error`-Tags | ja | ja | ja | – |
| `WS-PWRequestZip` | ja | – | – | – |
| `WS-RequestPWLink` | ja | – | – | – |
| `WS-SecureLoginConfigurationJS` | ja | – | – | – |
| `WS-StaySignedIn_input` | ja | – | – | – |
| `WS-StayFullySignedIn_input` | ja | – | – | – |
| `WS-UserRequiresReAuthForCritAction` | – | ja | ja | – |
| `WS-CombinedLogin_radioname` | ja | – | – | – |
| `WS-CombinedLogin_radiovalue_*` | ja | – | – | – |
| `WS-CombinedLogin_radioselected_*` | ja | ja | ja | – |
| `WS-CombinedLogin_eMail` und die drei Passwortfelder | ja | ja | ja | – |
| `WS-CombinedLogin_*_input` | ja | – | – | – |
| `WS-CombinedLogin_*_error` | ja | ja | ja | – |
| `WS-CreateAccountAfterGuestOrder_pw` und `_pwagain` | ja | ja | ja | – |
| `WS-CreateAccountAfterGuestOrder_*_input` | ja | – | – | – |
| `WS-CreateAccountAfterGuestOrder_*_error` | ja | ja | ja | – |
| `WS-CreateAccountAfterGuestOrder_cancellink` | ja | – | – | – |
| `WS-ExternLogin_facebook_connect_email` | ja | ja | ja | – |
| `WS-ExternLogin_facebook_connect_email_input` | ja | – | – | – |
| `WS-ExternLogin_facebook_connect_email_error` | ja | ja | ja | – |
| `WS-ExternLogin_facebook_Connect_pw_input` | ja | – | – | – |
| `WS-ExternLogin_facebook_Connect_pw_error` | ja | ja | ja | – |
| `WS-ExternLogin_facebook_Connect_pw_needed` | – | ja | ja | – |
| `WS-DoubleOptInLink` | ja | ja | ja | – |
| `WS-VoluntaryDoubleOptInVerificationLink` | ja | ja | ja | – |
| `WS-RequestVoluntaryDoubleOptInEmailLink` | ja | ja | ja | – |
| `WS-RequestDeleteAccountDoubleOptInEmailLink` | ja | – | – | – |
| `WS-EmailVerified` | – | ja | ja | – |
| `WS-LoginRegistrationCode` | ja | ja | ja | – |
| `WS-LoginRegistrationCode_error` | ja | ja | ja | – |
| `WS-LastLoginDate`, `WS-LastLoginTime` | ja | ja | ja | – |
| `WS-UserCredit` | ja | – | – | – |
| `WS-OrderCount()` | ja | ja | ja | – |
| `WS-SubAccountID` | ja | ja | ja | – |
| `WS-LoginLink`, `WS-LogoutLink`, `WS-UserAccountLink` | ja | – | – | – |
| `WS-AddrManageLink`, `WS-AutoLoginManageLink`, `WS-UserDownloadLink` | ja | – | – | – |
| `WS-OSBLink` | ja | – | – | – |
| `WS-BankManageLink` | ja | ja | ja | – |
| `WS-PrimePackagesManage` | ja | ja | ja | – |
| `WS-SavedBasketsManageLink` | ja | ja | ja | – |
| `WS-PPCVaultManageLink` | ja | ja | ja | – |
| `WS-UserSearch`, `WS-UserSearch_Input`, `WS-UserSearchType`, `WS-UserSearchResults` | ja | – | – | – |
| `WS-SuperUserID` | ja | ja | ja | – |
| `WS-AppLoginErrorCode` | ja | ja | ja | – |

Die Anmelde- und Registrierungsfelder gelten auf dem Login-Template, die `CombinedLogin`-Familie dort im Bereich `LoginUser`. `WS-BankManageLink` und `WS-PrimePackagesManage` gelten auf der Kundenkontoübersicht, `WS-DoubleOptInLink` und `WS-VoluntaryDoubleOptInVerificationLink` in den zugehörigen E-Mail-Templates, `WS-OSBLink` in der Bestelleingangs-E-Mail an den Shopbetreiber, die Tags der Kundensuche auf deren Template. Alle übrigen sind auf allen Templates zulässig.

## Verwandte Themen

* Wegweiser: [Anmeldung und Registrierung](https://dokumentation.websale.de/v8s/kundenkonto/anmeldung-registrierung.md)
* Wegweiser: Dauerhafter Login
* Wegweiser: [Double-OptIn](https://dokumentation.websale.de/v8s/kundenkonto/anmeldung-registrierung.md#double-optin)
* Wegweiser: [Passwort vergessen](https://dokumentation.websale.de/v8s/kundenkonto/anmeldung-registrierung.md#passwort-vergessen)
* Wegweiser: [SuperUser-Funktion](https://dokumentation.websale.de/v8s/kundenkonto/anmeldung-registrierung.md#superuser-funktion)
* Referenz: [UL- (SuperUser)](https://dokumentation.websale.de/v8s/referenz/tags/ul-superuser.md)


## Related topics

- [Kunde, Anmeldung und Kundenkonto](https://dokumentation.websale.de/v8s/referenz/konfigurationen/shopkonfiguration-shop-config/kunde-anmeldung-und-kundenkonto.md)
- [Anmeldung und Registrierung](https://dokumentation.websale.de/v8s/kundenkonto/anmeldung-registrierung.md)
- [Schaltflächen für Kundenkonto und Anmeldung](https://dokumentation.websale.de/v8s/referenz/tags/bt/kundenkonto-und-anmeldung.md)
- [DA- (Kundenkonto löschen)](https://dokumentation.websale.de/v8s/referenz/tags/da-kundenkonto-loeschen.md)
- [MSG- (Meldungen)](https://dokumentation.websale.de/v8s/referenz/tags/msg-meldungen.md)


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