Bei einer belegten SteamID sagen, wem sie gehoert

"Diese SteamID ist bereits einem Spieler zugeordnet" liess offen, welchem -
und damit blieb nur, den Bestand von Hand durchzusuchen. Die Meldung nennt
jetzt den Namen und sagt auch, ob die Kennung dort die aktuelle ist oder als
frueheres Konto haengt.

Dabei fiel auf, dass die Pruefung nur die Hauptangaben ansah. Eine Kennung,
die bei jemandem als frueheres Konto eingetragen war, liess sich bei einem
anderen als aktuelle vergeben - und danach wuesste weder der Abgleich noch
der Import, wem ein Kauf gehoert. Beides wird jetzt geprueft, in beide
Richtungen: beim Anlegen und Bearbeiten eines Spielers ebenso wie beim
Nachtragen eines frueheren Kontos.

server/src/services/players.ts

@@ -192,11 +192,49 @@ function canonicalSteamId(input: string | null | undefined): string | null {
   return normalized;
 }
 
-async function assertSteamIdFree(steamId: string, exceptId?: number): Promise<void> {
-  const existing = await prisma.player.findUnique({ where: { steamId }, select: { id: true } });
-  if (existing && existing.id !== exceptId) {
-    throw conflict('STEAMID_TAKEN', 'Diese SteamID ist bereits einem Spieler zugeordnet');
+/**
+ * Wer diese SteamID schon führt - als Hauptangabe oder als früheres Konto.
+ *
+ * Beides muss geprüft werden: Eine Kennung, die bei einem Spieler als
+ * früheres Konto hängt, gehört ihm genauso. Stünde sie daneben bei einem
+ * anderen als Hauptangabe, wüsste weder der Abgleich noch der Import, wem
+ * ein Kauf gehört.
+ */
+async function findeSteamIdInhaber(
+  steamId: string,
+  exceptId?: number,
+): Promise<{ id: number; displayName: string; alsAlias: boolean } | null> {
+  const haupt = await prisma.player.findUnique({
+    where: { steamId },
+    select: { id: true, displayName: true },
+  });
+  if (haupt && haupt.id !== exceptId) return { ...haupt, alsAlias: false };
+
+  const alias = await prisma.playerAlias.findUnique({
+    where: { type_value: { type: AliasType.STEAM_ID, value: steamId } },
+    select: { playerId: true, player: { select: { displayName: true } } },
+  });
+  if (alias && alias.playerId !== exceptId) {
+    return { id: alias.playerId, displayName: alias.player.displayName, alsAlias: true };
   }
+
+  return null;
+}
+
+/**
+ * Stellt sicher, dass die Kennung frei ist - und sagt sonst, bei wem sie
+ * liegt. Ohne den Namen sucht man von Hand durch den ganzen Bestand.
+ */
+async function assertSteamIdFree(steamId: string, exceptId?: number): Promise<void> {
+  const inhaber = await findeSteamIdInhaber(steamId, exceptId);
+  if (!inhaber) return;
+
+  throw conflict(
+    'STEAMID_TAKEN',
+    inhaber.alsAlias
+      ? `Diese SteamID ist bei "${inhaber.displayName}" als früheres Konto eingetragen`
+      : `Diese SteamID gehört bereits zu "${inhaber.displayName}"`,
+  );
 }
 
 export async function createPlayer(input: PlayerInput, ctx: ActionContext) {
@@ -419,6 +457,21 @@ export async function addAlias(
     );
   }
 
+  // Auch die Hauptangaben der anderen: dieselbe Kennung kann nicht bei einem
+  // als früheres Konto und beim nächsten als aktuelles stehen.
+  if (type === AliasType.STEAM_ID) {
+    const fremd = await prisma.player.findUnique({
+      where: { steamId: value },
+      select: { id: true, displayName: true },
+    });
+    if (fremd && fremd.id !== playerId) {
+      throw conflict(
+        'ALIAS_TAKEN',
+        `Diese SteamID ist die aktuelle Kennung von "${fremd.displayName}"`,
+      );
+    }
+  }
+
   const created = await prisma.playerAlias.create({
     data: { playerId, type, value, note: note?.trim() || null },
   });