feat(2.7.0): Roadmap im DC, Testinstanz mit Testtor, Supervisor und MCP
Sammelcommit fuer den ueber mehrere Sitzungen gewachsenen, bisher nicht
eingecheckten Stand. Getrennte Commits waeren ehrlicher gewesen, sind es
nachtraeglich aber nicht mehr: BugRepo, changelog.json und die Doku tragen
Aenderungen aus allen Straengen gleichzeitig, und keine Zwischenstufe waere
lauffaehig.
ROADMAP IM DEPLOYMENTCENTER (2.7.0)
Planungsstand, Reihenfolge und Zustaendigkeit lagen in handgepflegten
Markdown-Dateien neben einem Bugtracker, der genau diese drei Dinge bereits
fuehrt. Zwei Pfleger fuer dasselbe Feld - Drift war eine Frage der Zeit.
Ab jetzt: Zustand im DC, Begruendung in der Datei. Kein Feld hat zwei Pfleger.
- Migration 016: epic, roadmap_rank, target_build, defer_trigger,
doc_anchor, Status "deferred", Tabelle roadmap_epics.
KEINE Roadmap-Tabelle - ein Eintrag ist ein bugtracker_item.
- Zugehoerigkeit ist ein Feld: Ein Item steht auf der Roadmap, wenn es ein
epic hat. Ein zweites Kennzeichen daneben koennte auseinanderlaufen.
- Kennung ist die Item-ID. Handvergebene Kuerzel ("A12") erzeugen die
schlimmste Fehlerart: Beide Seiten stimmig, Verschiedenes gemeint, weil
die Kennung nach einer Loeschung neu vergeben wurde.
- Zurueckstellen verlangt defer_trigger. Ohne benannten Anlass ist ein
Vorhaben nicht zurueckgestellt, sondern vergessen. Die Regel sitzt im
Repository, damit sie auf allen drei Schreibwegen gleich greift.
- Modules/Bugtracker/Roadmap.php, /api/bugtracker/v1/roadmap.php,
WebUI-Modul mit Filtern, cli/roadmap.php --write/--check,
dc_roadmap und dc_roadmap_set im MCP-Adapter.
- cli/roadmap.php --write ERZEUGT den Zustandsteil der Markdown-Datei;
--check prueft nur die Prosa. Was erzeugt wird, kann nicht driften.
- docs/ROADMAP_MIGRATION.md: Uebernahme fuer die anderen Projekte.
TESTINSTANZ UND TESTTOR
- dc-dev.mhdf.de: zweite Installation, eigene DB, eigene Schluessel,
Basic-Auth davor, Rocket.Chat aus.
- 124 Testfaelle in tests/e2e gegen API, Rechte, Migrationen, Sperre.
- scripts/deploy.py bringt vor jedem Upload erst den anstehenden Stand auf
die Testinstanz und laesst dann den Testlauf laufen. Erst bei
Rueckgabewert 0 geht etwas auf die Produktion (--ohne-test als Notausgang).
Andersherum prueft der Lauf aelteren Code als den, der gleich hochgeht.
- tests/ ist aus dem Produktiv-Deploy ausgeschlossen; testctl.php kann
nicht versehentlich auf dc.mhdf.de landen.
- Ein Lauf mit mehr uebersprungenen als geprueften Faellen endet mit
Rueckgabewert 2 statt 0. Nichts ist kaputt, geprueft wurde es aber auch
nicht - der Unterschied darf nicht am Rueckgabewert verschwinden.
SUPERVISOR, PROJEKTLANDSCHAFT, NACHPRUEFUNG (2.6.0/2.6.1)
- Migration 013: projektuebergreifend melden (dev_agent, evidence,
triage_external, affects).
- Migration 014: supervisor_findings, Katalog, fuenf serverseitige
Detektoren im Tick.
- Migration 015: Nachpruefung als Arbeitsschlange statt Benachrichtigung.
- DEV-Lizenzschluessel zur Selbstbedienung, dc-testkit fuer die Test-VM.
- MCP-Adapter: 15 Werkzeuge, ohne Fremdabhaengigkeiten, mit Abgrenzung
von Fremddaten gegen Prompt-Injektion.
BEHOBEN
- observe und status im Supervisor legten den Zustand des Befundes als
"status" in die Antwort. Http::ok() merged ['status' => 'success']
darunter, also gewann der Befundzustand - eine angenommene Meldung kam
als status="open" an. Heisst jetzt finding_status. War Item #59.
Migrationen 013-016 sind auf dem Produktivserver noch NICHT ausgefuehrt.
Ohne sie bricht das WebUI, weil die Roadmap-Ansicht bei jedem Seitenaufruf
gegen bugtracker_items.epic abfragt.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Deploymentcenter Bot
co-authored by
Claude Opus 5
Claude Opus 5
parent
9d0261306c
commit
1d5ac92051
@@ -60,7 +60,19 @@ if ($isWrite && $method !== 'POST') {
|
||||
|
||||
$context = ApiAuth::requireScope($db, $isWrite ? 'bugtracker:manage' : 'bugtracker:read');
|
||||
$author = $context['actor'];
|
||||
|
||||
// Zwei Einschraenkungen, weil Lesen und Schreiben hier verschieden weit reichen.
|
||||
//
|
||||
// $boundProject gilt beim Schreiben und kennt keine Ausnahme: auch ein
|
||||
// Werkbank-Token uebernimmt und schliesst nur Items im eigenen Projekt. Sonst
|
||||
// zoege ein Agent, der in Projekt X arbeitet, ueber ?action=next Arbeit aus
|
||||
// einem fremden Backlog an sich.
|
||||
//
|
||||
// $readProject gilt beim Lesen und laesst Werkbank-Token durch: ein Agent, der
|
||||
// entscheiden soll, ob ein Fehler ins eigene oder ins fremde Projekt gehoert,
|
||||
// muss die Landschaft sehen.
|
||||
$boundProject = ApiAuth::projectFilter($context);
|
||||
$readProject = ApiAuth::projectFilter($context, true);
|
||||
|
||||
$itemId = resolveItemId();
|
||||
|
||||
@@ -72,7 +84,11 @@ switch ($action) {
|
||||
// no break - Http::ok beendet die Anfrage
|
||||
|
||||
case 'stats':
|
||||
$slug = Http::str('project_slug') ?? $boundProject;
|
||||
// Die Bindung geht der Anfrage vor. Vorher stand hier
|
||||
// "Http::str('project_slug') ?? $boundProject" - damit konnte ein an
|
||||
// Projekt X gebundenes Token die Zahlen jedes anderen Projekts abrufen,
|
||||
// indem es den Slug einfach mitschickte.
|
||||
$slug = $readProject ?? Http::str('project_slug');
|
||||
Http::ok(['stats' => $repo->getStats($slug)]);
|
||||
|
||||
case 'get':
|
||||
@@ -81,11 +97,11 @@ switch ($action) {
|
||||
if ($item === null) {
|
||||
Http::fail(404, 'not_found', sprintf('Item #%d existiert nicht.', $itemId));
|
||||
}
|
||||
ApiAuth::enforceProject($context, (string)$item['project_slug']);
|
||||
ApiAuth::enforceProject($context, (string)$item['project_slug'], true);
|
||||
Http::ok(['item' => $item]);
|
||||
|
||||
case 'list':
|
||||
$filters = collectFilters($boundProject);
|
||||
$filters = collectFilters($readProject);
|
||||
$result = $repo->getItems($filters);
|
||||
Http::ok([
|
||||
'count' => count($result['items']),
|
||||
@@ -113,6 +129,14 @@ switch ($action) {
|
||||
|
||||
case 'next':
|
||||
$filters = collectFilters($boundProject);
|
||||
|
||||
// Der Rueckkanal: zusaetzlich zu den eigenen Items auch fremde, die auf
|
||||
// Nachpruefung warten und bei denen dieses Projekt als betroffen
|
||||
// vermerkt ist. Nur dort - siehe assertProject().
|
||||
if ($boundProject !== null) {
|
||||
$filters['include_affected_verification'] = $boundProject;
|
||||
}
|
||||
|
||||
$limit = Http::int('limit', 1);
|
||||
$claimedItems = $repo->claimNext($author, $filters, $limit);
|
||||
Http::ok([
|
||||
@@ -125,7 +149,8 @@ switch ($action) {
|
||||
|
||||
case 'release':
|
||||
requireItemId($itemId);
|
||||
assertProject($repo, $context, $itemId);
|
||||
// Zurueckgeben duerfen heisst: was man haelt, auch loslassen koennen.
|
||||
assertProject($repo, $context, $itemId, false, true);
|
||||
|
||||
if (!$repo->releaseItem($itemId, $author, Http::str('note'))) {
|
||||
Http::fail(409, 'not_claimed', sprintf(
|
||||
@@ -138,7 +163,7 @@ switch ($action) {
|
||||
|
||||
case 'comment':
|
||||
requireItemId($itemId);
|
||||
assertProject($repo, $context, $itemId);
|
||||
assertProject($repo, $context, $itemId, true, true);
|
||||
|
||||
$comment = Http::str('comment');
|
||||
if ($comment === null) {
|
||||
@@ -157,7 +182,9 @@ switch ($action) {
|
||||
|
||||
case 'status':
|
||||
requireItemId($itemId);
|
||||
assertProject($repo, $context, $itemId);
|
||||
// Der Pruefende schliesst mit dem Status ab - auch bei einem fremden
|
||||
// Item, das er zur Nachpruefung haelt.
|
||||
assertProject($repo, $context, $itemId, false, true);
|
||||
|
||||
$status = Http::str('status');
|
||||
if ($status === null) {
|
||||
@@ -166,7 +193,16 @@ switch ($action) {
|
||||
]);
|
||||
}
|
||||
|
||||
if (!$repo->updateStatus($itemId, $status, Http::str('notes'), $author)) {
|
||||
try {
|
||||
$changed = $repo->updateStatus($itemId, $status, Http::str('notes'), $author);
|
||||
} catch (\InvalidArgumentException $e) {
|
||||
// Etwa: zurueckstellen ohne Ausloeser. Das ist eine verletzte
|
||||
// Regel, kein unbekannter Status - und verdient deshalb eine
|
||||
// Meldung, die sagt, was fehlt.
|
||||
Http::fail(400, 'invalid_transition', $e->getMessage());
|
||||
}
|
||||
|
||||
if (!$changed) {
|
||||
Http::fail(400, 'invalid_status', sprintf(
|
||||
'Status "%s" ist unbekannt oder Item #%d existiert nicht.',
|
||||
$status,
|
||||
@@ -180,7 +216,13 @@ switch ($action) {
|
||||
requireItemId($itemId);
|
||||
assertProject($repo, $context, $itemId);
|
||||
|
||||
if (!$repo->updateItemDetails($itemId, Http::body(), $author)) {
|
||||
try {
|
||||
$updated = $repo->updateItemDetails($itemId, Http::body(), $author);
|
||||
} catch (\InvalidArgumentException $e) {
|
||||
Http::fail(400, 'invalid_update', $e->getMessage());
|
||||
}
|
||||
|
||||
if (!$updated) {
|
||||
Http::fail(404, 'not_found', sprintf('Item #%d existiert nicht.', $itemId));
|
||||
}
|
||||
Http::ok(['message' => sprintf('Item #%d aktualisiert.', $itemId)]);
|
||||
@@ -283,10 +325,39 @@ function requireItemId(int $itemId): void
|
||||
}
|
||||
}
|
||||
|
||||
/** Stellt sicher, dass ein projektgebundenes Token das Item anfassen darf. */
|
||||
function assertProject(BugRepo $repo, array $context, int $itemId): void
|
||||
{
|
||||
if (ApiAuth::projectFilter($context) === null) {
|
||||
/**
|
||||
* Stellt sicher, dass ein projektgebundenes Token das Item anfassen darf.
|
||||
*
|
||||
* $allowWorkbench laesst Werkbank-Token auch an fremde Items. Das ist nur fuer
|
||||
* Kommentare gesetzt: wer aus einem anderen Projekt heraus melden darf, muss
|
||||
* auch nachreichen koennen, was er inzwischen herausgefunden hat. Uebernehmen,
|
||||
* abschliessen oder den Status aendern bleibt dem besitzenden Projekt
|
||||
* vorbehalten - dort weiss man, was ein "resolved" bedeutet.
|
||||
*/
|
||||
/**
|
||||
* Projektschranke fuer Schreibzugriffe auf ein einzelnes Item.
|
||||
*
|
||||
* $allowLeaseHolder oeffnet sie fuer den, der das Item gerade haelt. Das ist
|
||||
* kein Schlupfloch, sondern die Kehrseite der Nachpruefung: Ein Agent kann ein
|
||||
* FREMDES Item nur ueber ?action=next in die Hand bekommen, und dort gibt
|
||||
* BugRepo nur Items heraus, die auf Nachpruefung warten und bei denen sein
|
||||
* Projekt als betroffen vermerkt ist (siehe include_affected_verification).
|
||||
* Wer auf diesem Weg etwas haelt, muss es auch kommentieren, im Status setzen
|
||||
* und zurueckgeben duerfen - sonst haette er eine Aufgabe, die er nicht
|
||||
* abschliessen kann.
|
||||
*
|
||||
* Bewusst NICHT geoeffnet: resolve und update. Was in einem fremden Projekt
|
||||
* als "behoben in Build X" gilt, entscheidet dieses Projekt. Der Pruefende
|
||||
* bestaetigt (status) oder meldet erneut - mehr braucht er nicht.
|
||||
*/
|
||||
function assertProject(
|
||||
BugRepo $repo,
|
||||
array $context,
|
||||
int $itemId,
|
||||
bool $allowWorkbench = false,
|
||||
bool $allowLeaseHolder = false
|
||||
): void {
|
||||
if (ApiAuth::projectFilter($context, $allowWorkbench) === null) {
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -295,7 +366,15 @@ function assertProject(BugRepo $repo, array $context, int $itemId): void
|
||||
Http::fail(404, 'not_found', sprintf('Item #%d existiert nicht.', $itemId));
|
||||
}
|
||||
|
||||
ApiAuth::enforceProject($context, (string)$item['project_slug']);
|
||||
if ($allowLeaseHolder
|
||||
&& ($item['claimed_by'] ?? null) === ($context['actor'] ?? null)
|
||||
&& $item['lease_until'] !== null
|
||||
&& strtotime((string)$item['lease_until']) > time()
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
ApiAuth::enforceProject($context, (string)$item['project_slug'], $allowWorkbench);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -17,22 +17,85 @@ require_once __DIR__ . '/../../../../src/bootstrap.php';
|
||||
use Deploymentcenter\Core\ApiAuth;
|
||||
use Deploymentcenter\Core\Db;
|
||||
use Deploymentcenter\Core\Http;
|
||||
use Deploymentcenter\Core\ProjectLinks;
|
||||
use Deploymentcenter\Modules\Bugtracker\BugRepo;
|
||||
|
||||
Http::beginJson(['GET', 'OPTIONS'], true);
|
||||
Http::beginJson(['GET', 'POST', 'OPTIONS'], true);
|
||||
|
||||
if (Http::method() !== 'GET') {
|
||||
Http::fail(405, 'method_not_allowed', 'Dieser Endpunkt erwartet GET.');
|
||||
if (!in_array(Http::method(), ['GET', 'POST'], true)) {
|
||||
Http::fail(405, 'method_not_allowed', 'Dieser Endpunkt erwartet GET oder POST.');
|
||||
}
|
||||
|
||||
$db = Db::init();
|
||||
$context = ApiAuth::requireScope($db, 'bugtracker:read');
|
||||
$context = ApiAuth::requireScope($db, Http::method() === 'POST' ? 'bugtracker:report' : 'bugtracker:read');
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// POST: Beziehung des eigenen Projekts zu einem anderen festhalten.
|
||||
// ---------------------------------------------------------------------------
|
||||
// Ersetzt die von Hand gepflegte Zeile "Deploymentcenter-Anbindung: SDK 2.5.1"
|
||||
// in jeder Projekt-CLAUDE.md. Eine Angabe, die an N Stellen nachgezogen werden
|
||||
// muss, ist nach dem ersten Vergessen falsch - und zwar schweigend.
|
||||
//
|
||||
// from_slug kommt wie reported_from aus der Token-Bindung, nicht aus dem Body:
|
||||
// ein Projekt traegt seine eigene Anbindung ein, nicht die eines anderen.
|
||||
if (Http::method() === 'POST') {
|
||||
$home = ApiAuth::homeProject($context);
|
||||
|
||||
if ($home === null) {
|
||||
Http::fail(
|
||||
400,
|
||||
'no_home_project',
|
||||
'Dieses Token ist an kein Projekt gebunden. Eine Beziehung braucht aber ein Projekt, '
|
||||
. 'von dem aus sie gilt.'
|
||||
);
|
||||
}
|
||||
|
||||
$target = is_string(Http::input('to_slug')) ? trim((string)Http::input('to_slug')) : null;
|
||||
|
||||
if ($target === null || $target === '' || $target === $home) {
|
||||
Http::fail(
|
||||
400,
|
||||
'invalid_target',
|
||||
'Das Feld "to_slug" muss ein anderes Projekt als das eigene bezeichnen.'
|
||||
);
|
||||
}
|
||||
|
||||
$kind = is_string(Http::input('kind')) ? (string)Http::input('kind') : 'uses_sdk';
|
||||
|
||||
if (!in_array($kind, ProjectLinks::KINDS, true)) {
|
||||
Http::fail(400, 'invalid_kind', 'Unbekannte Art der Beziehung.', null, [
|
||||
'allowed' => ProjectLinks::KINDS,
|
||||
]);
|
||||
}
|
||||
|
||||
$version = is_string(Http::input('integrated_version'))
|
||||
? trim((string)Http::input('integrated_version'))
|
||||
: null;
|
||||
|
||||
$links = new ProjectLinks($db);
|
||||
|
||||
if (!$links->record($home, $target, $kind, $version !== '' ? $version : null)) {
|
||||
Http::fail(500, 'link_failed', 'Die Beziehung konnte nicht gespeichert werden.');
|
||||
}
|
||||
|
||||
Http::ok([
|
||||
'from_slug' => $home,
|
||||
'to_slug' => $target,
|
||||
'kind' => $kind,
|
||||
'integrated_version' => $version,
|
||||
'message' => $version !== null
|
||||
? sprintf('"%s" nutzt "%s" in Fassung %s.', $home, $target, $version)
|
||||
: sprintf('Beziehung "%s" -> "%s" festgehalten.', $home, $target),
|
||||
]);
|
||||
}
|
||||
|
||||
$repo = new BugRepo($db);
|
||||
$projects = $repo->getProjects();
|
||||
|
||||
// Ein projektgebundenes Token sieht nur sein eigenes Projekt.
|
||||
$bound = ApiAuth::projectFilter($context);
|
||||
// Ein Laufzeit-Token sieht nur sein eigenes Projekt. Ein Werkbank-Token sieht
|
||||
// alle: es soll ja gerade entscheiden koennen, wohin ein Fehler gehoert - und
|
||||
// dafuer muss es die Nachbarn kennen.
|
||||
$bound = ApiAuth::projectFilter($context, true);
|
||||
if ($bound !== null) {
|
||||
$projects = array_values(array_filter(
|
||||
$projects,
|
||||
@@ -40,18 +103,30 @@ if ($bound !== null) {
|
||||
));
|
||||
}
|
||||
|
||||
// Das Heimatprojekt bleibt auch beim Werkbank-Token bekannt. Es ist der
|
||||
// Bezugspunkt, gegen den die Beziehungen ausgewiesen werden.
|
||||
$home = ApiAuth::homeProject($context);
|
||||
$links = new ProjectLinks($db);
|
||||
|
||||
Http::ok([
|
||||
'count' => count($projects),
|
||||
'projects' => array_map(static function (array $p): array {
|
||||
'count' => count($projects),
|
||||
'home_project' => $home,
|
||||
'projects' => array_map(static function (array $p) use ($links, $home): array {
|
||||
$slug = (string)$p['slug'];
|
||||
|
||||
return [
|
||||
'id' => (int)$p['id'],
|
||||
'slug' => (string)$p['slug'],
|
||||
'slug' => $slug,
|
||||
'name' => (string)$p['name'],
|
||||
'notes' => $p['notes'] ?? null,
|
||||
'repo_url' => $p['repo_url'] ?? null,
|
||||
'default_agent' => $p['default_agent'] ?? null,
|
||||
'open_items' => (int)($p['open_items'] ?? 0),
|
||||
'critical_items' => (int)($p['critical_items'] ?? 0),
|
||||
|
||||
// Wie haengt dieses Projekt mit dem eigenen zusammen? null heisst
|
||||
// schlicht "gar nicht" und ist der Normalfall.
|
||||
'relation' => $home !== null ? $links->between($home, $slug) : null,
|
||||
];
|
||||
}, $projects),
|
||||
]);
|
||||
|
||||
@@ -23,6 +23,14 @@ use Deploymentcenter\Core\Http;
|
||||
use Deploymentcenter\Modules\Bugtracker\BugRepo;
|
||||
use Deploymentcenter\Modules\License\RateLimiter;
|
||||
|
||||
/**
|
||||
* Mindestlaenge der Begruendung bei einer Meldung gegen ein fremdes Projekt.
|
||||
*
|
||||
* Kurz genug, dass ein Satz reicht - lang genug, dass "Bug" oder "kaputt"
|
||||
* nicht durchgeht.
|
||||
*/
|
||||
const MIN_EVIDENCE_LENGTH = 40;
|
||||
|
||||
Http::beginJson(['POST', 'OPTIONS'], true);
|
||||
|
||||
if (Http::method() !== 'POST') {
|
||||
@@ -49,12 +57,58 @@ $environment = is_string($data['environment'] ?? null) ? $data['environment'] :
|
||||
$context = ApiAuth::requireScope($db, 'bugtracker:report', $environment, false);
|
||||
|
||||
$projectSlug = is_string($data['project_slug'] ?? null) ? trim($data['project_slug']) : null;
|
||||
ApiAuth::enforceProject($context, $projectSlug);
|
||||
|
||||
// Ein projektgebundenes Token schreibt immer in sein eigenes Projekt.
|
||||
$boundProject = ApiAuth::projectFilter($context);
|
||||
if ($boundProject !== null) {
|
||||
$data['project_slug'] = $boundProject;
|
||||
// Werkbank-Token duerfen in ein fremdes Projekt melden - ein Agent, der das SDK
|
||||
// in Projekt X integriert und dabei einen Fehler im Deploymentcenter findet,
|
||||
// muss ihn dort ablegen koennen. Laufzeit-Token duerfen das nicht: sie stecken
|
||||
// im ausgelieferten Client und sind extrahierbar.
|
||||
ApiAuth::enforceProject($context, $projectSlug, true);
|
||||
|
||||
$homeProject = ApiAuth::homeProject($context);
|
||||
|
||||
// Ein Laufzeit-Token schreibt immer in sein eigenes Projekt.
|
||||
if ($homeProject !== null && !ApiAuth::isWorkbench($context)) {
|
||||
$data['project_slug'] = $homeProject;
|
||||
}
|
||||
|
||||
// --- Fremdmeldung? ----------------------------------------------------------
|
||||
$target = is_string($data['project_slug'] ?? null) ? trim($data['project_slug']) : null;
|
||||
$isForeign = $homeProject !== null
|
||||
&& $target !== null && $target !== ''
|
||||
&& $target !== $homeProject;
|
||||
|
||||
// Die Herkunft wird aus der Token-Bindung abgeleitet und niemals aus dem Body
|
||||
// uebernommen. Nur so ist sie bezeugt statt behauptet - und nur dann traegt das
|
||||
// Signal "drei Projekte melden dasselbe" ueberhaupt etwas.
|
||||
$rawEvidence = $data['evidence'] ?? null;
|
||||
unset($data['reported_from'], $data['evidence']);
|
||||
|
||||
if ($isForeign) {
|
||||
$evidence = is_string($rawEvidence) ? trim($rawEvidence) : null;
|
||||
|
||||
// Begruendungspflicht. Ein Agent in Projekt X kann kaum unterscheiden, ob
|
||||
// das fremde Projekt kaputt ist oder ob X es falsch benutzt; die
|
||||
// Voreinstellung eines hilfsbereiten Modells ist im Zweifel "melde es".
|
||||
// Etwas ausformulieren zu muessen kostet einen Reflex fast immer den Kopf.
|
||||
if ($evidence === null || mb_strlen($evidence) < MIN_EVIDENCE_LENGTH) {
|
||||
Http::fail(
|
||||
400,
|
||||
'missing_evidence',
|
||||
sprintf(
|
||||
'Eine Meldung gegen das fremde Projekt "%s" verlangt das Feld "evidence" '
|
||||
. '(mindestens %d Zeichen): was wurde beobachtet, und warum liegt die '
|
||||
. 'Ursache dort und nicht in "%s"?',
|
||||
$target,
|
||||
MIN_EVIDENCE_LENGTH,
|
||||
$homeProject
|
||||
),
|
||||
null,
|
||||
['home_project' => $homeProject, 'target_project' => $target]
|
||||
);
|
||||
}
|
||||
|
||||
$data['reported_from'] = $homeProject;
|
||||
$data['evidence'] = $evidence;
|
||||
}
|
||||
|
||||
// Der Absender wird aus dem Token abgeleitet und kann nicht frei gewaehlt
|
||||
@@ -72,11 +126,41 @@ if (empty($data['client_ref'])) {
|
||||
$repo = new BugRepo($db);
|
||||
$result = $repo->reportItem($data);
|
||||
|
||||
$message = $result['idempotent_hit']
|
||||
? 'Bereits erfasst (identische client_ref) - kein Duplikat angelegt.'
|
||||
: ($result['is_new']
|
||||
? ($result['type'] === 'bug' ? 'Bug erfasst.' : 'Feature Request erfasst.')
|
||||
: 'Wiederkehrendes Vorkommnis - Zaehler erhoeht.');
|
||||
// Bekannt und in einer spaeteren Fassung behoben. Diese Antwort geht jeder
|
||||
// anderen vor: Sie beendet die Frage, statt sie einzusortieren. Der Melder
|
||||
// prueft eine Fassung, in der der Fix noch nicht steckt - er soll aufhoeren zu
|
||||
// suchen und aktualisieren, nicht ein weiteres Item anlegen.
|
||||
// Der Fix hat nicht getragen. Kein neues Item - das bestehende ist zurueck in
|
||||
// der Arbeitsschlange, und der Beleg haengt daran.
|
||||
if (!empty($result['fix_insufficient'])) {
|
||||
$message = sprintf(
|
||||
'Der Fix traegt nicht. Item #%d steht wieder auf "fix_insufficient" und liegt in der '
|
||||
. 'Arbeitsschlange - kein neues Item angelegt, der Beleg haengt am bestehenden.',
|
||||
$result['id']
|
||||
);
|
||||
} elseif (isset($result['known_fixed_in'])) {
|
||||
$message = sprintf(
|
||||
'Bekannt und behoben in Build "%s" - du hast "%s" geprueft. Kein neues Item angelegt. '
|
||||
. 'Aktualisiere und pruefe erneut; tritt es dann immer noch auf, ist es eine Regression '
|
||||
. 'und gehoert gemeldet.',
|
||||
$result['known_fixed_in'],
|
||||
$result['reported_build']
|
||||
);
|
||||
} elseif ($isForeign) {
|
||||
$message = $result['is_new']
|
||||
? sprintf(
|
||||
'Im Eingang von "%s" hinterlegt. Wird dort gesichtet und zaehlt erst nach '
|
||||
. 'Bestaetigung in die Statistik.',
|
||||
$target
|
||||
)
|
||||
: sprintf('Bereits bekannt - "%s" ist als betroffen vermerkt.', $homeProject);
|
||||
} else {
|
||||
$message = $result['idempotent_hit']
|
||||
? 'Bereits erfasst (identische client_ref) - kein Duplikat angelegt.'
|
||||
: ($result['is_new']
|
||||
? ($result['type'] === 'bug' ? 'Bug erfasst.' : 'Feature Request erfasst.')
|
||||
: 'Wiederkehrendes Vorkommnis - Zaehler erhoeht.');
|
||||
}
|
||||
|
||||
Http::ok([
|
||||
'item_id' => $result['id'],
|
||||
@@ -90,6 +174,17 @@ Http::ok([
|
||||
'environment' => $result['environment'],
|
||||
'push_id' => $result['push_id'] ?? null,
|
||||
'regression_of' => $result['regression_of'] ?? null,
|
||||
// Gesetzt, wenn der Fehler bereits in einer spaeteren Fassung behoben ist
|
||||
// als der, die gemeldet wurde. Dann wurde NICHTS angelegt und nichts
|
||||
// hochgezaehlt - die Antwort ist eine Auskunft.
|
||||
'known_fixed_in' => $result['known_fixed_in'] ?? null,
|
||||
'reported_build' => $result['reported_build'] ?? null,
|
||||
// Gesetzt, wenn der gemeldete Fehler ein Item betrifft, dessen Fix noch
|
||||
// nicht bestaetigt war. Dann wurde kein neues Item angelegt - das
|
||||
// bestehende wechselte auf fix_insufficient.
|
||||
'fix_insufficient' => !empty($result['fix_insufficient']),
|
||||
'reported_from' => $result['reported_from'] ?? null,
|
||||
'affects' => $result['affects'] ?? [],
|
||||
'url' => Http::baseUrl() . '/index.php#tab-bugtracker',
|
||||
'message' => $message,
|
||||
], $result['is_new'] ? 201 : 200);
|
||||
|
||||
@@ -0,0 +1,317 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* /api/bugtracker/v1/roadmap.php
|
||||
*
|
||||
* Die Roadmap - Vorhaben mit Themenbereich, Reihenfolge und Zielfassung.
|
||||
*
|
||||
* GET ?action=list Eintraege, gefiltert (bugtracker:read)
|
||||
* GET ?action=epics Themenbereiche samt Zaehlung (bugtracker:read)
|
||||
* GET ?action=next "Als Naechstes" (bugtracker:read)
|
||||
* GET ?action=active Wer arbeitet gerade woran (bugtracker:read)
|
||||
* GET ?action=render Der erzeugte Markdown-Block (bugtracker:read)
|
||||
* POST ?action=set Bereich/Rang/Ziel/Anker setzen (bugtracker:manage)
|
||||
* POST ?action=move Eintrag eine Position schieben (bugtracker:manage)
|
||||
* POST ?action=reorder Reihenfolge eines Bereichs neu (bugtracker:manage)
|
||||
* POST ?action=epic Themenbereich anlegen/aendern (bugtracker:manage)
|
||||
*
|
||||
* KEINE eigene Datenhaltung. Ein Roadmap-Eintrag ist ein bugtracker_item mit
|
||||
* gesetztem `epic`; dieser Endpunkt ist die Sicht darauf. Anlegen laeuft
|
||||
* weiterhin ueber /report, Abschliessen ueber /manage - sonst gaebe es zwei
|
||||
* Wege zu denselben Daten und damit zwei Stellen, an denen Regeln gelten
|
||||
* muessten.
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
require_once __DIR__ . '/../../../../src/bootstrap.php';
|
||||
|
||||
use Deploymentcenter\Core\ApiAuth;
|
||||
use Deploymentcenter\Core\Db;
|
||||
use Deploymentcenter\Core\Http;
|
||||
use Deploymentcenter\Modules\Bugtracker\BugRepo;
|
||||
use Deploymentcenter\Modules\Bugtracker\Roadmap;
|
||||
|
||||
Http::beginJson(['GET', 'POST', 'OPTIONS'], true);
|
||||
|
||||
const READ_ACTIONS = ['list', 'epics', 'next', 'active', 'render', 'check'];
|
||||
const WRITE_ACTIONS = ['set', 'move', 'reorder', 'epic'];
|
||||
|
||||
$action = strtolower(Http::str('action') ?? 'list');
|
||||
|
||||
if (!in_array($action, READ_ACTIONS, true) && !in_array($action, WRITE_ACTIONS, true)) {
|
||||
Http::fail(404, 'unknown_action', sprintf('Unbekannte Aktion "%s".', $action), null, [
|
||||
'available' => array_merge(READ_ACTIONS, WRITE_ACTIONS),
|
||||
]);
|
||||
}
|
||||
|
||||
$isWrite = in_array($action, WRITE_ACTIONS, true);
|
||||
|
||||
if ($isWrite && Http::method() !== 'POST') {
|
||||
Http::fail(405, 'method_not_allowed', sprintf('Die Aktion "%s" erwartet POST.', $action));
|
||||
}
|
||||
|
||||
$db = Db::init();
|
||||
$repo = new BugRepo($db);
|
||||
$roadmap = new Roadmap($db);
|
||||
|
||||
$context = ApiAuth::requireScope($db, $isWrite ? 'bugtracker:manage' : 'bugtracker:read');
|
||||
$author = $context['actor'];
|
||||
|
||||
// Lesen darf die Landschaft sehen, Schreiben nur das eigene Projekt.
|
||||
//
|
||||
// Dieselbe Trennung wie in /manage, und aus demselben Grund: Ein Agent soll
|
||||
// erkennen koennen, wo sein Projekt in der Gesamtplanung steht - aber die
|
||||
// Reihenfolge fremder Vorhaben legt er nicht fest.
|
||||
$readProject = ApiAuth::projectFilter($context, true);
|
||||
$writeProject = ApiAuth::projectFilter($context);
|
||||
|
||||
$requested = Http::str('project_slug') ?? Http::str('project') ?? 'all';
|
||||
$scope = $readProject ?? $requested;
|
||||
|
||||
switch ($action) {
|
||||
case 'epics':
|
||||
Http::ok([
|
||||
'epics' => $roadmap->epics($scope),
|
||||
'orphans' => $roadmap->orphanEpics($scope),
|
||||
'stats' => $roadmap->stats($scope),
|
||||
]);
|
||||
|
||||
case 'next':
|
||||
Http::ok([
|
||||
'items' => $roadmap->nextUp($scope, Http::int('limit', 5) ?: 5),
|
||||
]);
|
||||
|
||||
case 'active':
|
||||
Http::ok([
|
||||
'items' => $roadmap->activeWork($scope),
|
||||
]);
|
||||
|
||||
case 'render': {
|
||||
$project = requireProject($scope);
|
||||
Http::ok([
|
||||
'project_slug' => $project,
|
||||
'markdown' => $roadmap->renderBlock($project),
|
||||
]);
|
||||
}
|
||||
|
||||
case 'check': {
|
||||
// Der Abgleich braucht den Dateiinhalt. Er kommt mitgeschickt, statt
|
||||
// dass der Server ihn liest: Die Datei liegt im Repository des
|
||||
// Projekts, oft auf einer anderen Maschine. Der Server kennt sie nicht
|
||||
// und soll auch nicht anfangen, in Verzeichnissen zu suchen.
|
||||
$project = requireProject($scope);
|
||||
$content = Http::str('content');
|
||||
|
||||
if ($content === null) {
|
||||
Http::fail(400, 'missing_content', 'Das Feld "content" mit dem Dateiinhalt fehlt.');
|
||||
}
|
||||
|
||||
$tmp = tempnam(sys_get_temp_dir(), 'dcrm');
|
||||
if ($tmp === false) {
|
||||
Http::fail(500, 'tmp_failed', 'Konnte den Inhalt nicht zwischenspeichern.');
|
||||
}
|
||||
|
||||
file_put_contents($tmp, $content);
|
||||
$result = $roadmap->check($project, $tmp);
|
||||
@unlink($tmp);
|
||||
|
||||
Http::ok($result);
|
||||
}
|
||||
|
||||
case 'list': {
|
||||
$filters = [
|
||||
'project_slug' => $scope,
|
||||
'on_roadmap' => true,
|
||||
'epic' => Http::str('epic') ?? 'all',
|
||||
'status' => resolveStatusFilter(Http::str('status')),
|
||||
'type' => Http::str('type') ?? 'all',
|
||||
'severity' => Http::str('severity') ?? 'all',
|
||||
'target_build' => Http::str('target_build') ?? 'all',
|
||||
'claimed_by' => Http::str('claimed_by') ?? '',
|
||||
'search' => Http::str('q') ?? '',
|
||||
'order' => 'roadmap',
|
||||
'limit' => Http::int('limit', 200) ?: 200,
|
||||
'offset' => Http::int('offset', 0) ?: 0,
|
||||
];
|
||||
|
||||
$result = $repo->getItems($filters);
|
||||
$result['stats'] = $roadmap->stats($scope);
|
||||
|
||||
Http::ok($result);
|
||||
}
|
||||
|
||||
case 'set': {
|
||||
$itemId = Http::int('id', 0) ?: 0;
|
||||
if ($itemId < 1) {
|
||||
Http::fail(400, 'missing_id', 'Das Feld "id" fehlt.');
|
||||
}
|
||||
|
||||
assertOwnProject($repo, $writeProject, $itemId);
|
||||
|
||||
// Nur die Roadmap-Felder. Titel, Schweregrad und Status laufen
|
||||
// weiterhin ueber /manage - ein zweiter Schreibweg auf dieselben
|
||||
// Spalten waere eine zweite Stelle, an der Regeln gelten muessten.
|
||||
$updates = [];
|
||||
foreach (['epic', 'target_build', 'defer_trigger', 'doc_anchor'] as $field) {
|
||||
if (Http::input($field) !== null) {
|
||||
$updates[$field] = Http::str($field);
|
||||
}
|
||||
}
|
||||
|
||||
// Ein leerer Wert loescht die Reihenfolge, statt sie auf 0 zu setzen.
|
||||
// Sonst waere "keine Meinung" nicht mehr ausdrueckbar - und Rang 0
|
||||
// sortierte den Eintrag ausgerechnet an die Spitze.
|
||||
if (Http::input('roadmap_rank') !== null) {
|
||||
$raw = Http::str('roadmap_rank');
|
||||
$updates['roadmap_rank'] = ($raw !== null && is_numeric($raw)) ? (int)$raw : null;
|
||||
}
|
||||
|
||||
// Zurueckstellen laeuft ueber diesen Weg mit, weil Status und
|
||||
// Ausloeser zusammen ankommen muessen - getrennt gesetzt entstuende
|
||||
// genau der Eintrag ohne Ausloeser, den die Regel verhindern soll.
|
||||
$status = Http::str('status');
|
||||
if ($status !== null) {
|
||||
$updates['status'] = $status;
|
||||
}
|
||||
|
||||
if ($updates === []) {
|
||||
Http::fail(400, 'nothing_to_do', 'Keines der Roadmap-Felder wurde mitgeschickt.', null, [
|
||||
'fields' => ['epic', 'roadmap_rank', 'target_build', 'defer_trigger', 'doc_anchor', 'status'],
|
||||
]);
|
||||
}
|
||||
|
||||
try {
|
||||
if (!$repo->updateItemDetails($itemId, $updates, $author)) {
|
||||
Http::fail(404, 'not_found', sprintf('Item #%d existiert nicht.', $itemId));
|
||||
}
|
||||
} catch (\InvalidArgumentException $e) {
|
||||
Http::fail(400, 'invalid_update', $e->getMessage());
|
||||
}
|
||||
|
||||
Http::ok(['message' => sprintf('Roadmap-Angaben zu #%d gesetzt.', $itemId)]);
|
||||
}
|
||||
|
||||
case 'move': {
|
||||
$itemId = Http::int('id', 0) ?: 0;
|
||||
if ($itemId < 1) {
|
||||
Http::fail(400, 'missing_id', 'Das Feld "id" fehlt.');
|
||||
}
|
||||
|
||||
assertOwnProject($repo, $writeProject, $itemId);
|
||||
|
||||
$direction = strtolower(Http::str('direction') ?? 'up');
|
||||
if (!in_array($direction, ['up', 'down'], true)) {
|
||||
Http::fail(400, 'invalid_direction', 'Erlaubt sind "up" und "down".');
|
||||
}
|
||||
|
||||
if (!$roadmap->move($itemId, $direction)) {
|
||||
Http::fail(409, 'cannot_move', sprintf(
|
||||
'#%d laesst sich nicht weiter nach %s schieben - '
|
||||
. 'schon am Rand des Bereichs, oder ohne Bereich.',
|
||||
$itemId,
|
||||
$direction === 'up' ? 'oben' : 'unten'
|
||||
));
|
||||
}
|
||||
|
||||
Http::ok(['message' => sprintf('#%d verschoben.', $itemId)]);
|
||||
}
|
||||
|
||||
case 'reorder': {
|
||||
$project = requireProject($writeProject ?? $requested);
|
||||
$epic = Http::str('epic');
|
||||
$ids = Http::input('ids');
|
||||
|
||||
if ($epic === null || !is_array($ids) || $ids === []) {
|
||||
Http::fail(400, 'missing_fields', 'Es werden "epic" und "ids" (Liste) erwartet.');
|
||||
}
|
||||
|
||||
$touched = $roadmap->reorder($project, $epic, array_map('intval', $ids));
|
||||
|
||||
Http::ok([
|
||||
'message' => sprintf('%d Eintrag/Eintraege neu gereiht.', $touched),
|
||||
'touched' => $touched,
|
||||
]);
|
||||
}
|
||||
|
||||
case 'epic': {
|
||||
$project = requireProject($writeProject ?? $requested);
|
||||
$epic = Http::str('epic');
|
||||
$title = Http::str('title');
|
||||
|
||||
if ($epic === null || $title === null) {
|
||||
Http::fail(400, 'missing_fields', 'Es werden "epic" und "title" erwartet.');
|
||||
}
|
||||
|
||||
$roadmap->saveEpic(
|
||||
$project,
|
||||
$epic,
|
||||
$title,
|
||||
Http::str('summary'),
|
||||
Http::int('sort_order', 100) ?: 100
|
||||
);
|
||||
|
||||
Http::ok(['message' => sprintf('Themenbereich "%s" gespeichert.', $epic)]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Verlangt ein konkretes Projekt.
|
||||
*
|
||||
* "all" ist beim Lesen sinnvoll und beim Schreiben oder Erzeugen nicht - eine
|
||||
* Datei gehoert zu genau einem Repository.
|
||||
*/
|
||||
function requireProject(?string $slug): string
|
||||
{
|
||||
if ($slug === null || $slug === '' || $slug === 'all') {
|
||||
Http::fail(400, 'missing_project', 'Diese Aktion braucht ein konkretes "project_slug".');
|
||||
}
|
||||
|
||||
return $slug;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ein Roadmap-Eintrag wird nur im eigenen Projekt umsortiert.
|
||||
*
|
||||
* Dieselbe Schranke wie beim Uebernehmen von Arbeit: Wer in Projekt X
|
||||
* arbeitet, ordnet nicht die Planung von Projekt Y.
|
||||
*/
|
||||
function assertOwnProject(BugRepo $repo, ?string $bound, int $itemId): void
|
||||
{
|
||||
if ($bound === null) {
|
||||
return; // Master-Token oder Oberflaeche
|
||||
}
|
||||
|
||||
$item = $repo->getItemDetails($itemId);
|
||||
if ($item === null) {
|
||||
Http::fail(404, 'not_found', sprintf('Item #%d existiert nicht.', $itemId));
|
||||
}
|
||||
|
||||
if ((string)$item['project_slug'] !== $bound) {
|
||||
Http::fail(403, 'foreign_project', sprintf(
|
||||
'Item #%d gehoert zu "%s". Fremde Roadmaps werden nicht umsortiert.',
|
||||
$itemId,
|
||||
(string)$item['project_slug']
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Uebersetzt eine Lage-Auswahl in die zugehoerigen Status.
|
||||
*
|
||||
* Elf Status sind fuer die Ablage richtig und fuer einen Filter zu viele. Wer
|
||||
* "offen" waehlt, meint keine ENUM-Konstante, sondern eine Lage - deshalb hier
|
||||
* die Gruppen aus Roadmap::STATUS_GROUPS, mit den Einzelstatus als Rueckfall.
|
||||
*/
|
||||
function resolveStatusFilter(?string $value): string
|
||||
{
|
||||
if ($value === null || $value === '' || $value === 'all') {
|
||||
return 'all';
|
||||
}
|
||||
|
||||
if (isset(Roadmap::STATUS_GROUPS[$value])) {
|
||||
return implode(',', Roadmap::STATUS_GROUPS[$value]);
|
||||
}
|
||||
|
||||
return $value;
|
||||
}
|
||||
@@ -5,7 +5,14 @@
|
||||
*
|
||||
* POST /api/license/v1/validate Lizenz und Hardware pruefen (oeffentlich)
|
||||
* POST /api/license/v1/deactivate Aktivierung freigeben (authentifiziert)
|
||||
* POST /api/license/v1/dev-key Entwicklungsschluessel abholen (license:dev)
|
||||
* GET /api/license/v1/status Verfuegbarkeitspruefung
|
||||
*
|
||||
* ACHTUNG, ZWEI ANTWORTFORMATE IN EINER DATEI: validate und deactivate
|
||||
* antworten ohne den status/error-Umschlag der uebrigen API - das ist ein
|
||||
* ausgerollter Vertrag, siehe die Begruendung weiter unten. dev-key ist neu und
|
||||
* folgt deshalb dem Hausformat (status: success). Wer hier etwas ergaenzt,
|
||||
* nimmt das Hausformat; der Sonderfall gilt nur fuer die beiden alten Wege.
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
@@ -15,6 +22,7 @@ require_once __DIR__ . '/../../../../src/bootstrap.php';
|
||||
use Deploymentcenter\Core\ApiAuth;
|
||||
use Deploymentcenter\Core\Db;
|
||||
use Deploymentcenter\Core\Http;
|
||||
use Deploymentcenter\Modules\License\DevKeys;
|
||||
use Deploymentcenter\Modules\License\LicenseService;
|
||||
use Deploymentcenter\Modules\License\RateLimiter;
|
||||
|
||||
@@ -55,12 +63,106 @@ switch ($action) {
|
||||
ApiAuth::requireScope($db, 'license:deactivate');
|
||||
Http::raw($service->deactivate(Http::body(), $ip));
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Entwicklungsschluessel zur Selbstbedienung
|
||||
//
|
||||
// Damit ein Agent auf der Testmaschine ueberhaupt etwas pruefen kann,
|
||||
// braucht er einen gueltigen Schluessel - fuer die Lizenzpruefung selbst
|
||||
// und seit 2.4 auch fuer den Zugang zur Release-Ablage. Ihn von Hand
|
||||
// auszustellen und weiterzureichen war der einzige Weg; das Ergebnis waren
|
||||
// unbefristete Schluessel in Chatverlaeufen. Herleitung in DevKeys.
|
||||
//
|
||||
// Antwortet im Hausformat, nicht im Sonderformat der Lizenzpruefung.
|
||||
// ------------------------------------------------------------------
|
||||
case 'dev-key':
|
||||
if (Http::method() !== 'POST') {
|
||||
Http::fail(405, 'method_not_allowed', 'Diese Aktion erwartet POST.');
|
||||
}
|
||||
|
||||
// Enger gedrosselt als der Rest des Moduls: Ein Schluessel wird einmal
|
||||
// je Testlauf geholt, nicht im Sekundentakt. Wer haeufiger anfragt, hat
|
||||
// eine Schleife gebaut - und legt sonst Zeilen an, bis die Grenze aus
|
||||
// DevKeys::MAX_PER_PROJECT greift.
|
||||
$devLimiter = new RateLimiter($db, 10, 60, 'license_dev');
|
||||
if (!$devLimiter->check($ip)) {
|
||||
Http::fail(429, 'rate_limited', 'Zu viele Anfragen nach Entwicklungsschluesseln.');
|
||||
}
|
||||
|
||||
// allowSession bewusst aus: Dieser Weg ist fuer Werkbank-Token auf
|
||||
// Testmaschinen, nicht fuer einen angemeldeten Browser. Wer im WebUI
|
||||
// sitzt, legt Lizenzen dort an.
|
||||
$context = ApiAuth::requireScope($db, 'license:dev', null, false);
|
||||
|
||||
$slug = Http::str('project_slug') ?? Http::str('product');
|
||||
if ($slug === null) {
|
||||
Http::fail(400, 'missing_project', 'Es fehlt project_slug.');
|
||||
}
|
||||
|
||||
// allowWorkbench bleibt aus. Ein Werkbank-Token darf projektuebergreifend
|
||||
// melden - aber ein Lizenzschluessel ist etwas anderes als eine Meldung:
|
||||
// Er oeffnet die Release-Ablage eines Produkts. Wer fuer ein fremdes
|
||||
// Projekt testet, braucht dafuer dessen Token.
|
||||
ApiAuth::enforceProject($context, $slug);
|
||||
|
||||
$identity = Http::str('instance_id')
|
||||
?? Http::str('hostname')
|
||||
?? ($context['token']['owner_identity'] ?? null);
|
||||
|
||||
if ($identity === null || $identity === '') {
|
||||
Http::fail(
|
||||
400,
|
||||
'missing_identity',
|
||||
'Es fehlt instance_id - die Kennung der Maschine, die den Schluessel bekommt. '
|
||||
. 'Ohne sie liesse sich ein wiederholter Aufruf nicht demselben Schluessel zuordnen.'
|
||||
);
|
||||
}
|
||||
|
||||
$devAction = strtolower(Http::str('action_mode') ?? 'issue');
|
||||
|
||||
try {
|
||||
if ($devAction === 'revoke') {
|
||||
$removed = DevKeys::revoke($db, $slug, (string)$identity, $context['actor']);
|
||||
|
||||
Http::ok([
|
||||
'project_slug' => $slug,
|
||||
'revoked' => $removed,
|
||||
'message' => $removed
|
||||
? 'Entwicklungsschluessel zurueckgegeben.'
|
||||
: 'Fuer diese Maschine war kein Entwicklungsschluessel vergeben.',
|
||||
]);
|
||||
}
|
||||
|
||||
$result = DevKeys::issue(
|
||||
$db,
|
||||
$slug,
|
||||
(string)$identity,
|
||||
Http::input('ttl_days') !== null ? Http::int('ttl_days') : null,
|
||||
$context['actor']
|
||||
);
|
||||
} catch (RuntimeException $e) {
|
||||
Http::fail(409, 'dev_key_denied', $e->getMessage());
|
||||
}
|
||||
|
||||
Http::ok([
|
||||
'license_key' => $result['license_key'],
|
||||
'project_slug' => $result['project_slug'],
|
||||
'instance_id' => $result['identity'],
|
||||
'expires_at' => $result['expires_at'],
|
||||
'max_activations' => $result['max_activations'],
|
||||
'activations_used' => $result['activations_used'],
|
||||
'created' => $result['created'],
|
||||
'renewed' => $result['renewed'],
|
||||
'message' => $result['created']
|
||||
? 'Entwicklungsschluessel ausgestellt. Er ist befristet und gilt nur fuer diese Maschine.'
|
||||
: 'Bestehender Entwicklungsschluessel verlaengert.',
|
||||
], $result['created'] ? 201 : 200);
|
||||
|
||||
case 'status':
|
||||
Http::raw(['status' => 'ok', 'module' => 'license', 'version' => '2.0']);
|
||||
|
||||
default:
|
||||
Http::fail(404, 'unknown_action', 'Endpunkt nicht gefunden.', null, [
|
||||
'available' => ['validate', 'deactivate', 'status'],
|
||||
'available' => ['validate', 'deactivate', 'dev-key', 'status'],
|
||||
]);
|
||||
}
|
||||
|
||||
@@ -79,7 +181,11 @@ function resolveLicenseAction(): string
|
||||
$last = strtolower((string)end($segments));
|
||||
|
||||
return match ($last) {
|
||||
'validate', 'deactivate', 'status' => $last,
|
||||
'validate', 'deactivate', 'status', 'dev-key' => $last,
|
||||
// Ein Tippfehler bei der Selbstbedienung soll nicht stillschweigend zur
|
||||
// Verfuegbarkeitspruefung werden - sonst sucht jemand lange nach dem
|
||||
// Grund, warum "kein Schluessel kommt, aber alles ok meldet".
|
||||
'devkey', 'dev_key' => 'dev-key',
|
||||
default => 'status',
|
||||
};
|
||||
}
|
||||
|
||||
+329
-2
@@ -15,6 +15,7 @@ require_once __DIR__ . '/../../src/bootstrap.php';
|
||||
use Deploymentcenter\Core\Config;
|
||||
use Deploymentcenter\Core\Http;
|
||||
use Deploymentcenter\Modules\Bugtracker\BugRepo;
|
||||
use Deploymentcenter\Modules\Supervisor\FindingRepo;
|
||||
use Deploymentcenter\Modules\Watchdog\EventLog;
|
||||
use Deploymentcenter\Core\TokenManager;
|
||||
|
||||
@@ -118,6 +119,21 @@ $spec = [
|
||||
'file_path' => ['type' => 'string'],
|
||||
'line_no' => ['type' => 'integer'],
|
||||
'context' => ['type' => 'object', 'description' => 'Beliebiger strukturierter Zusatzkontext'],
|
||||
'evidence' => [
|
||||
'type' => 'string',
|
||||
'minLength' => 40,
|
||||
'description' =>
|
||||
'Pflicht, wenn project_slug ein fremdes Projekt bezeichnet: was wurde '
|
||||
. 'beobachtet, und warum liegt die Ursache dort und nicht im eigenen '
|
||||
. 'Projekt? Wird bei einer Meldung ins eigene Projekt ignoriert.',
|
||||
],
|
||||
'reported_from' => [
|
||||
'type' => 'string',
|
||||
'readOnly' => true,
|
||||
'description' =>
|
||||
'Herkunft der Meldung. Wird vom Server aus der Token-Bindung '
|
||||
. 'abgeleitet; ein Wert im Body wird verworfen.',
|
||||
],
|
||||
],
|
||||
],
|
||||
'Release' => [
|
||||
@@ -226,7 +242,38 @@ $spec = [
|
||||
'post' => [
|
||||
'tags' => ['Bugtracker'],
|
||||
'summary' => 'Bug, Feature Request oder Idee melden',
|
||||
'description' => 'Benoetigt den Scope bugtracker:report. Gleiche Fehler werden automatisch zusammengefasst und hochgezaehlt.',
|
||||
'description' =>
|
||||
"Benoetigt den Scope bugtracker:report. Gleiche Fehler werden automatisch "
|
||||
. "zusammengefasst und hochgezaehlt.\n\n"
|
||||
. "**Meldung gegen ein fremdes Projekt.** Ein Token vom Typ dev_agent "
|
||||
. "(Werkbank-Token: Claude Code, MCP-Adapter, CI) darf project_slug auf ein "
|
||||
. "anderes Projekt setzen - etwa wenn beim Integrieren des SDK ein Fehler im "
|
||||
. "Deploymentcenter selbst auffaellt. Laufzeit-Token duerfen das nicht; sie "
|
||||
. "stecken im ausgelieferten Client und sind extrahierbar.\n\n"
|
||||
. "Fuer solche Meldungen gilt:\n"
|
||||
. "- `evidence` ist Pflicht (mindestens 40 Zeichen): was wurde beobachtet, "
|
||||
. "und warum liegt die Ursache dort und nicht im eigenen Projekt?\n"
|
||||
. "- `reported_from` wird aus der Token-Bindung abgeleitet und aus dem Body "
|
||||
. "ignoriert - die Herkunft ist bezeugt, nicht behauptet.\n"
|
||||
. "- Das Item landet im Status `triage_external` und zaehlt erst nach "
|
||||
. "Bestaetigung in die Statistik.\n"
|
||||
. "- Der Schweregrad wird auf `medium` gedeckelt; `high` und `critical` "
|
||||
. "vergibt die empfangende Seite.\n"
|
||||
. "- Meldet ein zweites Projekt dieselbe Sache, entsteht kein neues Item - "
|
||||
. "es waechst die Liste der Betroffenen (`affects`).\n\n"
|
||||
. "**Schicke immer `build_version`.** Trifft die Meldung auf ein bereits "
|
||||
. "behobenes Item, entscheidet der Vergleich mit dessen `resolved_in_build` "
|
||||
. "ueber drei sehr verschiedene Ausgaenge - ohne die Angabe faellt die "
|
||||
. "Entscheidung im Zweifel auf den unguenstigsten:\n"
|
||||
. "- **aeltere Fassung als der Fix** -> es passiert nichts. Die Antwort traegt "
|
||||
. "`known_fixed_in`, kein Item wird angelegt und kein Zaehler erhoeht. "
|
||||
. "Aktualisieren und erneut pruefen.\n"
|
||||
. "- **Fix war noch nicht bestaetigt** (`resolved`, `awaiting_verification`, "
|
||||
. "`in_verification`) -> das bestehende Item wechselt auf `fix_insufficient` "
|
||||
. "und liegt wieder in der Arbeitsschlange. `fix_insufficient: true` in der "
|
||||
. "Antwort. Kein neues Item: Versuch und Fehlschlag gehoeren auf einen Strang.\n"
|
||||
. "- **Item war bestaetigt geschlossen** -> Regression, neues Item mit "
|
||||
. "`regression_of` auf das alte.",
|
||||
'requestBody' => [
|
||||
'required' => true,
|
||||
'content' => ['application/json' => ['schema' => ['$ref' => '#/components/schemas/ReportRequest']]],
|
||||
@@ -234,7 +281,9 @@ $spec = [
|
||||
'responses' => [
|
||||
'201' => ['description' => 'Neu angelegt'],
|
||||
'200' => ['description' => 'Bestehendes Item aktualisiert (Duplikat oder Idempotenz-Treffer)'],
|
||||
'400' => $errorResponse,
|
||||
'401' => $errorResponse,
|
||||
'403' => $errorResponse,
|
||||
'429' => $errorResponse,
|
||||
],
|
||||
],
|
||||
@@ -300,7 +349,14 @@ $spec = [
|
||||
'get' => [
|
||||
'tags' => ['Bugtracker'],
|
||||
'summary' => 'Projekte auflisten (Discovery)',
|
||||
'description' => 'Benoetigt den Scope bugtracker:read.',
|
||||
'description' =>
|
||||
"Benoetigt den Scope bugtracker:read.\n\n"
|
||||
. "Jeder Eintrag traegt `relation`: wie das Projekt mit dem eigenen "
|
||||
. "zusammenhaengt (`uses_sdk`, `depends_on`, `shares_code`, Richtung und "
|
||||
. "integrierte Fassung). `null` heisst schlicht: gar nicht.\n\n"
|
||||
. "Ein Laufzeit-Token sieht nur sein eigenes Projekt. Ein Werkbank-Token "
|
||||
. "(dev_agent) sieht alle - es soll ja entscheiden koennen, wohin ein "
|
||||
. "Fehler gehoert, und dafuer muss es die Nachbarn kennen.",
|
||||
'responses' => ['200' => ['description' => 'Projektliste'], '401' => $errorResponse],
|
||||
],
|
||||
],
|
||||
@@ -350,6 +406,169 @@ $spec = [
|
||||
],
|
||||
],
|
||||
|
||||
'/api/bugtracker/v1/roadmap.php' => [
|
||||
'get' => [
|
||||
'tags' => ['Bugtracker'],
|
||||
'summary' => 'Roadmap lesen',
|
||||
'description' =>
|
||||
"Scope bugtracker:read.\n\n"
|
||||
. "**Keine eigene Datenhaltung.** Ein Roadmap-Eintrag ist ein "
|
||||
. "bugtracker_item mit gesetztem `epic`; dieser Endpunkt ist die Sicht "
|
||||
. "darauf. Angelegt wird ueber `/report`, abgeschlossen ueber `/manage`.\n\n"
|
||||
. "- `action=list` Eintraege, nach Bereich und Reihenfolge sortiert\n"
|
||||
. "- `action=epics` Themenbereiche samt Zaehlung je Lage\n"
|
||||
. "- `action=next` die vorderen Eintraege der Warteschlange\n"
|
||||
. "- `action=active` wer haelt gerade welches Item\n"
|
||||
. "- `action=render` der erzeugte Markdown-Block fuer die Projektdatei\n"
|
||||
. "- `action=check` Abgleich einer mitgeschickten Datei (`content`) gegen "
|
||||
. "die Items\n\n"
|
||||
. "`status` nimmt eine Lage statt eines ENUM-Werts: `aktiv`, `offen`, "
|
||||
. "`arbeit`, `erledigt`, `zurueckgestellt`, `verworfen`. Einzelstatus "
|
||||
. "funktionieren weiterhin.",
|
||||
'parameters' => [
|
||||
['name' => 'action', 'in' => 'query', 'schema' => ['type' => 'string', 'enum' => ['list', 'epics', 'next', 'active', 'render', 'check'], 'default' => 'list']],
|
||||
['name' => 'project_slug', 'in' => 'query', 'schema' => ['type' => 'string']],
|
||||
['name' => 'epic', 'in' => 'query', 'schema' => ['type' => 'string'], 'description' => 'Themenbereich, z. B. "A"'],
|
||||
['name' => 'status', 'in' => 'query', 'schema' => ['type' => 'string'], 'description' => 'Lage oder kommagetrennte Einzelstatus'],
|
||||
['name' => 'target_build', 'in' => 'query', 'schema' => ['type' => 'string']],
|
||||
['name' => 'claimed_by', 'in' => 'query', 'schema' => ['type' => 'string']],
|
||||
['name' => 'q', 'in' => 'query', 'schema' => ['type' => 'string'], 'description' => 'Volltextsuche'],
|
||||
['name' => 'limit', 'in' => 'query', 'schema' => ['type' => 'integer', 'default' => 200, 'maximum' => 500]],
|
||||
],
|
||||
'responses' => ['200' => ['description' => 'Roadmap-Eintraege bzw. Bereiche'], '401' => $errorResponse],
|
||||
],
|
||||
'post' => [
|
||||
'tags' => ['Bugtracker'],
|
||||
'summary' => 'Roadmap-Angaben setzen',
|
||||
'description' =>
|
||||
"Scope bugtracker:manage. Nur im eigenen Projekt - fremde Planung wird "
|
||||
. "nicht umsortiert.\n\n"
|
||||
. "- `action=set&id=` setzt `epic`, `roadmap_rank`, `target_build`, "
|
||||
. "`defer_trigger`, `doc_anchor` und optional `status`\n"
|
||||
. "- `action=move&id=` schiebt einen Eintrag eine Position (`direction=up|down`)\n"
|
||||
. "- `action=reorder` vergibt die Reihenfolge eines Bereichs neu (`epic`, `ids[]`)\n"
|
||||
. "- `action=epic` legt einen Themenbereich an oder aendert ihn\n\n"
|
||||
. "**Zurueckstellen verlangt einen Ausloeser.** `status=deferred` ohne "
|
||||
. "`defer_trigger` wird mit 400 abgelehnt: Ohne benannten Anlass ist ein "
|
||||
. "Vorhaben nicht zurueckgestellt, sondern vergessen.",
|
||||
'parameters' => [
|
||||
['name' => 'action', 'in' => 'query', 'required' => true, 'schema' => ['type' => 'string', 'enum' => ['set', 'move', 'reorder', 'epic']]],
|
||||
['name' => 'id', 'in' => 'query', 'schema' => ['type' => 'integer']],
|
||||
],
|
||||
'responses' => [
|
||||
'200' => ['description' => 'Erfolg'],
|
||||
'400' => ['description' => 'Regelverletzung, etwa Zurueckstellen ohne Ausloeser'],
|
||||
'403' => ['description' => 'Item gehoert einem anderen Projekt'],
|
||||
'401' => $errorResponse,
|
||||
],
|
||||
],
|
||||
],
|
||||
|
||||
'/api/supervisor/v1/observe' => [
|
||||
'post' => [
|
||||
'tags' => ['Supervisor'],
|
||||
'summary' => 'Befund einliefern',
|
||||
'description' =>
|
||||
"Scope supervisor:report.\n\n"
|
||||
. "Ein Befund ist keine Fehlermeldung. Er behauptet nicht, dass etwas kaputt "
|
||||
. "ist, sondern dass etwas ungewoehnlich ist - deshalb loest er keine "
|
||||
. "Benachrichtigung aus. Die Einstufung trifft die empfangende Seite, die den "
|
||||
. "Flottenblick hat; `severity_hint` heisst darum Hinweis und nicht "
|
||||
. "Schweregrad.\n\n"
|
||||
. "`client_ref` bewusst aus Detektor, Gegenstand und Fassung bauen statt "
|
||||
. "zufaellig zu erzeugen: derselbe Befund darf beliebig oft gemeldet werden "
|
||||
. "und erhoeht dann nur den Zaehler. Ein Beobachter, der minuetlich nachsieht, "
|
||||
. "legt sonst 1.440 Eintraege am Tag an. Fehlt das Feld, baut der Server es "
|
||||
. "selbst zusammen.\n\n"
|
||||
. "Die Liste gueltiger Detektornamen liefert `?action=catalog`. Ein "
|
||||
. "unbekannter Name wird angenommen, in der Antwort aber mit "
|
||||
. "`known_detector: false` gekennzeichnet - stilles Verwerfen waere "
|
||||
. "schlimmer, denn dann suchte jemand nach Befunden, die nie ankamen.",
|
||||
'requestBody' => [
|
||||
'required' => true,
|
||||
'content' => ['application/json' => ['schema' => [
|
||||
'type' => 'object',
|
||||
'required' => ['detector'],
|
||||
'properties' => [
|
||||
'project_slug' => ['type' => 'string'],
|
||||
'detector' => ['type' => 'string', 'example' => 'trend.monotonic'],
|
||||
'subject' => ['type' => 'string', 'example' => 'memory.working_set'],
|
||||
'instance' => ['type' => 'string', 'example' => 'kunde-4711/app-01'],
|
||||
'severity_hint' => ['type' => 'string', 'enum' => FindingRepo::SEVERITY_HINTS],
|
||||
'observed' => ['type' => 'object', 'description' => 'Was wurde gemessen?'],
|
||||
'baseline' => ['type' => 'object', 'description' => 'Wogegen?'],
|
||||
'build' => ['type' => 'string'],
|
||||
'commit_sha' => ['type' => 'string'],
|
||||
'environment' => ['type' => 'string', 'enum' => FindingRepo::ENVIRONMENTS],
|
||||
'client_ref' => ['type' => 'string'],
|
||||
],
|
||||
]]],
|
||||
],
|
||||
'responses' => [
|
||||
'201' => ['description' => 'Neuer Befund - finding_id, finding_status, '
|
||||
. 'occurrence_count, known_detector'],
|
||||
'200' => ['description' => 'Bekannter Befund, Zaehler erhoeht'],
|
||||
'400' => $errorResponse,
|
||||
'401' => $errorResponse,
|
||||
'429' => $errorResponse,
|
||||
],
|
||||
],
|
||||
],
|
||||
|
||||
'/api/supervisor/v1/findings' => [
|
||||
'get' => [
|
||||
'tags' => ['Supervisor'],
|
||||
'summary' => 'Befunde abfragen',
|
||||
'description' =>
|
||||
"Scope supervisor:read. Filter: project_slug, detector, status, instance, "
|
||||
. "build, environment, since, limit, offset.\n\n"
|
||||
. "`detector` nimmt auch einen Familiennamen: \"deviation\" liefert "
|
||||
. "deviation.self und deviation.fleet.\n\n"
|
||||
. "`status` ist standardmaessig \"active\" (open und acknowledged).",
|
||||
'responses' => ['200' => ['description' => 'Befundliste'], '401' => $errorResponse],
|
||||
],
|
||||
],
|
||||
|
||||
'/api/supervisor/v1/summary' => [
|
||||
'get' => [
|
||||
'tags' => ['Supervisor'],
|
||||
'summary' => 'Befunde je Detektor zaehlen',
|
||||
'description' => 'Scope supervisor:read. Der Ueberblick vor dem Einzelbefund.',
|
||||
'responses' => ['200' => ['description' => 'Zaehlung'], '401' => $errorResponse],
|
||||
],
|
||||
],
|
||||
|
||||
'/api/supervisor/v1/catalog' => [
|
||||
'get' => [
|
||||
'tags' => ['Supervisor'],
|
||||
'summary' => 'Detektor-Katalog',
|
||||
'description' =>
|
||||
"Scope supervisor:read. Alle bekannten Detektoren mit Herkunft (client oder "
|
||||
. "server), wonach sie suchen und was sie dafuer brauchen.\n\n"
|
||||
. "Die Namen sind stabil und wandern nicht - nur so bleiben Befunde aus "
|
||||
. "verschiedenen Projekten vergleichbar.",
|
||||
'responses' => ['200' => ['description' => 'Katalog'], '401' => $errorResponse],
|
||||
],
|
||||
],
|
||||
|
||||
'/api/supervisor/v1/status' => [
|
||||
'post' => [
|
||||
'tags' => ['Supervisor'],
|
||||
'summary' => 'Befund einstufen',
|
||||
'description' =>
|
||||
"Scope supervisor:manage - bewusst getrennt von supervisor:report. Ein "
|
||||
. "Beobachter auf Kundenhardware darf melden, aber nicht entscheiden, dass "
|
||||
. "seine eigene Meldung erledigt ist.\n\n"
|
||||
. "Status: open, acknowledged, promoted, resolved, ignored.",
|
||||
'responses' => [
|
||||
'200' => ['description' => 'Geaendert'],
|
||||
'400' => $errorResponse,
|
||||
'401' => $errorResponse,
|
||||
'404' => $errorResponse,
|
||||
],
|
||||
],
|
||||
],
|
||||
|
||||
'/api/updateservice/v1/check' => [
|
||||
'get' => [
|
||||
'tags' => ['UpdateService'],
|
||||
@@ -663,6 +882,64 @@ $spec = [
|
||||
],
|
||||
],
|
||||
|
||||
'/api/setup/v1/agent' => [
|
||||
'post' => [
|
||||
'tags' => ['Setup'],
|
||||
'summary' => 'Watchdog-Agent fuer die Maschine selbst',
|
||||
'description' =>
|
||||
"Scope `setup:install`. Legt den Monitor an, stellt ein Token mit genau "
|
||||
. "`watchdog:ping` aus und liefert das fertige Skript fuer diesen Host - "
|
||||
. "Shell unter Linux, PowerShell unter Windows.\n\n"
|
||||
. "Gedacht fuer den Installer, der ohnehin auf dem Zielsystem laeuft: der Weg "
|
||||
. "ueber die Oberflaeche verlangte Monitor anlegen, Token erzeugen, Skript "
|
||||
. "herunterladen, kopieren und einplanen - fuenf Schritte an einem anderen "
|
||||
. "Rechner.\n\n"
|
||||
. "Einen bereits vorhandenen Monitor gleichen Namens lehnt der Endpunkt mit "
|
||||
. "`409 monitor_exists` ab. Sonst uebernaehme eine zweite Maschine "
|
||||
. "stillschweigend die Historie der ersten; `overwrite: true` erlaubt es "
|
||||
. "ausdruecklich.\n\n"
|
||||
. "Das Skript enthaelt das Token im Klartext und wird nur einmal ausgeliefert.",
|
||||
'requestBody' => [
|
||||
'required' => true,
|
||||
'content' => ['application/json' => ['schema' => [
|
||||
'type' => 'object',
|
||||
'required' => ['project', 'source'],
|
||||
'properties' => [
|
||||
'project' => ['type' => 'string', 'description' => 'Produkt, an das das Token gebunden wird.'],
|
||||
'source' => ['type' => 'string', 'description' => 'Name des Monitors im Dashboard.'],
|
||||
'os' => ['type' => 'string', 'enum' => ['linux', 'windows'], 'default' => 'linux'],
|
||||
'interval' => ['type' => 'integer', 'default' => 60, 'description' => 'Erwarteter Abstand der Heartbeats in Sekunden (30 bis 3600).'],
|
||||
'group' => ['type' => 'string', 'description' => 'Gruppierung im Dashboard.'],
|
||||
'parent' => ['type' => 'string', 'description' => 'Uebergeordneter Monitor, etwa der Hypervisor.'],
|
||||
'overwrite' => ['type' => 'boolean', 'default' => false, 'description' => 'Einen bestehenden Monitor gleichen Namens uebernehmen.'],
|
||||
],
|
||||
]]],
|
||||
],
|
||||
'responses' => [
|
||||
'201' => [
|
||||
'description' => 'Monitor eingerichtet, Skript enthaelt das Token',
|
||||
'content' => ['application/json' => ['schema' => [
|
||||
'type' => 'object',
|
||||
'properties' => [
|
||||
'source' => ['type' => 'string'],
|
||||
'os' => ['type' => 'string'],
|
||||
'filename' => ['type' => 'string'],
|
||||
'script' => ['type' => 'string'],
|
||||
'schedule' => ['type' => 'string', 'description' => 'Einplanungsbefehl; {PFAD} steht fuer den Ablageort.'],
|
||||
'interval' => ['type' => 'integer'],
|
||||
'token_id' => ['type' => 'string'],
|
||||
'existing' => ['type' => 'boolean'],
|
||||
],
|
||||
]]],
|
||||
],
|
||||
'401' => $errorResponse,
|
||||
'403' => $errorResponse,
|
||||
'404' => $errorResponse,
|
||||
'409' => $errorResponse,
|
||||
],
|
||||
],
|
||||
],
|
||||
|
||||
'/api/watchdog/v1/ping' => [
|
||||
'post' => [
|
||||
'tags' => ['Watchdog'],
|
||||
@@ -874,6 +1151,56 @@ $spec = [
|
||||
],
|
||||
],
|
||||
|
||||
'/api/license/v1/dev-key' => [
|
||||
'post' => [
|
||||
'tags' => ['Lizenz'],
|
||||
'summary' => 'Entwicklungsschluessel abholen (Selbstbedienung)',
|
||||
'description' =>
|
||||
"Scope `license:dev`. Gedacht fuer Werkbank-Token auf Testmaschinen.\n\n"
|
||||
. "**Antwortet im Hausformat** (`status: \"success\"`) - anders als `validate` und "
|
||||
. "`deactivate` daneben, die ihr abweichendes Altformat behalten.\n\n"
|
||||
. "**Der Aufruf ist wiederholbar.** Fuer dieselbe Kombination aus `project_slug` "
|
||||
. "und `instance_id` kommt derselbe Schluessel zurueck und seine Frist wird "
|
||||
. "verlaengert. Ein Testskript darf ihn deshalb an den Anfang jedes Laufs setzen, "
|
||||
. "ohne bei jedem Lauf einen weiteren Schluessel zu hinterlassen. `created` sagt, "
|
||||
. "ob er neu ist.\n\n"
|
||||
. "Der ausgestellte Schluessel ist eine gewoehnliche Lizenz: befristet (Vorgabe 30 "
|
||||
. "Tage, einstellbar ueber `license.dev_ttl_days`), mit wenigen Aktivierungen, und "
|
||||
. "in `customer_email` als Testschluessel markiert. Er oeffnet damit auch die "
|
||||
. "Release-Ablage des Produkts - die `.htpasswd` wird beim Ausstellen sofort "
|
||||
. "nachgezogen.\n\n"
|
||||
. "Projektgebundene Token kommen nur an ihr eigenes Projekt; die Ausnahme fuer "
|
||||
. "Werkbank-Token gilt hier **nicht**. Ein Lizenzschluessel oeffnet Pakete, eine "
|
||||
. "Meldung tut das nicht.\n\n"
|
||||
. "Zum Zurueckgeben `action_mode: \"revoke\"` senden. Abgelaufene Schluessel "
|
||||
. "verschwinden ohnehin von selbst.\n\n"
|
||||
. "Begrenzt auf 10 Anfragen pro Minute und IP, und auf 12 gleichzeitig gueltige "
|
||||
. "Schluessel je Projekt.",
|
||||
'requestBody' => [
|
||||
'required' => true,
|
||||
'content' => ['application/json' => ['schema' => [
|
||||
'type' => 'object',
|
||||
'required' => ['project_slug', 'instance_id'],
|
||||
'properties' => [
|
||||
'project_slug' => ['type' => 'string', 'description' => 'Slug aus dc_projects.'],
|
||||
'instance_id' => ['type' => 'string', 'example' => 'testvm', 'description' => 'Kennung der Maschine. Ueber sie findet ein wiederholter Aufruf denselben Schluessel wieder; ein FQDN wird auf den kurzen Namen gekuerzt.'],
|
||||
'ttl_days' => ['type' => 'integer', 'example' => 30, 'description' => 'Gewuenschte Laufzeit, begrenzt auf 90 Tage.'],
|
||||
'action_mode' => ['type' => 'string', 'enum' => ['issue', 'revoke'], 'default' => 'issue'],
|
||||
],
|
||||
]]],
|
||||
],
|
||||
'responses' => [
|
||||
'200' => ['description' => 'Bestehender Schluessel verlaengert oder zurueckgegeben'],
|
||||
'201' => ['description' => 'Neuer Schluessel ausgestellt'],
|
||||
'400' => $errorResponse,
|
||||
'401' => $errorResponse,
|
||||
'403' => $errorResponse,
|
||||
'409' => $errorResponse,
|
||||
'429' => $errorResponse,
|
||||
],
|
||||
],
|
||||
],
|
||||
|
||||
'/api/license/v1/status' => [
|
||||
'get' => [
|
||||
'tags' => ['Lizenz'],
|
||||
|
||||
@@ -0,0 +1,239 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* /api/supervisor/v1/...
|
||||
*
|
||||
* Eingang und Abfrage der Supervisor-Befunde.
|
||||
*
|
||||
* POST ?action=observe Befund einliefern (supervisor:report)
|
||||
* GET ?action=findings Befunde abfragen (supervisor:read)
|
||||
* GET ?action=summary Zaehlung je Detektor (supervisor:read)
|
||||
* GET ?action=catalog Der Detektor-Katalog (supervisor:read)
|
||||
* POST ?action=status Befund einstufen (supervisor:read)
|
||||
*
|
||||
* Ein Befund ist keine Fehlermeldung. Er behauptet nicht, dass etwas kaputt
|
||||
* ist, sondern dass etwas ungewoehnlich ist - deshalb loest er hier auch
|
||||
* keine Benachrichtigung aus.
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
require_once __DIR__ . '/../../../../src/bootstrap.php';
|
||||
|
||||
use Deploymentcenter\Core\ApiAuth;
|
||||
use Deploymentcenter\Core\Config;
|
||||
use Deploymentcenter\Core\Db;
|
||||
use Deploymentcenter\Core\Http;
|
||||
use Deploymentcenter\Modules\License\RateLimiter;
|
||||
use Deploymentcenter\Modules\Supervisor\Catalog;
|
||||
use Deploymentcenter\Modules\Supervisor\FindingRepo;
|
||||
|
||||
const READ_ACTIONS = ['findings', 'summary', 'catalog'];
|
||||
const WRITE_ACTIONS = ['observe', 'status'];
|
||||
|
||||
/**
|
||||
* Aktion aus ?action= oder dem letzten Pfadsegment - wie beim Watchdog, damit
|
||||
* beide Schreibweisen funktionieren:
|
||||
* POST /api/supervisor/v1/observe
|
||||
* POST /api/supervisor/v1/?action=observe
|
||||
*/
|
||||
function resolveSupervisorAction(): string
|
||||
{
|
||||
$explicit = Http::str('action');
|
||||
if ($explicit !== null) {
|
||||
return strtolower($explicit);
|
||||
}
|
||||
|
||||
$segments = array_values(array_filter(
|
||||
explode('/', trim(Http::path(), '/')),
|
||||
static fn(string $s): bool => $s !== ''
|
||||
));
|
||||
|
||||
$last = strtolower((string)end($segments));
|
||||
|
||||
return match ($last) {
|
||||
'observe' => 'observe',
|
||||
'summary' => 'summary',
|
||||
'catalog' => 'catalog',
|
||||
'status' => 'status',
|
||||
default => 'findings',
|
||||
};
|
||||
}
|
||||
|
||||
Http::beginJson(['GET', 'POST', 'OPTIONS'], true);
|
||||
|
||||
$action = resolveSupervisorAction();
|
||||
|
||||
if (!in_array($action, READ_ACTIONS, true) && !in_array($action, WRITE_ACTIONS, true)) {
|
||||
Http::fail(404, 'unknown_action', sprintf('Unbekannte Aktion "%s".', $action), null, [
|
||||
'available' => array_merge(READ_ACTIONS, WRITE_ACTIONS),
|
||||
]);
|
||||
}
|
||||
|
||||
$isWrite = in_array($action, WRITE_ACTIONS, true);
|
||||
|
||||
if ($isWrite && Http::method() !== 'POST') {
|
||||
Http::fail(405, 'method_not_allowed', sprintf('Die Aktion "%s" erwartet POST.', $action));
|
||||
}
|
||||
|
||||
$db = Db::init();
|
||||
|
||||
// Ein Beobachter meldet regelmaessig. Bricht seine Zustandsverwaltung, sendet
|
||||
// er im Sekundentakt - dann soll er gedrosselt werden und nicht die Tabelle
|
||||
// fuellen.
|
||||
if ($action === 'observe') {
|
||||
$limiter = new RateLimiter(
|
||||
$db,
|
||||
(int)Config::get('supervisor.observe_rate', 120),
|
||||
60,
|
||||
'sv_observe'
|
||||
);
|
||||
|
||||
if (!$limiter->check(Http::clientIp())) {
|
||||
Http::fail(429, 'rate_limited', 'Zu viele Befunde. Bitte Sendefrequenz reduzieren.');
|
||||
}
|
||||
}
|
||||
|
||||
// Drei Rechte, drei Rollen:
|
||||
// observe - der Beobachter auf der Kundenmaschine, meldet nur
|
||||
// status - die Sichtung, entscheidet ueber Befunde
|
||||
// Rest - Lesen
|
||||
//
|
||||
// Beim Einliefern ist die Sitzung bewusst nicht erlaubt: das ist die
|
||||
// Maschinenschnittstelle.
|
||||
$scope = match ($action) {
|
||||
'observe' => 'supervisor:report',
|
||||
'status' => 'supervisor:manage',
|
||||
default => 'supervisor:read',
|
||||
};
|
||||
|
||||
$context = ApiAuth::requireScope($db, $scope, null, $action !== 'observe');
|
||||
|
||||
$repo = new FindingRepo($db);
|
||||
|
||||
switch ($action) {
|
||||
|
||||
// ---------------------------------------------------------------- lesen
|
||||
case 'catalog':
|
||||
Http::ok([
|
||||
'count' => count(Catalog::DETECTORS),
|
||||
'detectors' => Catalog::DETECTORS,
|
||||
]);
|
||||
// no break - Http::ok beendet die Anfrage
|
||||
|
||||
case 'summary':
|
||||
$slug = ApiAuth::projectFilter($context, true) ?? Http::str('project_slug');
|
||||
Http::ok([
|
||||
'project_slug' => $slug,
|
||||
'by_detector' => $repo->byDetector($slug),
|
||||
]);
|
||||
|
||||
case 'findings':
|
||||
$bound = ApiAuth::projectFilter($context, true);
|
||||
|
||||
$result = $repo->search([
|
||||
'project_slug' => $bound ?? Http::str('project_slug') ?? 'all',
|
||||
'detector' => Http::str('detector'),
|
||||
'status' => Http::str('status'),
|
||||
'instance' => Http::str('instance'),
|
||||
'build' => Http::str('build'),
|
||||
'environment' => Http::str('environment'),
|
||||
'since' => Http::str('since'),
|
||||
'limit' => Http::int('limit', 50),
|
||||
'offset' => Http::int('offset', 0),
|
||||
]);
|
||||
|
||||
Http::ok($result);
|
||||
|
||||
// ------------------------------------------------------------ schreiben
|
||||
case 'observe':
|
||||
$data = Http::body();
|
||||
|
||||
if ($data === []) {
|
||||
Http::fail(400, 'empty_body', 'Der Request-Body ist leer.');
|
||||
}
|
||||
|
||||
$projectSlug = is_string($data['project_slug'] ?? null) ? trim($data['project_slug']) : null;
|
||||
ApiAuth::enforceProject($context, $projectSlug);
|
||||
|
||||
// Ein projektgebundenes Token meldet immer fuer sein eigenes Projekt.
|
||||
// Anders als beim Bugtracker gibt es hier keine Ausnahme fuer
|
||||
// Werkbank-Token: ein Befund ist eine Beobachtung an einer laufenden
|
||||
// Installation, und die macht man nicht stellvertretend fuer ein
|
||||
// fremdes Projekt.
|
||||
$home = ApiAuth::homeProject($context);
|
||||
if ($home !== null) {
|
||||
$data['project_slug'] = $home;
|
||||
}
|
||||
|
||||
// Die Herkunft wird abgeleitet, nicht uebernommen - ein Client darf
|
||||
// seine Befunde nicht als serverseitig ermittelt ausgeben.
|
||||
$data['origin'] = Catalog::ORIGIN_CLIENT;
|
||||
|
||||
try {
|
||||
$result = $repo->record($data);
|
||||
} catch (\InvalidArgumentException $e) {
|
||||
Http::fail(400, 'invalid_finding', $e->getMessage());
|
||||
}
|
||||
|
||||
Http::ok([
|
||||
'finding_id' => $result['id'],
|
||||
'is_new' => $result['is_new'],
|
||||
'occurrence_count' => $result['occurrence_count'],
|
||||
'detector' => $result['detector'],
|
||||
// NICHT 'status'. Http::ok() legt ['status' => 'success'] als
|
||||
// Umschlag darum und merged dieses Feld darueber - der Zustand des
|
||||
// Befundes ueberschrieb also die Erfolgsmeldung. Jeder Client, der
|
||||
// wie dokumentiert auf status === "success" prueft, brach
|
||||
// ausgerechnet an dem Endpunkt, den ein meldender Client am
|
||||
// haeufigsten aufruft.
|
||||
'finding_status' => $result['status'],
|
||||
'client_ref' => $result['client_ref'],
|
||||
// Ein unbekannter Detektorname wird angenommen, aber gemeldet.
|
||||
// Still verwerfen waere schlimmer: dann suchte jemand tagelang
|
||||
// nach Befunden, die nie ankamen.
|
||||
'known_detector' => $result['known_detector'],
|
||||
'message' => $result['known_detector']
|
||||
? ($result['is_new'] ? 'Befund aufgenommen.' : 'Bekannter Befund - Zaehler erhoeht.')
|
||||
: sprintf(
|
||||
'Befund aufgenommen. Achtung: "%s" steht nicht im Katalog - Tippfehler, '
|
||||
. 'oder der Katalog muss erweitert werden.',
|
||||
$result['detector']
|
||||
),
|
||||
], $result['is_new'] ? 201 : 200);
|
||||
|
||||
case 'status':
|
||||
$id = Http::int('id', 0);
|
||||
|
||||
if ($id <= 0) {
|
||||
Http::fail(400, 'missing_id', 'Es wurde keine Befund-ID uebergeben.');
|
||||
}
|
||||
|
||||
$finding = $repo->get($id);
|
||||
if ($finding === null) {
|
||||
Http::fail(404, 'not_found', sprintf('Befund #%d existiert nicht.', $id));
|
||||
}
|
||||
|
||||
ApiAuth::enforceProject($context, (string)$finding['project_slug'], true);
|
||||
|
||||
$status = Http::str('status');
|
||||
if ($status === null || !in_array($status, FindingRepo::STATUSES, true)) {
|
||||
Http::fail(400, 'invalid_status', 'Ungueltiger Status.', null, [
|
||||
'allowed' => FindingRepo::STATUSES,
|
||||
]);
|
||||
}
|
||||
|
||||
if (!$repo->setStatus($id, $status, $context['actor'])) {
|
||||
Http::fail(500, 'update_failed', sprintf('Befund #%d konnte nicht geaendert werden.', $id));
|
||||
}
|
||||
|
||||
Http::ok([
|
||||
'finding_id' => $id,
|
||||
// Aus demselben Grund wie bei 'observe' nicht 'status': Der
|
||||
// gesetzte Zustand ueberschriebe sonst die Erfolgsmeldung des
|
||||
// Umschlags. Hier faellt es weniger auf, weil ein Mensch die
|
||||
// Einstufung ausloest - der Fehler ist derselbe.
|
||||
'finding_status' => $status,
|
||||
'message' => sprintf('Befund #%d auf "%s" gesetzt.', $id, $status),
|
||||
]);
|
||||
}
|
||||
+194
-5
@@ -1,16 +1,205 @@
|
||||
{
|
||||
"_comment": "Einzige Quelle der Wahrheit fuer den Changelog. Wird von /docs/changelog.php gerendert und von GET /api/updateservice/v1/changelog?since=X ausgeliefert. Neue Eintraege oben einfuegen.",
|
||||
|
||||
"schema": 1,
|
||||
"current": "2.6.0",
|
||||
|
||||
"current": "2.7.0",
|
||||
"versions": [
|
||||
{
|
||||
"version": "2.7.0",
|
||||
"date": "2026-08-29",
|
||||
"summary": "Die Roadmap zieht in das Deploymentcenter: Planungsstand, Reihenfolge und Zustaendigkeit stehen dort, wo sie ohnehin gefuehrt werden, und nicht mehr in handgepflegten Markdown-Dateien daneben. Die Dateien behalten, was eine Tabellenzelle nicht traegt - die Begruendung.",
|
||||
"actionRequired": true,
|
||||
"changes": [
|
||||
{
|
||||
"area": "api",
|
||||
"breaking": false,
|
||||
"title": "Roadmap als Sicht auf den Bugtracker - keine zweite Ablage",
|
||||
"text": "Migration 016 legt KEINE Roadmap-Tabelle an. Ein Roadmap-Eintrag IST ein bugtracker_item; es fehlten nur vier Angaben, die ein Backlog nicht braucht und eine Planung schon: epic (Themenbereich), roadmap_rank (Reihenfolge - Schweregrad ist keine Prioritaet), target_build (Zielfassung VOR der Umsetzung, abgegrenzt von resolved_in_build danach) und defer_trigger. Dazu doc_anchor: der Verweis auf die Stelle in der Projektdatei, an der die Begruendung steht. Neu ausserdem der Status \"deferred\" und die winzige Tabelle roadmap_epics fuer die Bereichstitel - stuenden die an jedem Item, waeren sie in jeder Zeile anders schreibbar. Die Zugehoerigkeit ist EIN Feld: Ein Item steht auf der Roadmap, wenn es ein epic hat. Ein zweites Kennzeichen daneben waeren zwei Angaben, die dasselbe behaupten und auseinanderlaufen koennen.",
|
||||
"action": "Migration 016 ausfuehren. Wer eigene Auswertungen auf bugtracker_items.status hat, muss \"deferred\" einordnen: Es zaehlt NICHT als offener Punkt und taucht bewusst nicht in ?action=next auf - genau das ist sein Zweck. Abzugrenzen von \"rejected\": verworfen heisst \"nicht erneut vorschlagen\", zurueckgestellt heisst \"es gibt einen Anlass, an dem es wieder ansteht\"."
|
||||
},
|
||||
{
|
||||
"area": "api",
|
||||
"breaking": false,
|
||||
"title": "Zurueckstellen ohne Ausloeser wird abgelehnt",
|
||||
"text": "status=deferred verlangt defer_trigger mit mindestens 10 Zeichen: Woran erkennt man, dass \"spaeter\" jetzt ist? Ohne benannten Anlass ist ein Vorhaben nicht zurueckgestellt, sondern vergessen - und ein vergessener Punkt sieht in jeder Liste aus wie ein geplanter. Die Regel sitzt im Repository und gilt damit auf allen drei Wegen gleich (WebUI, /manage?action=update, roadmap.php?action=set); in einem Formular allein waere sie in dem Moment wirkungslos, in dem ein Agent die API benutzt. Abgelehnt wird mit 400 invalid_update statt 404 - ein fehlender Ausloeser ist kein fehlendes Item. Ein zurueckgestelltes Item verliert ausserdem seine Lease: Wer etwas vertagt, arbeitet nicht mehr daran.",
|
||||
"action": null
|
||||
},
|
||||
{
|
||||
"area": "api",
|
||||
"breaking": false,
|
||||
"title": "Neuer Endpunkt /api/bugtracker/v1/roadmap.php",
|
||||
"text": "Lesend (bugtracker:read): action=list liefert die Eintraege nach Bereich und Reihenfolge, epics die Bereiche samt Zaehlung je Lage, next die vorderen Eintraege der Warteschlange, active wer gerade welches Item haelt, render den erzeugten Markdown-Block, check den Abgleich einer mitgeschickten Datei. Schreibend (bugtracker:manage, nur im eigenen Projekt): set, move, reorder, epic. Der status-Parameter nimmt eine Lage statt eines ENUM-Werts - aktiv, offen, arbeit, erledigt, zurueckgestellt, verworfen; zwoelf Status sind fuer die Ablage richtig und fuer eine Auswahlliste zu viele. Angelegt wird weiterhin ueber /report und abgeschlossen ueber /manage: Ein zweiter Schreibweg auf dieselben Spalten waere eine zweite Stelle, an der Regeln gelten muessten.",
|
||||
"action": null
|
||||
},
|
||||
{
|
||||
"area": "mcp",
|
||||
"breaking": false,
|
||||
"title": "dc_roadmap und dc_roadmap_set - der Planungsstand als Werkzeug",
|
||||
"text": "Der Adapter hat jetzt 15 Werkzeuge. dc_roadmap beantwortet zu Sitzungsbeginn die zwei Fragen, die man sich sonst falsch beantwortet: was ist als Naechstes dran, und arbeitet schon jemand daran. dc_roadmap_set hebt ein Item auf die Roadmap (epic setzen), reiht es ein und traegt die Zielfassung nach. Beide bewusst getrennt von dc_report: Anlegen und Einplanen sind zwei Entscheidungen, und ein Werkzeug, das beides zugleich tut, trifft die zweite ungefragt mit.",
|
||||
"action": "In den Projekten mit eingerichtetem Adapter den Roadmap-Abschnitt aus docs/AGENT_PROMPT_TEMPLATE.md in CLAUDE.md bzw. AGENTS.md uebernehmen. Ohne ihn weiss ein Agent nicht, dass er vor der Arbeit nachsehen soll."
|
||||
},
|
||||
{
|
||||
"area": "webui",
|
||||
"breaking": false,
|
||||
"title": "Neues Modul \"Roadmap\" mit Filtern nach Bereich, Lage, Zielfassung und Agent",
|
||||
"text": "Vier Unteransichten: Uebersicht (Kennzahlen, \"Als Naechstes\", wer arbeitet gerade woran, Fortschritt je Themenbereich), Alle Vorhaben (die Liste mit Reihenfolge-Pfeilen und Bearbeitungsdialog), Aufnahmeliste (offene Vorhaben ohne Bereich - der Weg vom Backlog auf die Planung) und Themenbereiche. Gefiltert wird serverseitig ueber GET-Parameter, die Ansicht ist damit als Link teilbar. Voreinstellung der Lage ist \"aktiv\" und nicht \"alle\": Eine Roadmap, die mit sechzig erledigten Eintraegen beginnt, beantwortet die Frage nicht, fuer die man sie aufschlaegt. Der Fortschrittsbalken rechnet Zurueckgestelltes und Verworfenes aus dem Nenner heraus - ein Bereich, in dem die Haelfte verworfen wurde, ist nicht zur Haelfte fertig, er ist kleiner geworden.",
|
||||
"action": null
|
||||
},
|
||||
{
|
||||
"area": "cli",
|
||||
"breaking": false,
|
||||
"title": "cli/roadmap.php: Zustandsblock erzeugen, Prosa abgleichen",
|
||||
"text": "Die Antwort auf die Frage, wie Datenbank und Markdown-Datei zusammenbleiben, ist nicht \"besser aufpassen\", sondern zweigeteilt. --write ERZEUGT den Zustandsteil der Datei zwischen <!-- dc:roadmap -->-Markern; dort kann nichts driften, weil dort niemand tippt, und ausserhalb wird nichts angefasst. --check prueft, was von Hand geschrieben ist: Verweist ein Absatz auf ein Item, das es nicht gibt (unknown_item)? Gehoert es einem anderen Projekt (foreign_item)? Fehlt zu einer zurueckgestellten Entscheidung die Begruendung (decision_undocumented)? Rueckgabewert 1 bei Fehlern, damit sich der Aufruf in deploy.py haengen laesst. Ein Item OHNE Absatz ist bewusst kein Befund - nicht jedes Vorhaben braucht eine Herleitung. Handvergebene Kennungen entfallen: Die Kennung ist die Item-ID, denn AUTO_INCREMENT vergibt nie zweimal dieselbe Nummer, waehrend ein neu vergebenes \"A12\" auf beiden Seiten stimmig aussieht und Verschiedenes meint.",
|
||||
"action": "Vorhandene ROADMAP.md, TODO.md oder PLAN.md je Projekt einmalig uebernehmen. Sechs Schritte, beschrieben in docs/ROADMAP_MIGRATION.md."
|
||||
},
|
||||
{
|
||||
"area": "api",
|
||||
"breaking": true,
|
||||
"title": "observe und status: der Zustand des Befundes heisst jetzt finding_status",
|
||||
"text": "Beide Endpunkte legten das Feld \"status\" des Befundes in dieselbe Ebene wie das Umschlagfeld \"status\" der API. Http::ok() arbeitet mit array_merge(['status' => 'success'], $data) - der Wert aus dem Body gewann. Eine angenommene Meldung kam beim Client also als status=\"open\" an. Jeder Client, der wie ueberall sonst auf status === \"success\" prueft, hielt eine erfolgreiche Meldung fuer einen Fehlschlag, und zwar ausgerechnet an dem Endpunkt, den ein meldender Client am haeufigsten aufruft. Das Feld heisst jetzt finding_status; der Umschlag sagt wieder \"success\". Zwei Testfaelle halten beides fest - dass der Umschlag stimmt UND dass die Angabe nicht einfach verschwunden ist, denn ein geloeschtes Feld haette denselben Test bestanden.",
|
||||
"action": "Wer die Antwort von /api/supervisor/v1/observe oder /status auswertet, liest den Befundzustand nun aus finding_status. In der Praxis war das Feld vorher nicht benutzbar - es kollidierte ja gerade mit dem Umschlag."
|
||||
},
|
||||
{
|
||||
"area": "betrieb",
|
||||
"breaking": false,
|
||||
"title": "Testinstanz dc-dev.mhdf.de und ein Testtor vor jedem Produktiv-Upload",
|
||||
"text": "Eine vollstaendige zweite Installation, die jederzeit geloescht und neu aufgebaut werden darf: eigene Datenbank, eigene Schluessel, Basic-Auth davor, Rocket.Chat aus. Dazu 124 Testfaelle in tests/e2e gegen API, Rechte, Migrationen und die Zugangssperre. scripts/deploy.py bringt vor jedem Upload erst den anstehenden Stand auf die Testinstanz und laesst dann den Testlauf darauf laufen; erst bei Rueckgabewert 0 geht etwas auf die Produktion (--ohne-test ist der Notausgang). Die Reihenfolge ist der Punkt: Liefe der Test gegen den vorhandenen Dev-Stand, prueft er aelteren Code als den, der gleich hochgeht. Gefundene, noch offene Fehler stehen mit Item-Nummer in tests/e2e/bekannte_befunde.json - sie laufen als BEK mit und blockieren nicht; besteht so ein Fall wieder, sagt der Lauf das ausdruecklich. Ein Lauf, in dem mehr uebersprungen als geprueft wurde, endet mit Rueckgabewert 2 statt 0: nichts ist kaputt, geprueft wurde es aber auch nicht, und der Unterschied darf nicht am Rueckgabewert verschwinden. Anleitung: docs/TESTINSTANZ.md.",
|
||||
"action": "Wer deployt, braucht scripts/deploy_dev_config.json (Vorlage: ...example.json). Ohne sie bricht scripts/deploy.py ab und verweist auf --ohne-test."
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"version": "2.6.1",
|
||||
"date": "2026-08-28",
|
||||
"summary": "Agenten koennen auf der Linux-Testumgebung selbstaendig testen: DEV-Lizenzschluessel zur Selbstbedienung, ein Werkzeug fuer Auslieferung und Meldung, und eine Nachpruefung, die als Arbeit zurueckkommt statt als Benachrichtigung.",
|
||||
"actionRequired": true,
|
||||
"changes": [
|
||||
{
|
||||
"area": "api",
|
||||
"breaking": true,
|
||||
"title": "Nachpruefung: der Fix ist erst fertig, wenn ihn jemand gegen ein Paket geprueft hat",
|
||||
"text": "Drei neue Zustaende (Migration 015): awaiting_verification, in_verification, fix_insufficient. Ein Item, dessen Fix veroeffentlicht wurde, geht nicht mehr direkt zu, sondern auf awaiting_verification - und taucht damit in ?action=next als Aufgabe auf. Das IST der Rueckkanal: Die Zustellung existierte laengst, es fehlte nur ein Status, der in der Warteschlangenabfrage vorkommt. Uebernehmen befoerdert nach in_verification, ueber denselben Claim wie gewoehnliche Arbeit. Bestaetigt wird mit status=closed; wer stattdessen erneut meldet, schiebt das Item selbsttaetig auf fix_insufficient - kein neues Item, Versuch und Fehlschlag bleiben auf einem Strang. Eine Regression bleibt davon unberuehrt und bekommt weiterhin ein eigenes Item: Sie betrifft ein bestaetigt geschlossenes Item, das zurueckkommt. Gegen das Verrotten: Laeuft die Lease ab, geht es zurueck in die Schlange; nach drei abgebrochenen Anlaeufen holt ein Vermerk einen Menschen; nach 30 Tagen ohne Pruefung wird ungeprueft geschlossen, mit einem Kommentar, der genau das sagt. Neu auch die Spalten status_changed_at (traegt den Timeout) und verification_cycles. Der Verlauf entsteht ohne zusaetzliche Tabelle: Jeder Statuswechsel schreibt jetzt strukturiertes meta_json (from/to/actor/since) in den vorhandenen Kommentarstrang - zuvor stand dort nur deutscher Fliesstext und der alte Status gar nicht.",
|
||||
"action": "Migration 015 ausfuehren. Wer eigene Auswertungen auf bugtracker_items.status hat, muss die drei neuen Werte einordnen: awaiting_verification und in_verification zaehlen NICHT als offene Fehler (der Fix ist ausgeliefert, offen ist nur die Frage), fix_insufficient dagegen schon - er ist ein offener Fehler, und zwar ein besonders aergerlicher. Wer Items ueber ?action=next abholt, muss den Status pruefen: in_verification heisst 'pruefe, ob der Fix traegt', nicht 'behebe das'."
|
||||
},
|
||||
{
|
||||
"area": "api",
|
||||
"breaking": false,
|
||||
"title": "Behoben: liegengelassene Items verschwanden lautlos aus der Warteschlange",
|
||||
"text": "Uebernehmen befoerdert ein Item von 'open' nach 'in_progress'. Lief die Lease ab, gab expireStaleLeases() zwar claimed_by, claimed_at und lease_until frei - liess den Status aber stehen. Da claimNext() nur nach 'open,planned' fragt, war ein liegengelassenes Item danach unauffindbar: kein Besitzer, nicht in der Schlange, kein Hinweis darauf, dass es je jemand angefasst hatte. Es blieb fuer immer liegen. Die Freigabe stuft den Status jetzt denselben Weg zurueck, den das Uebernehmen ihn befoerdert hat (in_progress -> open, in_verification -> awaiting_verification). Der Fehler bestand unabhaengig von der Nachpruefung und betraf jedes Projekt mit Agentenbetrieb.",
|
||||
"action": null
|
||||
},
|
||||
{
|
||||
"area": "api",
|
||||
"breaking": false,
|
||||
"title": "Wer einen Fremdbefund gemeldet hat, bekommt den Pruefauftrag",
|
||||
"text": "Beim Schreiben gilt sonst ohne Ausnahme: Ein Agent uebernimmt nur Items seines eigenen Projekts. Genau das machte den Rueckkanal unmoeglich - meldet PolyTrader einen Fehler im Deploymentcenter, gehoert das Item dem Deploymentcenter, und PolyTraders Agent bekaeme es nie zu sehen, obwohl er oft der Einzige ist, der bestaetigen kann, dass der Fix bei ihm wirkt. Geoeffnet wird deshalb genau ein Spalt: fremde Items, die auf Nachpruefung warten UND bei denen das eigene Projekt in bugtracker_item_affects vermerkt ist. Wer auf diesem Weg etwas haelt, darf es kommentieren, im Status setzen und zurueckgeben - aber nicht resolve oder update. Was in einem fremden Projekt als 'behoben in Build X' gilt, entscheidet dieses Projekt.",
|
||||
"action": null
|
||||
},
|
||||
{
|
||||
"area": "api",
|
||||
"breaking": false,
|
||||
"title": "Regression oder nur ein veralteter Pruefstand? Der Tracker vergleicht jetzt die Fassungen",
|
||||
"text": "Trifft eine Meldung auf ein bereits erledigtes Item, wurde daraus bisher IMMER eine Regression - ein neues Item mit Verweis auf das alte. Verglichen wurde nichts. Auf einer Testumgebung ist der haeufigste Fall aber ein anderer: Ein Lauf gegen 1.4.2 findet einen Fehler, der in 1.4.3 behoben wurde. Das ist kein Rueckschritt der Software, sondern eine veraltete Installation. Waere jede solche Meldung eine 'Regression', waere die Kennzeichnung wertlos fuer die echten. Neu wird build_version gegen resolved_in_build des erledigten Items verglichen (ueber den vorhandenen semantischen Vergleicher UpdateService\\Version, nicht ueber einen zweiten). Ist die gemeldete Fassung AELTER, entsteht nichts: kein Item, kein Kommentar, kein hochgezaehlter Zaehler. Die Antwort traegt stattdessen known_fixed_in und reported_build und sagt, dass aktualisiert und erneut geprueft werden soll. Ist sie gleich oder neuer, bleibt es bei der Regression - der Systemkommentar nennt jetzt beide Fassungen. Nicht vergleichbare Angaben ('dev', 'nightly', 'unknown', fehlendes resolved_in_build) fuehren weiterhin zur Regression; im Zweifel wird gemeldet und nicht verschluckt.",
|
||||
"action": "Wer eigene Meldewege gebaut hat, schickt build_version mit. Ohne diese Angabe kann der Server nicht unterscheiden und legt weiterhin im Zweifel ein Regressionsitem an. dc-testkit traegt sie automatisch aus der manifest.json des geprueften Verzeichnisses nach."
|
||||
},
|
||||
{
|
||||
"area": "api",
|
||||
"breaking": false,
|
||||
"title": "DEV-Lizenzschluessel zur Selbstbedienung",
|
||||
"text": "Neu: POST /api/license/v1/dev-key, Scope license:dev. Eine Testmaschine stellt sich damit fuer ihr Projekt selbst einen befristeten Lizenzschluessel aus - Vorgabe 30 Tage, hoechstens 90, drei Aktivierungen, hoechstens zwoelf gleichzeitig je Projekt. Der Aufruf ist wiederholbar: Fuer dieselbe Kombination aus project_slug und instance_id kommt derselbe Schluessel zurueck und seine Frist wird verlaengert; ein Testskript darf ihn deshalb an den Anfang jedes Laufs setzen. Der Schluessel wird beim Ausstellen sofort in die .htpasswd des Produkts nachgezogen und oeffnet damit auch die Release-Ablage. Er ist markiert (customer_email dev-agent@testumgebung.invalid, Name 'DEV <maschine>'), damit Testhardware in der Aktivierungsliste von echten Installationen zu unterscheiden ist. Abgelaufene Schluessel werden nach vierzehn Tagen automatisch geloescht. ACHTUNG beim Anbinden: Dieser Endpunkt antwortet im Hausformat (status: success), nicht im abweichenden Altformat von validate und deactivate daneben.",
|
||||
"action": "Wer auf der Linux-Test-VM testet, braucht je Projekt ein Werkbank-Token mit den Rechten bugtracker:manage und license:dev (Besitzerart dev_agent, an das Projekt gebunden). Bis das angelegt ist, laufen 'dc-testkit license' und 'dc-testkit report' ins Leere. Anleitung: docs/TESTUMGEBUNG.md, Abschnitt 4.2."
|
||||
},
|
||||
{
|
||||
"area": "tooling",
|
||||
"breaking": false,
|
||||
"title": "dc-testkit - ein Weg fuer Lizenz, Auslieferung und Meldung",
|
||||
"text": "Neu unter public/testkit/dc-testkit.sh, auf der Testmaschine zu holen ueber https://dc.mhdf.de/testkit/dc-testkit.sh. Deckt den ganzen Kreis eines Testlaufs ab: doctor prueft Werkzeuge, Netz, Token und Projekt; license holt und verlaengert den DEV-Schluessel; agent laedt den update-agent und gleicht die Pruefsumme gegen installer.json ab; install liefert in einen leeren Sandkasten aus; update, repair und list decken die uebrigen Wege ab; verify vergleicht das geschriebene manifest.json mit dem, was der Server als neueste Fassung fuehrt; report, next, comment, resolve und unclaim bedienen den Bugtracker; run macht alles nacheinander und meldet, was scheitert; cleanup raeumt auf und gibt den Schluessel zurueck. Braucht nur curl und python3 - jq ist auf der VM nicht installiert und wird nicht vorausgesetzt. Der Lizenzschluessel geht ueber DC_LICENSE_KEY an den Agenten und nicht ueber --license-key: Auf einer geteilten Maschine sieht jeder andere Benutzer fremde Befehlszeilen in 'ps aux'. Meldungen tragen ein aus Projekt, Titel und Fundstelle abgeleitetes client_ref - derselbe Befund aus zehn Laeufen legt ein Item an und nicht zehn.",
|
||||
"action": null
|
||||
},
|
||||
{
|
||||
"area": "docs",
|
||||
"breaking": false,
|
||||
"title": "Anleitung fuer die Linux-Testumgebung, projektuebergreifend",
|
||||
"text": "Neu: docs/TESTUMGEBUNG.md. Beschreibt die geteilte Test-VM vollstaendig - Zugang, vorhandene Werkzeuge, Testkit, Konventionen fuer den Parallelbetrieb mehrerer Projekte (eigene Datenbank, eigenes X-Display, Projektpraefix in /tmp), Sichtpruefung von Oberflaechen ueber Xvfb, xdotool und ImageMagick, sowie Belegungsliste und Aufraeumen. Bewusst NICHT unter public/: Die Datei nennt eine interne Adresse, einen Benutzernamen und den Weg, sudo zeitweise freizuschalten; /docs/ ist oeffentlich erreichbar. Zuvor lag die Beschreibung im PolyTrader-Repo, obwohl sie fuer alle Projekte gilt; dort steht jetzt nur noch ein Verweis samt der PolyTrader-eigenen Angaben.",
|
||||
"action": null
|
||||
},
|
||||
{
|
||||
"area": "docs",
|
||||
"breaking": false,
|
||||
"title": "Bekannte Luecke: der Installationsdialog ist nicht kopflos pruefbar",
|
||||
"text": "update-agent --action install ist ein Dialog mit Auswahllisten und Passwortabfrage. Ein Agent kann ihn nicht treiben - Auswahllisten brauchen Pfeiltasten an einem echten Terminal, und ein Agent gibt grundsaetzlich kein Passwort ein. 'dc-testkit install' prueft deshalb die Auslieferung in ein leeres Verzeichnis: denselben Pfad, den der Installer intern nimmt, mit Download, SHA256, Signatur, Staging und Rollback. Ungeprueft bleiben die Aufloesung von setup.json und das Schreiben der Konfiguration. Als Vorhaben in der Roadmap unter G1 vermerkt.",
|
||||
"action": null
|
||||
},
|
||||
{
|
||||
"area": "docs",
|
||||
"breaking": false,
|
||||
"title": "Fremdmeldungen: was dabei anders ist, steht jetzt dort, wo Agenten es lesen",
|
||||
"text": "Projektuebergreifendes Melden gibt es seit 2.6.0 (C1), beschrieben war es aber nirgends dort, wo ein meldender Agent hinsieht. Drei Eigenheiten fuehrten deshalb verlaesslich in die Irre: evidence ist bei einer Fremdmeldung PFLICHT (mind. 40 Zeichen, sonst 400 missing_evidence); der Schweregrad wird serverseitig auf medium gedeckelt, weil ein fremder Melder die Dringlichkeit nicht beurteilen kann; und die Meldung landet in triage_external statt in open, wird in der offenen Liste des Zielprojekts also nicht gefunden. Steht jetzt in TESTUMGEBUNG.md Abschnitt 4.6 und in der Agent-Prompt-Vorlage. Neu im Testkit: 'dc-testkit projects' zeigt die gueltigen Slugs, 'report --project <fremd> --evidence ...' meldet dorthin, und die Deckelung wird vorher angesagt statt hinterher entdeckt.",
|
||||
"action": "Wer die Agent-Prompt-Vorlage in ein Projekt kopiert hat, zieht den Abschnitt 'Projekt bestimmen' nach - die alte Fassung sagte zwar, dass DC-Fehler unter 'deploymentcenter' gehoeren, verschwieg aber die Pflichtangabe evidence. Ein Agent, der ihr folgte, lief in 400 missing_evidence und legte den Befund danach im eigenen Projekt ab, wo ihn niemand behebt."
|
||||
},
|
||||
{
|
||||
"area": "tooling",
|
||||
"breaking": false,
|
||||
"title": "Testkit: 'feature' wurde stillschweigend zu 'bug'",
|
||||
"text": "Der Bugtracker kennt genau zwei Typen, bug und feature_request, und deutet alles Uebrige wortlos in 'bug' um (BugRepo Zeile 92). Ein '--type feature' haette Feature Requests also als Fehler abgelegt, ohne dass es jemandem aufgefallen waere. Das Testkit uebersetzt jetzt feature/fr/wunsch/verbesserung nach feature_request und lehnt unbekannte Typen ab, statt sie umzudeuten. 'idea' wird gesondert abgefangen: Das ist ein Schweregrad, kein Typ. Schweregrade werden ebenfalls gegen die erlaubte Liste geprueft.",
|
||||
"action": null
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"version": "2.6.0",
|
||||
"date": "2026-08-21",
|
||||
"summary": "Der Installer prueft die Laufzeit und richtet die Ueberwachung des Hosts ein.",
|
||||
"actionRequired": false,
|
||||
"summary": "Supervisor-Befunde, MCP-Anbindung und projektuebergreifendes Melden. Der Installer prueft die Laufzeit und richtet die Ueberwachung des Hosts ein.",
|
||||
"actionRequired": true,
|
||||
"changes": [
|
||||
{
|
||||
"area": "server",
|
||||
"breaking": false,
|
||||
"title": "Serverseitige Detektoren finden, woran niemand gedacht hat",
|
||||
"text": "Fuenf Detektoren laufen im minuetlichen Tick (gedrosselt auf zehn Minuten) und arbeiten ausschliesslich auf Daten, die ohnehin hereinkommen: novel.error_signature meldet Fehlersignaturen, die es in dieser Fassung noch nie gab; silence.heartbeat verstummte Instanzen; deviation.self Abweichungen vom eigenen Verlauf; deviation.fleet Ausreisser gegenueber den anderen Installationen derselben Fassung; regression.build Verschiebungen zwischen zwei Fassungen. Keiner davon muss den gesuchten Fehler vorher kennen - der Massstab kommt aus der Wirklichkeit statt aus einem Kopf. Sie brauchen keine Client-Aenderung.",
|
||||
"action": "Fuer deviation.fleet und regression.build den Monitoren ein Projekt zuordnen (watchdog_monitors.project_slug). Ohne Zuordnung laufen die uebrigen Detektoren weiter. Ein Beobachter in der ausgelieferten Anwendung ist NICHT noetig und auch nicht vorgesehen - diese Detektoren arbeiten auf Daten, die ohnehin hereinkommen."
|
||||
},
|
||||
{
|
||||
"area": "api",
|
||||
"breaking": false,
|
||||
"title": "/api/supervisor/v1/ - Befunde einliefern und abfragen",
|
||||
"text": "POST observe nimmt Befunde entgegen (Scope supervisor:report), GET findings und summary liefern sie aus (supervisor:read), catalog nennt alle bekannten Detektoren, POST status stuft ein (supervisor:manage). Ein Befund ist keine Fehlermeldung: er behauptet nicht, dass etwas kaputt ist, sondern dass etwas ungewoehnlich ist - deshalb loest er keine Benachrichtigung aus. Idempotent ueber client_ref, damit ein minuetlich pruefender Beobachter einen Eintrag mit hohem Zaehler erzeugt und nicht 1.440 am Tag. Wer einliefert, sind Pruefwerkzeuge und Testlaeufe (dc-testkit ab 2.6.1) - ein Beobachter im ausgelieferten Programm war erwogen und ist verworfen worden, siehe docs/ROADMAP.md Abschnitt H.",
|
||||
"action": ""
|
||||
},
|
||||
{
|
||||
"area": "api",
|
||||
"breaking": false,
|
||||
"title": "Projektuebergreifend melden",
|
||||
"text": "Ein Token vom Typ dev_agent darf jetzt in ein fremdes Projekt melden - der Fall, den die Agenten-Prompt-Vorlage seit jeher verlangte und den ApiAuth::enforceProject() mit 403 verweigerte. Laufzeit-Token duerfen es weiterhin nicht: sie stecken im ausgelieferten Client und sind extrahierbar. Fuer Fremdmeldungen ist evidence Pflicht, reported_from wird aus der Token-Bindung abgeleitet statt aus dem Body uebernommen, das Item landet im Status triage_external und wird auf Schweregrad medium gedeckelt. Meldet ein zweites Projekt dasselbe, entsteht kein neues Item - es waechst die Liste der Betroffenen.",
|
||||
"action": "Fuer Claude Code je Projekt ein Token vom Typ dev_agent anlegen, gebunden an das jeweilige Projekt."
|
||||
},
|
||||
{
|
||||
"area": "api",
|
||||
"breaking": false,
|
||||
"title": "MCP-Adapter fuer Claude Code und andere Werkzeuge",
|
||||
"text": "Unter mcp/ liegt ein Adapter ohne Fremdabhaengigkeiten, der 13 Werkzeuge bereitstellt: Bugtracker (Suchen, Uebernehmen, Melden, Kommentieren, Abschliessen), Supervisor (Befunde, Zaehlung je Detektor, Kennzahlverlauf) und die Projektlandschaft. Fremddaten - Fehlermeldungen, Stacktraces, Kommentare - werden im Werkzeugergebnis abgegrenzt gekennzeichnet: sie entstehen auf fremden Maschinen und sind Daten, keine Anweisungen. Damit entfaellt das Einkopieren der Agenten-Prompt-Vorlage in jedes Projekt.",
|
||||
"action": "Adapter je Projekt in .mcp.json eintragen, siehe mcp/README.md."
|
||||
},
|
||||
{
|
||||
"area": "api",
|
||||
"breaking": false,
|
||||
"title": "Beziehungen zwischen Projekten",
|
||||
"text": "dc_project_links haelt fest, welches Projekt welches nutzt und in welcher Fassung. Damit ersetzt POST /api/bugtracker/v1/projects die von Hand gepflegte Zeile \"Deploymentcenter-Anbindung: SDK x.y.z\" in jeder Projekt-CLAUDE.md - eine Angabe, die an N Stellen nachgezogen werden muss und nach dem ersten Vergessen schweigend falsch ist. Erstmals beantwortbar: welche meiner Projekte sind von diesem SDK-Fehler betroffen?",
|
||||
"action": "Nach jeder Aenderung an der Anbindung dc_link_project aufrufen."
|
||||
},
|
||||
{
|
||||
"area": "client",
|
||||
"breaking": false,
|
||||
"title": "DeploymentcenterSdk.Version stand auf 2.5.1",
|
||||
"text": "Die Konstante war beim Sprung auf 2.6.0 nicht mitgezogen worden. Wer den Changelog wie vorgesehen mit ?since=DeploymentcenterSdk.Version abfragte, bekam 2.6.0 dauerhaft als neu gemeldet, auch nach dem Aktualisieren. Jetzt korrekt.",
|
||||
"action": ""
|
||||
},
|
||||
{
|
||||
"area": "server",
|
||||
"breaking": false,
|
||||
"title": "Projektgebundene Token kamen an fremde Statistiken",
|
||||
"text": "?action=stats nahm project_slug aus der Anfrage, ohne die Bindung des Tokens zu erzwingen - ein an Projekt X gebundenes Token konnte damit die Zahlen jedes anderen Projekts abrufen. Die Bindung geht der Anfrage jetzt vor.",
|
||||
"action": ""
|
||||
},
|
||||
{
|
||||
"area": "client",
|
||||
"breaking": false,
|
||||
|
||||
+876
-1
@@ -30,6 +30,7 @@ use Deploymentcenter\Core\Logger;
|
||||
use Deploymentcenter\Core\TokenManager as CoreTokenManager;
|
||||
use Deploymentcenter\Modules\Bugtracker\BugRepo;
|
||||
use Deploymentcenter\Modules\Bugtracker\IgnoreRules;
|
||||
use Deploymentcenter\Modules\Bugtracker\Roadmap;
|
||||
use Deploymentcenter\Modules\License\Audit;
|
||||
use Deploymentcenter\Modules\License\KeyGen;
|
||||
use Deploymentcenter\Modules\UpdateService\ReleaseGuard;
|
||||
@@ -1051,7 +1052,12 @@ if ($_SERVER['REQUEST_METHOD'] === 'POST') {
|
||||
}
|
||||
}
|
||||
|
||||
$ok = $itemId > 0 && (new BugRepo($pdo))->updateItemDetails($itemId, $updates, 'user:' . $actor);
|
||||
try {
|
||||
$ok = $itemId > 0 && (new BugRepo($pdo))->updateItemDetails($itemId, $updates, 'user:' . $actor);
|
||||
} catch (\InvalidArgumentException $e) {
|
||||
dc_flash($e->getMessage(), 'danger');
|
||||
dc_redirect('#tab-bugtracker');
|
||||
}
|
||||
|
||||
dc_flash(
|
||||
$ok ? sprintf('Item #%d aktualisiert.', $itemId) : 'Item nicht gefunden.',
|
||||
@@ -1083,6 +1089,97 @@ if ($_SERVER['REQUEST_METHOD'] === 'POST') {
|
||||
dc_redirect('#tab-bugtracker');
|
||||
}
|
||||
|
||||
// ------------------------------------------------------ Roadmap
|
||||
//
|
||||
// Alle Roadmap-Aktionen schreiben in dieselben Item-Spalten wie
|
||||
// der Bugtracker. Ein eigener Datenbestand existiert nicht - was
|
||||
// hier gesetzt wird, ist Themenbereich, Reihenfolge, Zielfassung
|
||||
// und der Verweis auf die Begruendung in der Datei.
|
||||
|
||||
case 'rm_set': {
|
||||
$itemId = (int)($_POST['item_id'] ?? 0);
|
||||
|
||||
$updates = [];
|
||||
foreach (['epic', 'target_build', 'defer_trigger', 'doc_anchor', 'status'] as $field) {
|
||||
if (array_key_exists($field, $_POST)) {
|
||||
$updates[$field] = $_POST[$field];
|
||||
}
|
||||
}
|
||||
|
||||
// Leeres Rangfeld heisst "keine Meinung", nicht "Rang 0" -
|
||||
// sonst spraenge der Eintrag an die Spitze seines Bereichs.
|
||||
if (array_key_exists('roadmap_rank', $_POST)) {
|
||||
$raw = trim((string)$_POST['roadmap_rank']);
|
||||
$updates['roadmap_rank'] = is_numeric($raw) ? (int)$raw : null;
|
||||
}
|
||||
|
||||
try {
|
||||
$ok = $itemId > 0
|
||||
&& (new BugRepo($pdo))->updateItemDetails($itemId, $updates, 'user:' . $actor);
|
||||
} catch (\InvalidArgumentException $e) {
|
||||
dc_flash($e->getMessage(), 'danger');
|
||||
dc_redirect('#tab-roadmap');
|
||||
}
|
||||
|
||||
dc_flash(
|
||||
$ok ? sprintf('Roadmap-Angaben zu #%d gespeichert.', $itemId) : 'Item nicht gefunden.',
|
||||
$ok ? 'success' : 'danger'
|
||||
);
|
||||
dc_redirect('#tab-roadmap');
|
||||
}
|
||||
|
||||
case 'rm_move': {
|
||||
$itemId = (int)($_POST['item_id'] ?? 0);
|
||||
$dir = ($_POST['direction'] ?? 'up') === 'down' ? 'down' : 'up';
|
||||
|
||||
$ok = $itemId > 0 && (new Roadmap($pdo))->move($itemId, $dir);
|
||||
|
||||
if (!$ok) {
|
||||
dc_flash('Der Eintrag steht bereits am Rand seines Bereichs.', 'danger');
|
||||
}
|
||||
dc_redirect('#tab-roadmap');
|
||||
}
|
||||
|
||||
case 'rm_save_epic': {
|
||||
$slug = trim((string)($_POST['project_slug'] ?? ''));
|
||||
$epic = trim((string)($_POST['epic'] ?? ''));
|
||||
$title = trim((string)($_POST['title'] ?? ''));
|
||||
|
||||
if ($slug === '' || $epic === '' || $title === '') {
|
||||
dc_flash('Projekt, Kuerzel und Titel werden alle drei gebraucht.', 'danger');
|
||||
dc_redirect('#sub-roadmap-epics');
|
||||
}
|
||||
|
||||
(new Roadmap($pdo))->saveEpic(
|
||||
$slug,
|
||||
$epic,
|
||||
$title,
|
||||
trim((string)($_POST['summary'] ?? '')) ?: null,
|
||||
(int)($_POST['sort_order'] ?? 100)
|
||||
);
|
||||
|
||||
dc_flash(sprintf('Themenbereich "%s" gespeichert.', e($epic)));
|
||||
dc_redirect('#sub-roadmap-epics');
|
||||
}
|
||||
|
||||
case 'rm_delete_epic': {
|
||||
$slug = trim((string)($_POST['project_slug'] ?? ''));
|
||||
$epic = trim((string)($_POST['epic'] ?? ''));
|
||||
|
||||
// Loeschen nur, solange nichts daran haengt. Sonst blieben
|
||||
// Items mit einem Bereich zurueck, den es nicht mehr gibt -
|
||||
// genau die haengende Referenz, die hier vermieden werden soll.
|
||||
$ok = (new Roadmap($pdo))->deleteEpic($slug, $epic);
|
||||
|
||||
dc_flash(
|
||||
$ok
|
||||
? sprintf('Themenbereich "%s" geloescht.', e($epic))
|
||||
: 'Der Bereich hat noch Eintraege - erst umhaengen, dann loeschen.',
|
||||
$ok ? 'success' : 'danger'
|
||||
);
|
||||
dc_redirect('#sub-roadmap-epics');
|
||||
}
|
||||
|
||||
// ------------------------------------------------ Ignore-Regeln
|
||||
case 'ir_create': {
|
||||
$rules = new IgnoreRules($pdo);
|
||||
@@ -1860,6 +1957,127 @@ function errUrl(array $overrides = []): string
|
||||
return 'index.php' . ($params !== [] ? '?' . http_build_query($params) : '') . '#sub-bugtracker-errors';
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// Roadmap
|
||||
// ----------------------------------------------------------------------
|
||||
// Kein eigener Datenbestand: Ein Roadmap-Eintrag ist ein bugtracker_item mit
|
||||
// gesetztem Themenbereich. Diese Ansicht ist eine Sicht darauf, kein zweites
|
||||
// System - deshalb liest sie dieselbe getItems()-Abfrage wie der Bugtracker,
|
||||
// nur mit anderer Sortierung und einem zusaetzlichen Filter.
|
||||
$roadmapRepo = new Roadmap($pdo);
|
||||
|
||||
$rmProject = (string)($_GET['rm_project'] ?? 'all');
|
||||
$rmEpic = (string)($_GET['rm_epic'] ?? 'all');
|
||||
$rmLage = (string)($_GET['rm_lage'] ?? 'aktiv');
|
||||
$rmAgent = (string)($_GET['rm_agent'] ?? '');
|
||||
$rmBuild = (string)($_GET['rm_build'] ?? 'all');
|
||||
$rmSearch = (string)($_GET['rm_q'] ?? '');
|
||||
|
||||
/**
|
||||
* Uebersetzt die gewaehlte Lage in Status.
|
||||
*
|
||||
* "aktiv" ist die Voreinstellung und nicht "alle": Eine Roadmap, die beim
|
||||
* Aufschlagen mit sechzig erledigten Eintraegen beginnt, beantwortet die
|
||||
* Frage nicht, fuer die man sie aufschlaegt.
|
||||
*/
|
||||
$rmLageStatuses = [
|
||||
'aktiv' => Roadmap::PENDING_STATUSES,
|
||||
'offen' => Roadmap::STATUS_GROUPS['offen'],
|
||||
'arbeit' => Roadmap::STATUS_GROUPS['arbeit'],
|
||||
'erledigt' => Roadmap::STATUS_GROUPS['erledigt'],
|
||||
'zurueckgestellt' => Roadmap::STATUS_GROUPS['zurueckgestellt'],
|
||||
'verworfen' => Roadmap::STATUS_GROUPS['verworfen'],
|
||||
];
|
||||
|
||||
$rmFilters = [
|
||||
'project_slug' => $rmProject,
|
||||
'on_roadmap' => true,
|
||||
'epic' => $rmEpic,
|
||||
'target_build' => $rmBuild,
|
||||
'claimed_by' => $rmAgent,
|
||||
'search' => $rmSearch,
|
||||
'order' => 'roadmap',
|
||||
'limit' => 400,
|
||||
];
|
||||
|
||||
if ($rmLage !== 'all' && isset($rmLageStatuses[$rmLage])) {
|
||||
$rmFilters['status'] = implode(',', $rmLageStatuses[$rmLage]);
|
||||
}
|
||||
|
||||
$roadmapResult = $bugRepo->getItems($rmFilters);
|
||||
$roadmapItems = $roadmapResult['items'];
|
||||
$roadmapTotal = $roadmapResult['total'];
|
||||
|
||||
$roadmapStats = $roadmapRepo->stats($rmProject);
|
||||
$roadmapEpics = $roadmapRepo->epics($rmProject);
|
||||
$roadmapOrphans = $roadmapRepo->orphanEpics($rmProject);
|
||||
$roadmapNext = $roadmapRepo->nextUp($rmProject, 6);
|
||||
$roadmapActive = $roadmapRepo->activeWork($rmProject);
|
||||
|
||||
// Bereichstitel als Nachschlagewerk, damit die Liste nicht je Zeile eine
|
||||
// weitere Abfrage braucht.
|
||||
$roadmapEpicTitles = [];
|
||||
foreach ($roadmapEpics as $rmE) {
|
||||
$roadmapEpicTitles[$rmE['project_slug'] . '/' . $rmE['epic']] = (string)$rmE['title'];
|
||||
}
|
||||
|
||||
// Zielfassungen, die tatsaechlich vergeben sind - eine Auswahlliste aus
|
||||
// vorhandenen Werten statt eines Freitextfelds, in das sich Tippfehler
|
||||
// schleichen.
|
||||
$roadmapBuilds = $pdo->query('
|
||||
SELECT DISTINCT target_build FROM bugtracker_items
|
||||
WHERE target_build IS NOT NULL AND target_build <> ""
|
||||
AND epic IS NOT NULL AND epic <> ""
|
||||
ORDER BY target_build DESC LIMIT 50
|
||||
')->fetchAll(PDO::FETCH_COLUMN) ?: [];
|
||||
|
||||
// Eintraege, die noch keinen Bereich haben und deshalb nicht auf der Roadmap
|
||||
// stehen. Die Aufnahmeliste: Der Weg vom Backlog auf die Planung ist genau
|
||||
// eine Angabe, und dies ist die Stelle, an der man ihn sieht.
|
||||
$roadmapCandidates = $bugRepo->getItems([
|
||||
'project_slug' => $rmProject,
|
||||
'on_roadmap' => false,
|
||||
'type' => 'feature_request',
|
||||
'status' => 'open,planned',
|
||||
'order' => 'severity',
|
||||
'limit' => 60,
|
||||
])['items'];
|
||||
|
||||
/** Baut eine URL mit den aktuellen Roadmap-Filtern. */
|
||||
function rmUrl(array $overrides = []): string
|
||||
{
|
||||
$params = [
|
||||
'rm_project' => $_GET['rm_project'] ?? null,
|
||||
'rm_epic' => $_GET['rm_epic'] ?? null,
|
||||
'rm_lage' => $_GET['rm_lage'] ?? null,
|
||||
'rm_agent' => $_GET['rm_agent'] ?? null,
|
||||
'rm_build' => $_GET['rm_build'] ?? null,
|
||||
'rm_q' => $_GET['rm_q'] ?? null,
|
||||
];
|
||||
|
||||
$params = array_merge($params, $overrides);
|
||||
$params = array_filter($params, static fn($v): bool => $v !== null && $v !== '' && $v !== 'all');
|
||||
|
||||
return 'index.php' . ($params !== [] ? '?' . http_build_query($params) : '') . '#tab-roadmap';
|
||||
}
|
||||
|
||||
/** Zeichen und Klartext zu einem Status, fuer Abzeichen in der Liste. */
|
||||
function rmBadge(string $status): string
|
||||
{
|
||||
$marker = Roadmap::MARKERS[$status] ?? '·';
|
||||
$label = Roadmap::STATUS_LABELS[$status] ?? $status;
|
||||
|
||||
$class = match (true) {
|
||||
in_array($status, ['resolved', 'closed'], true) => 'badge-up',
|
||||
$status === 'in_progress' => 'badge-warning',
|
||||
in_array($status, ['awaiting_verification', 'in_verification'], true) => 'badge-warning',
|
||||
$status === 'fix_insufficient' => 'badge-down',
|
||||
default => 'badge-stopped',
|
||||
};
|
||||
|
||||
return '<span class="badge ' . $class . '">' . $marker . ' ' . e($label) . '</span>';
|
||||
}
|
||||
|
||||
// Agenten-Uebersicht: wer bearbeitet gerade was
|
||||
$agentWorkload = $pdo->query('
|
||||
SELECT claimed_by,
|
||||
@@ -2088,6 +2306,12 @@ $csrfField = Csrf::field();
|
||||
<span class="nav-text">UpdateService</span>
|
||||
</a>
|
||||
</li>
|
||||
<li class="nav-item">
|
||||
<a class="nav-link" onclick="switchMainTab('roadmap', this)" title="Roadmap & Projektstatus">
|
||||
<svg viewBox="0 0 24 24"><line x1="3" y1="6" x2="21" y2="6"></line><line x1="3" y1="12" x2="15" y2="12"></line><line x1="3" y1="18" x2="9" y2="18"></line><circle cx="18" cy="12" r="2"></circle><circle cx="12" cy="18" r="2"></circle></svg>
|
||||
<span class="nav-text">Roadmap</span>
|
||||
</a>
|
||||
</li>
|
||||
<li class="nav-item">
|
||||
<a class="nav-link" onclick="switchMainTab('bugtracker', this)" title="Bug- & Feature-Tracker">
|
||||
<svg viewBox="0 0 24 24"><path d="M12 2a2 2 0 0 1 2 2v1h3a2 2 0 0 1 2 2v2a2 2 0 0 1-2 2h-1v2h2a1 1 0 0 1 0 2h-2v2h1a2 2 0 0 1 2 2v2a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2v-2a2 2 0 0 1 2-2h1v-2H6a1 1 0 0 1 0-2h2v-2H7a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2h3V4a2 2 0 0 1 2-2z"></path></svg>
|
||||
@@ -3575,6 +3799,592 @@ chmod +x update-agent
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- ================= MODULE: ROADMAP ================= -->
|
||||
<!--
|
||||
Kein eigener Datenbestand. Ein Roadmap-Eintrag ist ein
|
||||
bugtracker_item mit gesetztem Themenbereich; diese Ansicht ist
|
||||
die Sicht darauf. Wer hier etwas aendert, aendert dasselbe
|
||||
Item, das der Bugtracker zeigt - eine zweite Wahrheit ueber
|
||||
denselben Vorgang soll gar nicht erst entstehen koennen.
|
||||
-->
|
||||
<div id="tab-roadmap" class="tab-content">
|
||||
|
||||
<!-- =============== Subtab: Übersicht =============== -->
|
||||
<div id="sub-roadmap-board" class="subtab-content active">
|
||||
|
||||
<div class="stats-grid" style="grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));">
|
||||
<div class="stat-card">
|
||||
<div class="stat-header">📋 Offen</div>
|
||||
<div class="stat-value" style="color:#5b9dff;"><?= $roadmapStats['pending'] ?></div>
|
||||
</div>
|
||||
<div class="stat-card">
|
||||
<div class="stat-header">🔨 In Arbeit</div>
|
||||
<div class="stat-value" style="color:var(--warning);"><?= $roadmapStats['working'] ?></div>
|
||||
</div>
|
||||
<div class="stat-card">
|
||||
<div class="stat-header">✅ Erledigt</div>
|
||||
<div class="stat-value" style="color:var(--success);"><?= $roadmapStats['done'] ?></div>
|
||||
</div>
|
||||
<div class="stat-card">
|
||||
<div class="stat-header">🧊 Zurückgestellt</div>
|
||||
<div class="stat-value" style="color:var(--text-muted);"><?= $roadmapStats['deferred'] ?></div>
|
||||
</div>
|
||||
<div class="stat-card">
|
||||
<div class="stat-header">❌ Verworfen</div>
|
||||
<div class="stat-value" style="color:var(--text-muted);"><?= $roadmapStats['rejected'] ?></div>
|
||||
</div>
|
||||
<div class="stat-card">
|
||||
<div class="stat-header">🤖 Belegt</div>
|
||||
<div class="stat-value" style="color:#66bb6a;"><?= $roadmapStats['claimed'] ?></div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="card" style="padding:0.85rem 1.1rem;">
|
||||
<form method="GET" action="index.php" style="display:flex; flex-wrap:wrap; gap:0.45rem; align-items:center;">
|
||||
<select name="rm_project" class="form-input" style="width:auto; padding:0.3rem 0.6rem; font-size:0.8rem;" onchange="this.form.submit()">
|
||||
<option value="all">🌐 Alle Projekte</option>
|
||||
<?php foreach ($projects as $p): ?>
|
||||
<option value="<?= e($p['slug']) ?>" <?= $rmProject === $p['slug'] ? 'selected' : '' ?>>
|
||||
<?= e($p['name']) ?>
|
||||
</option>
|
||||
<?php endforeach; ?>
|
||||
</select>
|
||||
|
||||
<select name="rm_lage" class="form-input" style="width:auto; padding:0.3rem 0.6rem; font-size:0.8rem;" onchange="this.form.submit()">
|
||||
<?php
|
||||
// Voreinstellung ist "aktiv" und nicht "alle": Eine Roadmap,
|
||||
// die mit sechzig erledigten Eintraegen beginnt, beantwortet
|
||||
// die Frage nicht, fuer die man sie aufschlaegt.
|
||||
$rmLageOptions = [
|
||||
'aktiv' => '🎯 Aktiv (offen + in Arbeit)',
|
||||
'offen' => '📋 Nur offen',
|
||||
'arbeit' => '🔨 Nur in Arbeit',
|
||||
'erledigt' => '✅ Erledigt',
|
||||
'zurueckgestellt' => '🧊 Zurückgestellt',
|
||||
'verworfen' => '❌ Verworfen',
|
||||
'all' => '📌 Alle Lagen',
|
||||
];
|
||||
foreach ($rmLageOptions as $value => $label): ?>
|
||||
<option value="<?= e($value) ?>" <?= $rmLage === $value ? 'selected' : '' ?>><?= e($label) ?></option>
|
||||
<?php endforeach; ?>
|
||||
</select>
|
||||
|
||||
<select name="rm_epic" class="form-input" style="width:auto; padding:0.3rem 0.6rem; font-size:0.8rem;" onchange="this.form.submit()">
|
||||
<option value="all">🗂️ Alle Bereiche</option>
|
||||
<?php foreach ($roadmapEpics as $rmE): ?>
|
||||
<option value="<?= e((string)$rmE['epic']) ?>" <?= $rmEpic === (string)$rmE['epic'] ? 'selected' : '' ?>>
|
||||
<?= e((string)$rmE['epic']) ?> — <?= e((string)$rmE['title']) ?>
|
||||
</option>
|
||||
<?php endforeach; ?>
|
||||
</select>
|
||||
|
||||
<select name="rm_build" class="form-input" style="width:auto; padding:0.3rem 0.6rem; font-size:0.8rem;" onchange="this.form.submit()">
|
||||
<option value="all">🎯 Alle Zielfassungen</option>
|
||||
<?php foreach ($roadmapBuilds as $rmB): ?>
|
||||
<option value="<?= e((string)$rmB) ?>" <?= $rmBuild === (string)$rmB ? 'selected' : '' ?>><?= e((string)$rmB) ?></option>
|
||||
<?php endforeach; ?>
|
||||
</select>
|
||||
|
||||
<input type="text" name="rm_agent" value="<?= e($rmAgent) ?>" placeholder="🤖 Agent"
|
||||
class="form-input" style="width:130px; padding:0.3rem 0.6rem; font-size:0.8rem;">
|
||||
|
||||
<input type="text" name="rm_q" value="<?= e($rmSearch) ?>" placeholder="🔍 Suche"
|
||||
class="form-input" style="width:170px; padding:0.3rem 0.6rem; font-size:0.8rem;">
|
||||
|
||||
<button type="submit" class="btn btn-sm">Filtern</button>
|
||||
<a href="index.php#tab-roadmap" class="btn btn-sm btn-secondary">Zurücksetzen</a>
|
||||
</form>
|
||||
</div>
|
||||
|
||||
<?php if ($roadmapOrphans !== []): ?>
|
||||
<!--
|
||||
Ein Bereich, den ein Item nennt und den es in
|
||||
roadmap_epics nicht gibt. Meist ein Tippfehler - und
|
||||
der erzeugt sonst lautlos einen weiteren Bereich, der
|
||||
in keiner Uebersicht auftaucht.
|
||||
-->
|
||||
<div class="card" style="padding:0.9rem 1.15rem; border-left:3px solid var(--danger);">
|
||||
<strong style="font-size:0.9rem;">⚠️ Unbekannte Themenbereiche</strong>
|
||||
<div style="margin-top:0.5rem; display:flex; flex-wrap:wrap; gap:0.5rem;">
|
||||
<?php foreach ($roadmapOrphans as $orphan): ?>
|
||||
<span class="badge badge-down">
|
||||
<?= e((string)$orphan['project_slug']) ?> / <?= e((string)$orphan['epic']) ?>
|
||||
· <?= (int)$orphan['items'] ?> Eintrag/Einträge
|
||||
</span>
|
||||
<?php endforeach; ?>
|
||||
</div>
|
||||
<div style="margin-top:0.5rem; font-size:0.8rem; color:var(--text-muted);">
|
||||
Diese Kürzel stehen an Items, sind aber nicht angelegt. Unter
|
||||
„Themenbereiche“ anlegen oder die Items umhängen.
|
||||
</div>
|
||||
</div>
|
||||
<?php endif; ?>
|
||||
|
||||
<?php if ($roadmapNext !== []): ?>
|
||||
<div class="card">
|
||||
<div class="card-header">
|
||||
<h2 class="card-title">🎯 Als Nächstes</h2>
|
||||
</div>
|
||||
<!--
|
||||
Diese Liste stand frueher von Hand oben in
|
||||
ROADMAP.md und veraltete zuverlaessig. Sie ergibt
|
||||
sich jetzt aus Reihenfolge und Status.
|
||||
-->
|
||||
<table>
|
||||
<thead>
|
||||
<tr><th style="width:40px;">#</th><th>Vorhaben</th><th>Bereich</th><th>Stand</th><th>Ziel</th><th>Wer</th></tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<?php foreach ($roadmapNext as $i => $item): ?>
|
||||
<tr>
|
||||
<td style="color:var(--text-muted);"><?= $i + 1 ?>.</td>
|
||||
<td>
|
||||
<span style="font-family:'Roboto Mono'; color:var(--text-muted); font-size:0.8rem;">#<?= (int)$item['id'] ?></span>
|
||||
<strong style="margin-left:0.35rem;"><?= e((string)$item['title']) ?></strong>
|
||||
<?php if ($rmProject === 'all'): ?>
|
||||
<span class="badge badge-stopped" style="margin-left:0.4rem;"><?= e((string)$item['project_slug']) ?></span>
|
||||
<?php endif; ?>
|
||||
</td>
|
||||
<td><?= e((string)$item['epic']) ?></td>
|
||||
<td><?= rmBadge((string)$item['status']) ?></td>
|
||||
<td><?= $item['target_build'] ? '<code>' . e((string)$item['target_build']) . '</code>' : '—' ?></td>
|
||||
<td><?= $item['claimed_by'] ? e((string)$item['claimed_by']) : '<span style="color:var(--text-muted);">frei</span>' ?></td>
|
||||
</tr>
|
||||
<?php endforeach; ?>
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
<?php endif; ?>
|
||||
|
||||
<div class="card">
|
||||
<div class="card-header">
|
||||
<h2 class="card-title">🤖 Wer arbeitet gerade woran</h2>
|
||||
</div>
|
||||
<?php if ($roadmapActive === []): ?>
|
||||
<p style="color:var(--text-muted); padding:0.75rem 0;">
|
||||
Zurzeit hält kein Agent ein Item. Ohne aktive Lease ist jedes
|
||||
Vorhaben frei — das ist der Normalzustand zwischen zwei Läufen.
|
||||
</p>
|
||||
<?php else: ?>
|
||||
<table>
|
||||
<thead>
|
||||
<tr><th>Item</th><th>Projekt</th><th>Bereich</th><th>Stand</th><th>Agent</th><th>Seit</th><th>Lease läuft</th></tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<?php foreach ($roadmapActive as $work): ?>
|
||||
<tr>
|
||||
<td>
|
||||
<span style="font-family:'Roboto Mono'; color:var(--text-muted); font-size:0.8rem;">#<?= (int)$work['id'] ?></span>
|
||||
<span style="margin-left:0.35rem;"><?= e((string)$work['title']) ?></span>
|
||||
</td>
|
||||
<td><span class="badge badge-stopped"><?= e((string)$work['project_slug']) ?></span></td>
|
||||
<td><?= $work['epic'] ? e((string)$work['epic']) : '<span style="color:var(--text-muted);">—</span>' ?></td>
|
||||
<td><?= rmBadge((string)$work['status']) ?></td>
|
||||
<td><strong><?= e((string)$work['claimed_by']) ?></strong></td>
|
||||
<td style="color:var(--text-muted);"><?= e(dc_ago((string)$work['claimed_at'])) ?></td>
|
||||
<td>
|
||||
<?php $left = (int)$work['lease_minutes_left']; ?>
|
||||
<span class="badge <?= $left < 15 ? 'badge-down' : 'badge-warning' ?>">
|
||||
noch <?= $left ?> min
|
||||
</span>
|
||||
</td>
|
||||
</tr>
|
||||
<?php endforeach; ?>
|
||||
</tbody>
|
||||
</table>
|
||||
<?php endif; ?>
|
||||
</div>
|
||||
|
||||
<div class="card">
|
||||
<div class="card-header">
|
||||
<h2 class="card-title">🗂️ Themenbereiche im Überblick</h2>
|
||||
</div>
|
||||
<table>
|
||||
<thead>
|
||||
<tr>
|
||||
<th style="width:60px;">Kürzel</th><th>Bereich</th>
|
||||
<?php if ($rmProject === 'all'): ?><th>Projekt</th><?php endif; ?>
|
||||
<th style="width:220px;">Fortschritt</th>
|
||||
<th style="width:90px;">📋</th><th style="width:90px;">🔨</th>
|
||||
<th style="width:90px;">✅</th><th style="width:90px;">🧊 / ❌</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<?php foreach ($roadmapEpics as $rmE): ?>
|
||||
<?php
|
||||
$total = (int)$rmE['total'];
|
||||
$done = (int)$rmE['done'];
|
||||
// Zurueckgestelltes und Verworfenes zaehlt nicht in den
|
||||
// Nenner: Ein Bereich, in dem die Haelfte verworfen wurde,
|
||||
// ist nicht zur Haelfte fertig - er ist kleiner geworden.
|
||||
$scope = $total - (int)$rmE['deferred'] - (int)$rmE['rejected'];
|
||||
$percent = $scope > 0 ? (int)round($done / $scope * 100) : 0;
|
||||
?>
|
||||
<tr>
|
||||
<td><strong style="font-family:'Roboto Mono';"><?= e((string)$rmE['epic']) ?></strong></td>
|
||||
<td>
|
||||
<a href="<?= e(rmUrl(['rm_epic' => (string)$rmE['epic'], 'rm_project' => (string)$rmE['project_slug']])) ?>">
|
||||
<?= e((string)$rmE['title']) ?>
|
||||
</a>
|
||||
<?php if (!empty($rmE['summary'])): ?>
|
||||
<div style="font-size:0.78rem; color:var(--text-muted); margin-top:0.15rem;">
|
||||
<?= e((string)$rmE['summary']) ?>
|
||||
</div>
|
||||
<?php endif; ?>
|
||||
</td>
|
||||
<?php if ($rmProject === 'all'): ?>
|
||||
<td><span class="badge badge-stopped"><?= e((string)$rmE['project_slug']) ?></span></td>
|
||||
<?php endif; ?>
|
||||
<td>
|
||||
<div style="background:rgba(255,255,255,0.06); border-radius:4px; height:8px; overflow:hidden;">
|
||||
<div style="width:<?= $percent ?>%; height:100%; background:var(--success);"></div>
|
||||
</div>
|
||||
<span style="font-size:0.75rem; color:var(--text-muted);">
|
||||
<?= $done ?> / <?= $scope ?> <?= $scope > 0 ? '(' . $percent . '%)' : '' ?>
|
||||
</span>
|
||||
</td>
|
||||
<td><?= (int)$rmE['pending'] ?></td>
|
||||
<td><?= (int)$rmE['working'] ?></td>
|
||||
<td><?= $done ?></td>
|
||||
<td style="color:var(--text-muted);"><?= (int)$rmE['deferred'] ?> / <?= (int)$rmE['rejected'] ?></td>
|
||||
</tr>
|
||||
<?php endforeach; ?>
|
||||
<?php if ($roadmapEpics === []): ?>
|
||||
<tr><td colspan="8" style="color:var(--text-muted); padding:1rem;">
|
||||
Noch keine Themenbereiche angelegt. Unter „Themenbereiche“ anfangen.
|
||||
</td></tr>
|
||||
<?php endif; ?>
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- =============== Subtab: Alle Vorhaben =============== -->
|
||||
<div id="sub-roadmap-list" class="subtab-content">
|
||||
<div class="card">
|
||||
<div class="card-header" style="display:flex; flex-wrap:wrap; justify-content:space-between; align-items:center; gap:0.75rem;">
|
||||
<h2 class="card-title" style="margin:0;">
|
||||
🗺️ Vorhaben
|
||||
<span class="badge badge-stopped" style="margin-left:0.5rem;"><?= (int)$roadmapTotal ?> Treffer</span>
|
||||
</h2>
|
||||
<span style="font-size:0.8rem; color:var(--text-muted);">
|
||||
Filter oben unter „Übersicht“ — sie gelten für beide Ansichten.
|
||||
</span>
|
||||
</div>
|
||||
|
||||
<table>
|
||||
<thead>
|
||||
<tr>
|
||||
<th style="width:60px;">Rang</th>
|
||||
<th style="width:70px;">Item</th>
|
||||
<th>Vorhaben</th>
|
||||
<th style="width:90px;">Bereich</th>
|
||||
<th style="width:150px;">Stand</th>
|
||||
<th style="width:100px;">Ziel</th>
|
||||
<th style="width:120px;">Wer</th>
|
||||
<th style="width:60px;">Doku</th>
|
||||
<th style="width:120px;"></th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<?php $rmLastEpic = null; ?>
|
||||
<?php foreach ($roadmapItems as $item): ?>
|
||||
<?php
|
||||
$itemEpic = (string)($item['epic'] ?? '');
|
||||
// Der Schluessel traegt das Projekt mit: Ueber alle
|
||||
// Projekte hinweg gibt es "A" mehrfach, und zwei
|
||||
// gleichnamige Bereiche duerfen nicht unter einer
|
||||
// Ueberschrift landen.
|
||||
$epicKey = $item['project_slug'] . '/' . $itemEpic;
|
||||
?>
|
||||
<?php if ($epicKey !== $rmLastEpic): ?>
|
||||
<tr style="background:rgba(255,255,255,0.02);">
|
||||
<td colspan="9" style="padding:0.55rem 0.75rem; font-weight:700; font-size:0.82rem;">
|
||||
<?= e($itemEpic) ?> — <?= e($roadmapEpicTitles[$epicKey] ?? 'Unbekannter Bereich') ?>
|
||||
<?php if ($rmProject === 'all'): ?>
|
||||
<span class="badge badge-stopped" style="margin-left:0.4rem;"><?= e((string)$item['project_slug']) ?></span>
|
||||
<?php endif; ?>
|
||||
</td>
|
||||
</tr>
|
||||
<?php $rmLastEpic = $epicKey; ?>
|
||||
<?php endif; ?>
|
||||
<tr>
|
||||
<td style="font-family:'Roboto Mono'; color:var(--text-muted);">
|
||||
<?= $item['roadmap_rank'] !== null ? (int)$item['roadmap_rank'] : '—' ?>
|
||||
</td>
|
||||
<td style="font-family:'Roboto Mono'; font-size:0.8rem;">#<?= (int)$item['id'] ?></td>
|
||||
<td>
|
||||
<strong><?= e((string)$item['title']) ?></strong>
|
||||
<?php if ($rmProject === 'all'): ?>
|
||||
<span class="badge badge-stopped" style="margin-left:0.4rem;"><?= e((string)$item['project_slug']) ?></span>
|
||||
<?php endif; ?>
|
||||
<?php if ((string)$item['status'] === 'deferred' && !empty($item['defer_trigger'])): ?>
|
||||
<div style="font-size:0.78rem; color:var(--text-muted); margin-top:0.2rem;">
|
||||
🧊 Auslöser: <?= e((string)$item['defer_trigger']) ?>
|
||||
</div>
|
||||
<?php endif; ?>
|
||||
</td>
|
||||
<td><?= e($itemEpic) ?></td>
|
||||
<td><?= rmBadge((string)$item['status']) ?></td>
|
||||
<td><?= $item['target_build'] ? '<code>' . e((string)$item['target_build']) . '</code>' : '—' ?></td>
|
||||
<td><?= $item['claimed_by'] ? e((string)$item['claimed_by']) : '<span style="color:var(--text-muted);">frei</span>' ?></td>
|
||||
<td style="text-align:center;">
|
||||
<?php if (!empty($item['doc_anchor'])): ?>
|
||||
<span title="<?= e((string)$item['doc_anchor']) ?>">📄</span>
|
||||
<?php else: ?>
|
||||
<span style="color:var(--text-muted);" title="Keine Begründung hinterlegt">—</span>
|
||||
<?php endif; ?>
|
||||
</td>
|
||||
<td style="white-space:nowrap;">
|
||||
<form method="POST" action="index.php#tab-roadmap" style="display:inline">
|
||||
<?= $csrfField ?>
|
||||
<input type="hidden" name="action" value="rm_move">
|
||||
<input type="hidden" name="item_id" value="<?= (int)$item['id'] ?>">
|
||||
<input type="hidden" name="direction" value="up">
|
||||
<button type="submit" class="btn btn-sm btn-secondary" title="Nach oben">▲</button>
|
||||
</form>
|
||||
<form method="POST" action="index.php#tab-roadmap" style="display:inline">
|
||||
<?= $csrfField ?>
|
||||
<input type="hidden" name="action" value="rm_move">
|
||||
<input type="hidden" name="item_id" value="<?= (int)$item['id'] ?>">
|
||||
<input type="hidden" name="direction" value="down">
|
||||
<button type="submit" class="btn btn-sm btn-secondary" title="Nach unten">▼</button>
|
||||
</form>
|
||||
<button type="button" class="btn btn-sm btn-secondary"
|
||||
onclick='openRoadmapEdit(<?= htmlspecialchars(json_encode([
|
||||
"id" => (int)$item["id"],
|
||||
"title" => (string)$item["title"],
|
||||
"epic" => $itemEpic,
|
||||
"roadmap_rank" => $item["roadmap_rank"],
|
||||
"target_build" => (string)($item["target_build"] ?? ""),
|
||||
"defer_trigger" => (string)($item["defer_trigger"] ?? ""),
|
||||
"doc_anchor" => (string)($item["doc_anchor"] ?? ""),
|
||||
"status" => (string)$item["status"],
|
||||
], JSON_UNESCAPED_UNICODE), ENT_QUOTES) ?>)'>✏️</button>
|
||||
</td>
|
||||
</tr>
|
||||
<?php endforeach; ?>
|
||||
<?php if ($roadmapItems === []): ?>
|
||||
<tr><td colspan="9" style="color:var(--text-muted); padding:1rem;">
|
||||
Keine Vorhaben mit diesen Filtern. Unter „Aufnahmeliste“ stehen die
|
||||
Einträge, die noch keinen Bereich haben.
|
||||
</td></tr>
|
||||
<?php endif; ?>
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- =============== Subtab: Aufnahmeliste =============== -->
|
||||
<div id="sub-roadmap-intake" class="subtab-content">
|
||||
<div class="card">
|
||||
<div class="card-header">
|
||||
<h2 class="card-title">➕ Noch nicht auf der Roadmap</h2>
|
||||
</div>
|
||||
<p style="color:var(--text-muted); font-size:0.85rem; margin-bottom:0.9rem;">
|
||||
Offene Feature-Requests ohne Themenbereich. Ein Vorhaben steht auf der
|
||||
Roadmap, sobald es einen Bereich hat — ein zweites Kennzeichen daneben
|
||||
gibt es bewusst nicht, sonst könnten beide auseinanderlaufen.
|
||||
</p>
|
||||
<table>
|
||||
<thead>
|
||||
<tr><th style="width:70px;">Item</th><th>Titel</th><th style="width:110px;">Projekt</th>
|
||||
<th style="width:110px;">Schweregrad</th><th style="width:110px;">Gemeldet</th><th style="width:90px;"></th></tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<?php foreach ($roadmapCandidates as $cand): ?>
|
||||
<tr>
|
||||
<td style="font-family:'Roboto Mono'; font-size:0.8rem;">#<?= (int)$cand['id'] ?></td>
|
||||
<td><?= e((string)$cand['title']) ?></td>
|
||||
<td><span class="badge badge-stopped"><?= e((string)$cand['project_slug']) ?></span></td>
|
||||
<td><?= e((string)$cand['severity']) ?></td>
|
||||
<td style="color:var(--text-muted);"><?= e(dc_ago((string)$cand['first_seen_at'])) ?></td>
|
||||
<td>
|
||||
<button type="button" class="btn btn-sm"
|
||||
onclick='openRoadmapEdit(<?= htmlspecialchars(json_encode([
|
||||
"id" => (int)$cand["id"],
|
||||
"title" => (string)$cand["title"],
|
||||
"epic" => "",
|
||||
"roadmap_rank" => null,
|
||||
"target_build" => "",
|
||||
"defer_trigger" => "",
|
||||
"doc_anchor" => "",
|
||||
"status" => (string)$cand["status"],
|
||||
], JSON_UNESCAPED_UNICODE), ENT_QUOTES) ?>)'>Aufnehmen</button>
|
||||
</td>
|
||||
</tr>
|
||||
<?php endforeach; ?>
|
||||
<?php if ($roadmapCandidates === []): ?>
|
||||
<tr><td colspan="6" style="color:var(--text-muted); padding:1rem;">
|
||||
Nichts offen ohne Bereich — die Roadmap ist vollständig.
|
||||
</td></tr>
|
||||
<?php endif; ?>
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- =============== Subtab: Themenbereiche =============== -->
|
||||
<div id="sub-roadmap-epics" class="subtab-content">
|
||||
<div class="card">
|
||||
<div class="card-header">
|
||||
<h2 class="card-title">🗂️ Themenbereich anlegen oder ändern</h2>
|
||||
</div>
|
||||
<!--
|
||||
Der Bereichstitel steht hier und nicht an jedem Item:
|
||||
sonst waere er in jeder Zeile anders schreibbar, und
|
||||
drei Tippfehler ergaeben drei Bereiche.
|
||||
-->
|
||||
<form method="POST" action="index.php#sub-roadmap-epics">
|
||||
<?= $csrfField ?>
|
||||
<input type="hidden" name="action" value="rm_save_epic">
|
||||
<div class="form-grid">
|
||||
<div class="form-group">
|
||||
<label class="form-label">Projekt</label>
|
||||
<select name="project_slug" class="form-input" required>
|
||||
<?php foreach ($projects as $p): ?>
|
||||
<option value="<?= e($p['slug']) ?>" <?= $rmProject === $p['slug'] ? 'selected' : '' ?>>
|
||||
<?= e($p['name']) ?>
|
||||
</option>
|
||||
<?php endforeach; ?>
|
||||
</select>
|
||||
</div>
|
||||
<div class="form-group">
|
||||
<label class="form-label">Kürzel (z. B. A, B, INFRA)</label>
|
||||
<input type="text" name="epic" class="form-input" maxlength="24" required>
|
||||
</div>
|
||||
<div class="form-group">
|
||||
<label class="form-label">Titel</label>
|
||||
<input type="text" name="title" class="form-input" maxlength="160" required>
|
||||
</div>
|
||||
<div class="form-group">
|
||||
<label class="form-label">Reihenfolge</label>
|
||||
<input type="number" name="sort_order" class="form-input" value="100">
|
||||
</div>
|
||||
</div>
|
||||
<div class="form-group" style="margin-top:0.9rem;">
|
||||
<label class="form-label">Kurzbeschreibung (optional)</label>
|
||||
<input type="text" name="summary" class="form-input"
|
||||
placeholder="Wofür steht dieser Bereich? Ein Satz genügt.">
|
||||
</div>
|
||||
<button type="submit" class="btn" style="margin-top:1rem;">Bereich speichern</button>
|
||||
</form>
|
||||
</div>
|
||||
|
||||
<div class="card">
|
||||
<div class="card-header"><h2 class="card-title">Vorhandene Bereiche</h2></div>
|
||||
<table>
|
||||
<thead>
|
||||
<tr><th style="width:80px;">Kürzel</th><th>Titel</th><th style="width:120px;">Projekt</th>
|
||||
<th style="width:90px;">Einträge</th><th style="width:90px;">Sortierung</th><th style="width:110px;"></th></tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<?php foreach ($roadmapEpics as $rmE): ?>
|
||||
<tr>
|
||||
<td><strong style="font-family:'Roboto Mono';"><?= e((string)$rmE['epic']) ?></strong></td>
|
||||
<td>
|
||||
<?= e((string)$rmE['title']) ?>
|
||||
<?php if (!empty($rmE['summary'])): ?>
|
||||
<div style="font-size:0.78rem; color:var(--text-muted);"><?= e((string)$rmE['summary']) ?></div>
|
||||
<?php endif; ?>
|
||||
</td>
|
||||
<td><span class="badge badge-stopped"><?= e((string)$rmE['project_slug']) ?></span></td>
|
||||
<td><?= (int)$rmE['total'] ?></td>
|
||||
<td style="color:var(--text-muted);"><?= (int)$rmE['sort_order'] ?></td>
|
||||
<td>
|
||||
<?php if ((int)$rmE['total'] === 0): ?>
|
||||
<form method="POST" action="index.php#sub-roadmap-epics" style="display:inline"
|
||||
onsubmit="return confirm('Bereich <?= e((string)$rmE['epic']) ?> löschen?');">
|
||||
<?= $csrfField ?>
|
||||
<input type="hidden" name="action" value="rm_delete_epic">
|
||||
<input type="hidden" name="project_slug" value="<?= e((string)$rmE['project_slug']) ?>">
|
||||
<input type="hidden" name="epic" value="<?= e((string)$rmE['epic']) ?>">
|
||||
<button type="submit" class="btn btn-sm btn-danger">Löschen</button>
|
||||
</form>
|
||||
<?php else: ?>
|
||||
<span style="font-size:0.78rem; color:var(--text-muted);">hat Einträge</span>
|
||||
<?php endif; ?>
|
||||
</td>
|
||||
</tr>
|
||||
<?php endforeach; ?>
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- =============== Dialog: Roadmap-Angaben =============== -->
|
||||
<div id="roadmapEditModal" style="display:none; position:fixed; top:0; left:0; width:100%; height:100%; background:rgba(0,0,0,0.75); backdrop-filter:blur(8px); z-index:9999; align-items:center; justify-content:center; padding:1rem;">
|
||||
<div class="card" style="max-width:720px; width:100%; max-height:90vh; overflow-y:auto; margin:0;">
|
||||
<div class="card-header">
|
||||
<h2 class="card-title">Roadmap-Angaben zu <span id="rmEditLabel"></span></h2>
|
||||
</div>
|
||||
<form method="POST" action="index.php#tab-roadmap">
|
||||
<?= $csrfField ?>
|
||||
<input type="hidden" name="action" value="rm_set">
|
||||
<input type="hidden" name="item_id" id="rmEditId">
|
||||
|
||||
<div class="form-grid">
|
||||
<div class="form-group">
|
||||
<label class="form-label">Themenbereich</label>
|
||||
<select name="epic" id="rmEditEpic" class="form-input">
|
||||
<option value="">— kein Bereich (nicht auf der Roadmap) —</option>
|
||||
<?php foreach ($roadmapEpics as $rmE): ?>
|
||||
<option value="<?= e((string)$rmE['epic']) ?>">
|
||||
<?= e((string)$rmE['epic']) ?> — <?= e((string)$rmE['title']) ?>
|
||||
(<?= e((string)$rmE['project_slug']) ?>)
|
||||
</option>
|
||||
<?php endforeach; ?>
|
||||
</select>
|
||||
</div>
|
||||
<div class="form-group">
|
||||
<label class="form-label">Rang (leer = ans Ende)</label>
|
||||
<input type="number" name="roadmap_rank" id="rmEditRank" class="form-input">
|
||||
</div>
|
||||
<div class="form-group">
|
||||
<label class="form-label">Zielfassung</label>
|
||||
<input type="text" name="target_build" id="rmEditBuild" class="form-input" placeholder="z. B. 2.7.0">
|
||||
</div>
|
||||
<div class="form-group">
|
||||
<label class="form-label">Status</label>
|
||||
<select name="status" id="rmEditStatus" class="form-input" onchange="rmToggleTrigger()">
|
||||
<?php foreach (BugRepo::STATUSES as $st): ?>
|
||||
<option value="<?= e($st) ?>">
|
||||
<?= e((Roadmap::MARKERS[$st] ?? '·') . ' ' . (Roadmap::STATUS_LABELS[$st] ?? $st)) ?>
|
||||
</option>
|
||||
<?php endforeach; ?>
|
||||
</select>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="form-group" style="margin-top:0.9rem;">
|
||||
<label class="form-label">
|
||||
Wo steht die Begründung? (Pfad und Anker in der Projektdatei)
|
||||
</label>
|
||||
<input type="text" name="doc_anchor" id="rmEditAnchor" class="form-input"
|
||||
placeholder="docs/ROADMAP.md#142-symbol-upload">
|
||||
</div>
|
||||
|
||||
<div class="form-group" id="rmTriggerGroup" style="margin-top:0.9rem;">
|
||||
<label class="form-label">
|
||||
🧊 Auslöser — woran erkennt man, dass „später“ jetzt ist?
|
||||
</label>
|
||||
<textarea name="defer_trigger" id="rmEditTrigger" class="form-input" rows="2"
|
||||
placeholder="z. B.: sobald Logauszüge strukturiert hereinkommen"></textarea>
|
||||
<div style="font-size:0.78rem; color:var(--text-muted); margin-top:0.3rem;">
|
||||
Pflicht beim Zurückstellen. Ohne Auslöser ist ein Vorhaben nicht
|
||||
zurückgestellt, sondern vergessen.
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div style="display:flex; justify-content:flex-end; gap:0.75rem; margin-top:1.2rem;">
|
||||
<button type="button" class="btn btn-secondary" onclick="closeRoadmapEdit()">Abbrechen</button>
|
||||
<button type="submit" class="btn">Speichern</button>
|
||||
</div>
|
||||
</form>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- ================= MODULE: BUGTRACKER & FEATURE-TRACKER ================= -->
|
||||
<div id="tab-bugtracker" class="tab-content">
|
||||
|
||||
@@ -3704,6 +4514,13 @@ chmod +x update-agent
|
||||
// Filtereintrag wären sie nur unter "Alle Status" zu
|
||||
// finden - ein Eingang, den niemand sieht, ist keiner.
|
||||
'triage_external' => '📥 Fremdmeldungen',
|
||||
// Die Nachpruefung braucht einen eigenen Einstieg:
|
||||
// Wer wissen will, welche Fixes noch unbestaetigt
|
||||
// sind, findet sie sonst nur unter "Alle Status"
|
||||
// zwischen allem anderen.
|
||||
'awaiting_verification,in_verification'
|
||||
=> '🔎 In Nachprüfung',
|
||||
'fix_insufficient' => '❗ Fix trägt nicht',
|
||||
];
|
||||
foreach ($statusOptions as $value => $label): ?>
|
||||
<option value="<?= e($value) ?>" <?= $btFilters['status'] === $value ? 'selected' : '' ?>><?= e($label) ?></option>
|
||||
@@ -3775,6 +4592,9 @@ chmod +x update-agent
|
||||
'resolved' => '<span class="badge badge-up">GELÖST</span>',
|
||||
'rejected' => '<span class="badge badge-stopped">ABGELEHNT</span>',
|
||||
'triage_external' => '<span class="badge" style="background:rgba(120,160,255,0.2); color:#7aa2ff; border:1px solid #7aa2ff;">📥 FREMDMELDUNG</span>',
|
||||
'awaiting_verification' => '<span class="badge" style="background:rgba(0,210,255,0.18); color:#5ce1e6; border:1px solid #5ce1e6;">🔎 WARTET AUF PRÜFUNG</span>',
|
||||
'in_verification' => '<span class="badge" style="background:rgba(0,210,255,0.3); color:#5ce1e6; border:1px solid #5ce1e6;">🔎 WIRD GEPRÜFT</span>',
|
||||
'fix_insufficient' => '<span class="badge badge-down" style="font-weight:bold;">❗ FIX TRÄGT NICHT</span>',
|
||||
default => '<span class="badge badge-stopped">' . e(strtoupper((string)$item['status'])) . '</span>',
|
||||
};
|
||||
|
||||
@@ -4585,6 +5405,7 @@ Antwort:
|
||||
'watchdog:read' => ['📊 Watchdog lesen', 'Monitore und Ereignisse abfragen'],
|
||||
'updateservice:read' => ['📦 Updates prüfen', 'Auf neue Releases prüfen'],
|
||||
'updateservice:publish' => ['🚀 Releases veröffentlichen', 'Neue Releases einstellen — schließt Prüfen ein'],
|
||||
'license:dev' => ['🧪 DEV-Lizenz abholen', 'Befristeten Testschlüssel selbst ausstellen — nur für Werkbank-Token auf Testmaschinen'],
|
||||
];
|
||||
foreach ($scopeChoices as $value => $labels): ?>
|
||||
<label style="display:flex; align-items:flex-start; gap:0.5rem; font-size:0.85rem; cursor:pointer; background:rgba(255,255,255,0.03); border:1px solid var(--border-glass); border-radius:10px; padding:0.6rem 0.75rem;">
|
||||
@@ -5009,6 +5830,12 @@ SYSTEM
|
||||
{ id: 'sub-update-guard', label: '🔒 Zugangsschutz' },
|
||||
{ id: 'sub-update-publish', label: '➕ Release Veröffentlichen' }
|
||||
],
|
||||
'roadmap': [
|
||||
{ id: 'sub-roadmap-board', label: '🗺️ Übersicht', active: true },
|
||||
{ id: 'sub-roadmap-list', label: '📋 Alle Vorhaben' },
|
||||
{ id: 'sub-roadmap-intake', label: '➕ Aufnahmeliste' },
|
||||
{ id: 'sub-roadmap-epics', label: '🗂️ Themenbereiche' }
|
||||
],
|
||||
'bugtracker': [
|
||||
{ id: 'sub-bugtracker-items', label: '🐛 Bugs & Features', active: true },
|
||||
{ id: 'sub-bugtracker-errors', label: '⚡ Fehler-Stream' },
|
||||
@@ -5191,6 +6018,51 @@ SYSTEM
|
||||
// GET-Parameter - das skaliert, ueberlebt den Auto-Refresh und laesst
|
||||
// sich als Link teilen.
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
// Roadmap
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Oeffnet den Dialog fuer die Roadmap-Angaben eines Items.
|
||||
*
|
||||
* Derselbe Dialog dient dem Aufnehmen (Bereich setzen) und dem
|
||||
* Aendern. Ein eigener Aufnahmedialog waere ein zweites Formular fuer
|
||||
* dieselben vier Felder gewesen.
|
||||
*/
|
||||
function openRoadmapEdit(item) {
|
||||
document.getElementById('rmEditId').value = item.id;
|
||||
document.getElementById('rmEditLabel').innerText = '#' + item.id + ' — ' + item.title;
|
||||
document.getElementById('rmEditEpic').value = item.epic || '';
|
||||
document.getElementById('rmEditRank').value = item.roadmap_rank === null ? '' : item.roadmap_rank;
|
||||
document.getElementById('rmEditBuild').value = item.target_build || '';
|
||||
document.getElementById('rmEditAnchor').value = item.doc_anchor || '';
|
||||
document.getElementById('rmEditTrigger').value = item.defer_trigger || '';
|
||||
document.getElementById('rmEditStatus').value = item.status;
|
||||
|
||||
rmToggleTrigger();
|
||||
document.getElementById('roadmapEditModal').style.display = 'flex';
|
||||
}
|
||||
|
||||
function closeRoadmapEdit() {
|
||||
document.getElementById('roadmapEditModal').style.display = 'none';
|
||||
}
|
||||
|
||||
/**
|
||||
* Der Ausloeser ist nur beim Zurueckstellen von Belang.
|
||||
*
|
||||
* Das Feld bleibt sichtbar, wird aber hervorgehoben und als Pflicht
|
||||
* markiert - ausblenden waere schlechter, weil ein bereits
|
||||
* hinterlegter Ausloeser dann unsichtbar mitliefe.
|
||||
*/
|
||||
function rmToggleTrigger() {
|
||||
const deferred = document.getElementById('rmEditStatus').value === 'deferred';
|
||||
const group = document.getElementById('rmTriggerGroup');
|
||||
const field = document.getElementById('rmEditTrigger');
|
||||
|
||||
group.style.opacity = deferred ? '1' : '0.55';
|
||||
field.required = deferred;
|
||||
}
|
||||
|
||||
// Open Bugtracker Edit Modal
|
||||
function openEditBugtrackerModal(item) {
|
||||
document.getElementById('btEditItemId').value = item.id;
|
||||
@@ -5834,6 +6706,9 @@ SYSTEM
|
||||
<option value="closed">Geschlossen</option>
|
||||
<option value="rejected">Abgelehnt</option>
|
||||
<option value="triage_external">📥 Fremdmeldung (ungesichtet)</option>
|
||||
<option value="awaiting_verification">🔎 Wartet auf Nachprüfung</option>
|
||||
<option value="in_verification">🔎 Wird gerade geprüft</option>
|
||||
<option value="fix_insufficient">❗ Fix trägt nicht</option>
|
||||
</select>
|
||||
</div>
|
||||
<div class="form-group">
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user