Zuweisen: Warnungen statt Abbruch, Zuweisung unter der Projekt-Sperre

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

server/services/projectAssignment.js

@@ -1,11 +1,21 @@
 import { config } from '../config.js'
 import { moveRepoToOrg, WARN } from './repoMove.js'
+import { splitRepo } from './giteaClient.js'
 import { listRecentPushes } from './pushHistory.js'
 import { createGitPushWorksheet, isSystemPusher } from './gitWorksheet.js'
 import { withLocks } from './keyedLock.js'
 import { ensureProjectTicket } from './ticketAdmin.js'
 import { getDocument, updateDocument } from './appwriteAdmin.js'
 
+/**
+ * Warnungen dieses Moduls, woertlich (Controller-Ruling R14, Fix-Runde 1) - Anfuehrungszeichen
+ * wie die bestehenden Warnungen in repoMove.js (‚...‘ mit U+201A/U+2018).
+ */
+const WARN_BACKFILL_FAILED = (reason) =>
+  `Pushes konnten nicht nachgetragen werden (${reason}). Bitte später ‚Pushes nachtragen‘ klicken.`
+const WARN_RECONCILE_FAILED = (reason) =>
+  `Zuweisung gespeichert, aber Umzug und Nachtragen sind fehlgeschlagen (${reason}). Bitte später ‚Pushes nachtragen‘ klicken.`
+
 /**
  * Commit-Nachrichten (erste Zeile), die frueher das System mit Kensos Schluessel geschrieben hat
  * (Preview-Config, automatisch erstellte Preview-Seite) - siehe Plan, Abschnitt "Global
@@ -42,65 +52,132 @@ export async function backfillPushes(project, { now = new Date() } = {}) {
   try {
     pushes = await listRecentPushes(project.repoFullName, { now })
   } catch (err) {
-    return { backfilled: 0, warnings: [WARN.giteaDown(err.message)] }
+    return { backfilled: 0, warnings: [WARN.giteaDown(err.message)], ticketId: project.ticketId || '' }
   }
 
   const relevant = pushes.filter((push) => !isSystemPusher(push.pusher) && !isOldSystemCommitPush(push))
-  if (relevant.length === 0) return { backfilled: 0, warnings: [] }
-
-  const ticketId = project.ticketId || (await ensureProjectTicket(project, { repoFullName: project.repoFullName }))
-  if (!ticketId) return { backfilled: 0, warnings: [] }
+  if (relevant.length === 0) return { backfilled: 0, warnings: [], ticketId: project.ticketId || '' }
 
+  // `ensureProjectTicket` und die Arbeitsblatt-Schleife sind hier bewusst in EINEM try/catch
+  // (Controller-Ruling R14): schlaegt eine der beiden Appwrite-Schreiboperationen fehl (z. B.
+  // Ausfall waehrend POST workorders/worksheets), bleibt die Zuweisung trotzdem bestehen - siehe
+  // `assignProject`, das sich darauf verlaesst, dass `backfillPushes` nie wirft.
+  let ticketId = project.ticketId || ''
   let backfilled = 0
-  // Aelteste zuerst (siehe `listRecentPushes`), damit die Arbeitsblaetter in derselben
-  // Reihenfolge entstehen, in der die Pushes tatsaechlich passiert sind.
-  for (const push of relevant) {
-    const result = await createGitPushWorksheet({ ticketId, repoFullName: project.repoFullName, ...push })
-    if (result?.created) backfilled += 1
+  try {
+    ticketId = ticketId || (await ensureProjectTicket(project, { repoFullName: project.repoFullName }))
+    if (!ticketId) return { backfilled: 0, warnings: [], ticketId: '' }
+
+    // Aelteste zuerst (siehe `listRecentPushes`), damit die Arbeitsblaetter in derselben
+    // Reihenfolge entstehen, in der die Pushes tatsaechlich passiert sind.
+    for (const push of relevant) {
+      const result = await createGitPushWorksheet({ ticketId, repoFullName: project.repoFullName, ...push })
+      if (result?.created) backfilled += 1
+    }
+    return { backfilled, warnings: [], ticketId }
+  } catch (err) {
+    return { backfilled, warnings: [WARN_BACKFILL_FAILED(err.message)], ticketId }
   }
-  return { backfilled, warnings: [] }
 }
 
 /**
+ * Kern von `reconcileProject`, OHNE selbst die Sperre zu nehmen - fuer `assignProject`, das
+ * seine eigene Lese-Pruef-Schreib-Folge und diesen Kern unter DERSELBEN Sperre laufen laesst
+ * (Controller-Ruling R15), statt die Sperre zweimal zu nehmen. `reconcileProject` (unten) bleibt
+ * der oeffentliche, selbst sperrende Einstieg (z. B. fuer die Migration, Task 9).
+ *
  * Liest das Projekt, verschiebt sein Repo bei Bedarf nach `GITEA_ORG` und traegt danach dessen
- * Pushes nach - alles unter der Projekt-Sperre, damit ein Doppelklick auf "Zuweisen" (oder ein
- * gleichzeitiger Aufruf ueber die Migration, Task 9) nicht zweimal umzieht oder doppelte
- * Arbeitsblaetter erzeugt (Review Focus 3, Plan). Das Projektdokument wird ERST innerhalb der
- * Sperre gelesen, damit ein zweiter, gleichzeitiger Aufruf nie mit einem inzwischen veralteten
- * Objekt arbeitet.
+ * Pushes nach. Wirft nur noch, wenn schon das ERSTE Lesen des Projekts fehlschlaegt (dann gibt es
+ * nichts Sinnvolles zu verschieben/nachzutragen) - `assignProject` faengt das ab (R14).
  */
-export async function reconcileProject(projectId, { now } = {}) {
-  return withLocks(['project:' + projectId], async () => {
-    let project = await getDocument(config.collections.websiteProjects, projectId)
-    const { moved, warnings: moveWarnings } = await moveRepoToOrg(project)
+async function reconcileProjectLocked(projectId, { now } = {}) {
+  let project = await getDocument(config.collections.websiteProjects, projectId)
+  const { moved, warnings: moveWarnings } = await moveRepoToOrg(project)
 
+  try {
     // Immer neu lesen, nicht nur wenn `moved` gesetzt ist: der Selbstheilungs-Zweig in
     // `moveRepoToOrg` (von Hand verschobenes/umbenanntes Repo) kann das Dokument umbenennen und
     // dabei trotzdem `moved: null` liefern (Controller-Ruling R13).
     project = await getDocument(config.collections.websiteProjects, projectId)
+  } catch {
+    // R14: Schlaegt das Nachlesen fehl, mit dem VOR dem Umzug gelesenen Dokument weitermachen -
+    // ist tatsaechlich etwas verschoben worden, von Hand dessen `repoFullName`/`giteaRepoUrl`/
+    // `giteaRepoName` nachziehen (siehe `updateProjectDocument` in repoMove.js). Keine zusaetzliche
+    // Warnung - `moveWarnings` deckt einen etwaigen Gitea-Ausfall bereits ab.
+    if (moved) {
+      project = {
+        ...project,
+        repoFullName: moved.to,
+        giteaRepoUrl: `${config.gitea.baseUrl}/${moved.to}`,
+        giteaRepoName: splitRepo(moved.to)[1],
+      }
+    }
+  }
 
-    const { backfilled, warnings: backfillWarnings } = await backfillPushes(project, { now })
+  const { backfilled, warnings: backfillWarnings, ticketId } = await backfillPushes(project, { now })
+  // R15: die Antwort soll die (evtl. gerade erst automatisch angelegte) ticketId zeigen, auch
+  // wenn `project` oben vor dem Anlegen gelesen wurde.
+  if (ticketId && project.ticketId !== ticketId) project = { ...project, ticketId }
 
-    return { project, moved, backfilled, warnings: [...moveWarnings, ...backfillWarnings] }
-  })
+  return { project, moved, backfilled, warnings: [...moveWarnings, ...backfillWarnings] }
 }
 
 /**
- * Weist ein Projekt einem Kunden/Ticket zu und stoesst danach Umzug + Nachtragen an. Die
- * Zuweisung selbst wird ZUERST und ausserhalb der Projekt-Sperre gespeichert (reines Appwrite,
- * ohne Gitea) - sie bleibt deshalb bestehen, selbst wenn Gitea gerade nicht erreichbar ist
- * (siehe `reconcileProject`/`moveRepoToOrg`, die deshalb nie wegen Gitea werfen duerfen).
+ * Oeffentlicher, selbst sperrender Einstieg fuer den Kern oben - damit ein Doppelklick auf
+ * "Zuweisen" (oder ein gleichzeitiger Aufruf ueber die Migration, Task 9) nicht zweimal umzieht
+ * oder doppelte Arbeitsblaetter erzeugt (Review Focus 3, Plan).
+ */
+export async function reconcileProject(projectId, { now } = {}) {
+  return withLocks(['project:' + projectId], () => reconcileProjectLocked(projectId, { now }))
+}
+
+/**
+ * Ticket-Id fuer die Zuweisung (Controller-Ruling R15): eine mitgegebene `ticketId` gewinnt immer.
+ * Ist sie leer UND bleibt die Kunden-Id gleich, bleibt die gespeicherte `ticketId` erhalten - ein
+ * Entfernen laeuft ueber "Zuweisung aufheben", nicht ueber diesen Endpunkt (sonst loescht ein
+ * zweiter Klick ohne `ticketId` ein zwischenzeitlich automatisch angelegtes Ticket, Review I3).
+ * Aendert sich die Kunden-Id und wird keine `ticketId` mitgegeben, wird sie geleert.
+ */
+function resolveTicketId(payloadTicketId, customerId, existing) {
+  if (payloadTicketId) return payloadTicketId
+  if (customerId === existing.customerId) return existing.ticketId || ''
+  return ''
+}
+
+/**
+ * Weist ein Projekt einem Kunden/Ticket zu und stoesst danach Umzug + Nachtragen an. Laeuft
+ * komplett unter der Projekt-Sperre (Controller-Ruling R15): Lesen (fuer die 404-Pruefung und die
+ * `ticketId`-Aufloesung), Schreiben der Zuweisung und der Reconcile-Kern teilen sich dieselbe
+ * Sperre, statt sie zweimal zu nehmen - ein zweiter, gleichzeitiger Aufruf sieht daher nie einen
+ * veralteten Stand. Ein unbekanntes Projekt wirft weiterhin (`.status = 404`) BEVOR irgendetwas
+ * geschrieben wird. Schlaegt danach der Reconcile-Kern (Umzug/Nachtragen) mit etwas anderem als
+ * einem 404 fehl, bleibt die Zuweisung trotzdem gespeichert - Ruling R14 verlangt eine Warnung
+ * statt eines Abbruchs, denn Spec 5.2 verlangt genau das.
  */
 export async function assignProject(projectId, { customerId = '', ticketId = '' }, { now } = {}) {
-  // 404 fuer ein unbekanntes Projekt, bevor ueberhaupt geschrieben wird.
-  await getDocument(config.collections.websiteProjects, projectId)
+  return withLocks(['project:' + projectId], async () => {
+    // 404 fuer ein unbekanntes Projekt, bevor ueberhaupt geschrieben wird.
+    const existing = await getDocument(config.collections.websiteProjects, projectId)
 
-  await updateDocument(config.collections.websiteProjects, projectId, {
-    customerId,
-    ticketId,
-    updatedAt: new Date().toISOString(),
+    const nextTicketId = resolveTicketId(ticketId, customerId, existing)
+    const saved = await updateDocument(config.collections.websiteProjects, projectId, {
+      customerId,
+      ticketId: nextTicketId,
+      updatedAt: new Date().toISOString(),
+    })
+
+    try {
+      const result = await reconcileProjectLocked(projectId, { now })
+      return { ok: true, ...result }
+    } catch (err) {
+      if (err.status === 404) throw err
+      return {
+        ok: true,
+        project: saved,
+        moved: null,
+        backfilled: 0,
+        warnings: [WARN_RECONCILE_FAILED(err.message)],
+      }
+    }
   })
-
-  const { project, moved, backfilled, warnings } = await reconcileProject(projectId, { now })
-  return { ok: true, project, moved, backfilled, warnings }
 }