feat(projekt): Projektmanagement-Tiefe nach Buch & Leitfaden v3.0
ci / quality (push) Failing after 1m0s
ci / build (push) Has been skipped

Operationalisiert den ToolCTRL-Projektmanagement-Leitfaden auf der
Projekt-Detailseite (hybrid: Cockpit-Primitive nativ, Schwergewichtiges
per Outline-Link):

- Projekt-Modus (Relax/Standard/Eskalation/Taskforce) + Dashboard-Surfacing
- Risiko- & Chancen-Register (Wahrscheinlichkeit×Auswirkung, Showstopper,
  Owner, Strategie) — offene Showstopper landen auf dem Dashboard
- Stakeholder-Analyse mit Macht/Interesse-Matrix
- Ziel & Definition: SMART-Ziel, Nicht-Ziele, Liefergegenstaende, Maxime,
  Zieldreieck (welche Ecke gibt nach)
- Meilensteine editierbar inkl. Ergebnis/Kundennutzen, Freitags-/
  Feiertags-Warnung, Mindest-2-Hinweis
- Phasen-Lebenszyklus (Definition→Planung→Umsetzung→Abschluss) mit Gate-Reviews
- Projekt-Statusbericht (Ampel/Trend/Text, extern-Flag, Verlauf) — speist
  statusCache & Pflicht-Minimum
- Änderungs-Log (Scope-Creep-Schutz), strukturierter Abschluss mit
  Checkliste + Abschlussvermerk

Migrationen 0009_pm_insights + 0010_leitfaden_phases. Enthält auch die
gemeinsame schema.ts (inkl. Lead-Tabellen aus dem Vor-Commit) und Seed.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
dejanandClaude Opus 4.8 committed 2026-06-05 17:31:30 +02:00
1 parent d72aa9fbf3
commit 864a1cef6a
22 files changed
+9237 -60

No files matched your search

+213 -1
View File
@@ -1,10 +1,16 @@
import { TRPCError } from '@trpc/server';
import { z } from 'zod';
import { and, eq, desc } from 'drizzle-orm';
import { project, milestone, area, user, type Project } from '@cockpit/db';
import { project, milestone, area, user, projectStatus, phaseGate, type Project } from '@cockpit/db';
import { ProjectSchemas } from '@cockpit/shared';
import { router, protectedProcedure } from '../trpc.js';
const PHASE_ORDER = ['definition', 'planung', 'umsetzung', 'abschluss'] as const;
function nextPhase(p: (typeof PHASE_ORDER)[number]): (typeof PHASE_ORDER)[number] {
const i = PHASE_ORDER.indexOf(p);
return PHASE_ORDER[Math.min(i + 1, PHASE_ORDER.length - 1)]!;
}
const byAreaInput = z.object({
slug: z.string().min(1),
includeArchived: z.boolean().optional(),
@@ -120,7 +126,9 @@ export const projectRouter = router({
.set({
archiviert: true,
archiviertAm: new Date(),
phase: 'abschluss',
lessonsLearnedUrl: input.lessonsLearnedUrl,
abschlussvermerk: input.abschlussvermerk ?? p.abschlussvermerk,
pflichtMinimumState: { ...p.pflichtMinimumState, retrospektive: true },
})
.where(eq(project.id, input.projectId))
@@ -128,6 +136,95 @@ export const projectRouter = router({
return updated as Project;
}),
// Phase direkt setzen (Leitfaden Kap. 2).
setPhase: protectedProcedure
.input(ProjectSchemas.setPhaseInput)
.mutation(async ({ ctx, input }) => {
const [updated] = await ctx.db
.update(project)
.set({ phase: input.phase, updatedAt: new Date() })
.where(eq(project.id, input.projectId))
.returning();
if (!updated) throw new TRPCError({ code: 'NOT_FOUND', message: 'Projekt nicht gefunden.' });
return updated;
}),
// Gate-Review am Phasenende (Leitfaden Kap. 5), optional Folgephase freigeben.
addPhaseGate: protectedProcedure
.input(ProjectSchemas.addPhaseGateInput)
.mutation(async ({ ctx, input }) => {
const [gate] = await ctx.db
.insert(phaseGate)
.values({
projectId: input.projectId,
phase: input.phase,
ergebnisErreicht: input.ergebnisErreicht,
notiz: input.notiz ?? null,
reviewedBy: ctx.user.id,
})
.returning();
if (input.advance) {
await ctx.db
.update(project)
.set({ phase: nextPhase(input.phase), updatedAt: new Date() })
.where(eq(project.id, input.projectId));
}
return gate;
}),
phaseGates: protectedProcedure
.input(ProjectSchemas.phaseGatesInput)
.query(async ({ ctx, input }) => {
return ctx.db
.select()
.from(phaseGate)
.where(eq(phaseGate.projectId, input.projectId))
.orderBy(desc(phaseGate.reviewedAt));
}),
// Statusbericht erfassen (Leitfaden Kap. 5) — speist statusCache + Pflicht-Minimum.
addStatus: protectedProcedure
.input(ProjectSchemas.addProjectStatusInput)
.mutation(async ({ ctx, input }) => {
const p = (
await ctx.db.select().from(project).where(eq(project.id, input.projectId)).limit(1)
)[0];
if (!p) throw new TRPCError({ code: 'NOT_FOUND', message: 'Projekt nicht gefunden.' });
const [created] = await ctx.db
.insert(projectStatus)
.values({
projectId: input.projectId,
ampel: input.ampel,
trend: input.trend ?? null,
text: input.text ?? null,
externSichtbar: input.externSichtbar,
createdBy: ctx.user.id,
})
.returning();
await ctx.db
.update(project)
.set({
statusCache: input.ampel,
trendCache: input.trend ?? null,
pflichtMinimumState: { ...p.pflichtMinimumState, status_aktuell: true },
updatedAt: new Date(),
})
.where(eq(project.id, input.projectId));
return created;
}),
statusHistory: protectedProcedure
.input(ProjectSchemas.projectStatusHistoryInput)
.query(async ({ ctx, input }) => {
const rows = await ctx.db
.select({ status: projectStatus, authorName: user.name })
.from(projectStatus)
.leftJoin(user, eq(user.id, projectStatus.createdBy))
.where(eq(projectStatus.projectId, input.projectId))
.orderBy(desc(projectStatus.createdAt));
return rows.map((r) => ({ ...r.status, authorName: r.authorName }));
}),
setMilestoneStatus: protectedProcedure
.input(ProjectSchemas.setMilestoneStatusInput)
.mutation(async ({ ctx, input }) => {
@@ -139,6 +236,121 @@ export const projectRouter = router({
return updated;
}),
// Projekt-Modus setzen (Buch Kap. 4): muss jederzeit ans Team kommuniziert sein.
setModus: protectedProcedure
.input(ProjectSchemas.setModusInput)
.mutation(async ({ ctx, input }) => {
const [updated] = await ctx.db
.update(project)
.set({ modus: input.modus, updatedAt: new Date() })
.where(eq(project.id, input.projectId))
.returning();
if (!updated) throw new TRPCError({ code: 'NOT_FOUND', message: 'Projekt nicht gefunden.' });
return updated;
}),
// Maxime / Beschreibung / DoD bearbeiten (Ziel-Disziplin).
update: protectedProcedure
.input(ProjectSchemas.updateProjectInput)
.mutation(async ({ ctx, input }) => {
const { projectId, ...patch } = input;
if (Object.keys(patch).length === 0) {
const existing = (
await ctx.db.select().from(project).where(eq(project.id, projectId)).limit(1)
)[0];
if (!existing) throw new TRPCError({ code: 'NOT_FOUND', message: 'Projekt nicht gefunden.' });
return existing;
}
const [updated] = await ctx.db
.update(project)
.set({ ...patch, updatedAt: new Date() })
.where(eq(project.id, projectId))
.returning();
if (!updated) throw new TRPCError({ code: 'NOT_FOUND', message: 'Projekt nicht gefunden.' });
return updated;
}),
addMilestone: protectedProcedure
.input(ProjectSchemas.addMilestoneInput)
.mutation(async ({ ctx, input }) => {
const existing = await ctx.db
.select({ id: milestone.id })
.from(milestone)
.where(eq(milestone.projectId, input.projectId));
const [created] = await ctx.db
.insert(milestone)
.values({
projectId: input.projectId,
title: input.title,
due: input.due ?? null,
order: existing.length,
})
.returning();
// Pflicht-Minimum-Punkt „Meilensteine" nachziehen (Buch: mind. 2).
const p = (
await ctx.db.select().from(project).where(eq(project.id, input.projectId)).limit(1)
)[0];
if (p) {
await ctx.db
.update(project)
.set({
pflichtMinimumState: {
...p.pflichtMinimumState,
meilensteine: existing.length + 1 >= 2,
},
})
.where(eq(project.id, input.projectId));
}
return created;
}),
updateMilestone: protectedProcedure
.input(ProjectSchemas.updateMilestoneInput)
.mutation(async ({ ctx, input }) => {
const { milestoneId, ...patch } = input;
if (Object.keys(patch).length === 0) {
const existing = (
await ctx.db.select().from(milestone).where(eq(milestone.id, milestoneId)).limit(1)
)[0];
if (!existing) throw new TRPCError({ code: 'NOT_FOUND', message: 'Meilenstein nicht gefunden.' });
return existing;
}
const [updated] = await ctx.db
.update(milestone)
.set(patch)
.where(eq(milestone.id, milestoneId))
.returning();
if (!updated) throw new TRPCError({ code: 'NOT_FOUND', message: 'Meilenstein nicht gefunden.' });
return updated;
}),
removeMilestone: protectedProcedure
.input(ProjectSchemas.removeMilestoneInput)
.mutation(async ({ ctx, input }) => {
const [removed] = await ctx.db
.delete(milestone)
.where(eq(milestone.id, input.milestoneId))
.returning({ projectId: milestone.projectId });
if (removed) {
const rest = await ctx.db
.select({ id: milestone.id })
.from(milestone)
.where(eq(milestone.projectId, removed.projectId));
const p = (
await ctx.db.select().from(project).where(eq(project.id, removed.projectId)).limit(1)
)[0];
if (p) {
await ctx.db
.update(project)
.set({
pflichtMinimumState: { ...p.pflichtMinimumState, meilensteine: rest.length >= 2 },
})
.where(eq(project.id, removed.projectId));
}
}
return { ok: true as const };
}),
listArchived: protectedProcedure.query(async ({ ctx }) => {
return await ctx.db
.select()