Standardreihenfolge je Universum festlegen

Ein Universum kann mehrere Reihenfolgen haben, aber welche beim Oeffnen
erschien, liess sich nicht bestimmen — es war immer die
Erscheinungsreihenfolge. Das Feld isDefault gab es schon und wurde beim
Oeffnen auch ausgewertet; es fehlte nur der Weg, es zu setzen.

Der Standard gehoert dem Universum, nicht der einzelnen Person: wer
Schreibrecht hat, legt ihn fuer alle fest — so wie die Reihenfolgen selbst
auch geteilt sind. Die Rangfolge bleibt dadurch die schlichte: die Adresse
schlaegt den Standard schlaegt die erste.

setDefaultOrder() setzt zurueck und neu in einer Transaktion, damit nie zwei
Standards nebeneinander stehen. deleteOrder() faengt jetzt den Fall ab, dass
die Standardreihenfolge geloescht wird — dann uebernimmt die
Erscheinungsreihenfolge, statt dass die Auswahl auf "die erste" faellt.

Ueber die Schnittstelle geht es per PATCH /api/v1/universen/{id}. Der
Endpunkt prueft, dass die Reihenfolge zu genau diesem Universum gehoert:
ohne das setzte ein PATCH auf A den Standard in B, weil die Domaenenschicht
das Universum aus der Reihenfolge ableitet.

Vier Tests dazu: Umstellen samt Eindeutigkeit, Vorrang der Adresse,
Rueckfall beim Loeschen, Rechtepruefung. Klickweg und Endpunkt gegen einen
Produktionsbau geprueft.

Refs #4

tests/universes.test.ts

@@ -12,9 +12,11 @@ import {
   addTitle,
   createOrder,
   createUniverse,
+  deleteOrder,
   getAccess,
   getUniverse,
   listUniverses,
+  setDefaultOrder,
   setOrderPositions,
   shareUniverse,
   trashUniverse,
@@ -280,3 +282,72 @@ test("gelöschte Universen verschwinden aus der Übersicht", async () => {
   const list = await listUniverses(ownerId);
   assert.equal(list.find((item) => item.id === universe.id), undefined);
 });
+
+// --- Standardreihenfolge ------------------------------------------------------
+
+test("die Standardreihenfolge lässt sich umstellen und bleibt eindeutig", async () => {
+  const universe = await createUniverse(ownerId, "Standardwechsel");
+  await addCollection(ownerId, universe.id, COLLECTION_ID);
+  const order = await createOrder(ownerId, universe.id, "Chronologisch");
+
+  // Frisch angelegt führt die Erscheinungsreihenfolge.
+  const vorher = await getUniverse(ownerId, universe.id);
+  assert.equal(vorher?.orders.find((o) => o.isDefault)?.kind, "RELEASE");
+
+  await setDefaultOrder(ownerId, order.id);
+
+  // Ohne Angabe in der Adresse erscheint jetzt die eigene Reihenfolge.
+  const nachher = await getUniverse(ownerId, universe.id);
+  assert.equal(nachher?.activeOrderId, order.id);
+
+  const standards = nachher!.orders.filter((o) => o.isDefault);
+  assert.equal(standards.length, 1, "es steht immer genau ein Standard");
+  assert.equal(standards[0]!.id, order.id, "und zwar der zuletzt gesetzte");
+});
+
+test("die Adresse schlägt die Standardreihenfolge", async () => {
+  const universe = await createUniverse(ownerId, "Adressvorrang");
+  await addCollection(ownerId, universe.id, COLLECTION_ID);
+  const order = await createOrder(ownerId, universe.id, "Chronologisch");
+  await setDefaultOrder(ownerId, order.id);
+
+  const release = (await getUniverse(ownerId, universe.id))!.orders.find(
+    (o) => o.kind === "RELEASE",
+  )!;
+  const view = await getUniverse(ownerId, universe.id, release.id);
+
+  assert.equal(view?.activeOrderId, release.id, "die angeforderte gewinnt gegen den Standard");
+});
+
+test("wird die Standardreihenfolge gelöscht, übernimmt die Erscheinungsreihenfolge", async () => {
+  const universe = await createUniverse(ownerId, "Rueckfall");
+  await addCollection(ownerId, universe.id, COLLECTION_ID);
+  const order = await createOrder(ownerId, universe.id, "Chronologisch");
+  await setDefaultOrder(ownerId, order.id);
+
+  await deleteOrder(ownerId, order.id);
+
+  const view = await getUniverse(ownerId, universe.id);
+  const standards = view!.orders.filter((o) => o.isDefault);
+  assert.equal(standards.length, 1, "das Universum bleibt nicht ohne Standard zurück");
+  assert.equal(standards[0]!.kind, "RELEASE");
+  assert.equal(view?.activeOrderId, standards[0]!.id);
+});
+
+test("den Standard setzen darf nur, wer schreiben darf", async () => {
+  const universe = await createUniverse(ownerId, "Rechteprobe");
+  await addCollection(ownerId, universe.id, COLLECTION_ID);
+  const order = await createOrder(ownerId, universe.id, "Chronologisch");
+
+  await shareUniverse(ownerId, universe.id, GUEST_EMAIL, "READ");
+  await assert.rejects(() => setDefaultOrder(guestId, order.id), /nur ansehen/);
+
+  // Der Standard steht danach unverändert auf der Erscheinungsreihenfolge.
+  const unveraendert = await getUniverse(ownerId, universe.id);
+  assert.equal(unveraendert?.orders.find((o) => o.isDefault)?.kind, "RELEASE");
+
+  // Mit Schreibrecht geht es dann.
+  await shareUniverse(ownerId, universe.id, GUEST_EMAIL, "WRITE");
+  await setDefaultOrder(guestId, order.id);
+  assert.equal((await getUniverse(guestId, universe.id))?.activeOrderId, order.id);
+});