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

@@ -0,0 +1,40 @@
CREATE TABLE "risk" (
"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
"project_id" uuid NOT NULL,
"kind" text DEFAULT 'risiko' NOT NULL,
"title" text NOT NULL,
"wahrscheinlichkeit" text DEFAULT 'mittel' NOT NULL,
"auswirkung" text DEFAULT 'mittel' NOT NULL,
"herkunft" text,
"showstopper" boolean DEFAULT false NOT NULL,
"massnahme" text,
"status" text DEFAULT 'offen' NOT NULL,
"created_by" uuid,
"created_at" timestamp with time zone DEFAULT now() NOT NULL,
"updated_at" timestamp with time zone DEFAULT now() NOT NULL
);
--> statement-breakpoint
CREATE TABLE "stakeholder" (
"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
"project_id" uuid NOT NULL,
"name" text NOT NULL,
"rolle" text,
"interesse" text DEFAULT 'mittel' NOT NULL,
"einfluss" text DEFAULT 'mittel' NOT NULL,
"haltung" text DEFAULT 'neutral' NOT NULL,
"beduerfnis" text,
"notiz" text,
"order" integer DEFAULT 0 NOT NULL,
"created_at" timestamp with time zone DEFAULT now() NOT NULL
);
--> statement-breakpoint
ALTER TABLE "milestone" ADD COLUMN "ergebnis" text;--> statement-breakpoint
ALTER TABLE "milestone" ADD COLUMN "kundennutzen" text;--> statement-breakpoint
ALTER TABLE "project" ADD COLUMN "maxime" text;--> statement-breakpoint
ALTER TABLE "project" ADD COLUMN "modus" text DEFAULT 'standard' NOT NULL;--> statement-breakpoint
ALTER TABLE "risk" ADD CONSTRAINT "risk_project_id_project_id_fk" FOREIGN KEY ("project_id") REFERENCES "public"."project"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
ALTER TABLE "risk" ADD CONSTRAINT "risk_created_by_user_id_fk" FOREIGN KEY ("created_by") REFERENCES "public"."user"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
ALTER TABLE "stakeholder" ADD CONSTRAINT "stakeholder_project_id_project_id_fk" FOREIGN KEY ("project_id") REFERENCES "public"."project"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
CREATE INDEX "idx_risk_project" ON "risk" USING btree ("project_id");--> statement-breakpoint
CREATE INDEX "idx_risk_showstopper" ON "risk" USING btree ("showstopper");--> statement-breakpoint
CREATE INDEX "idx_stakeholder_project" ON "stakeholder" USING btree ("project_id");
@@ -0,0 +1,49 @@
CREATE TABLE "change_entry" (
"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
"project_id" uuid NOT NULL,
"titel" text NOT NULL,
"auswirkung" text,
"entscheidung" text DEFAULT 'offen' NOT NULL,
"created_by" uuid,
"created_at" timestamp with time zone DEFAULT now() NOT NULL
);
--> statement-breakpoint
CREATE TABLE "phase_gate" (
"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
"project_id" uuid NOT NULL,
"phase" text NOT NULL,
"ergebnis_erreicht" boolean NOT NULL,
"notiz" text,
"reviewed_by" uuid,
"reviewed_at" timestamp with time zone DEFAULT now() NOT NULL
);
--> statement-breakpoint
CREATE TABLE "project_status" (
"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
"project_id" uuid NOT NULL,
"ampel" text NOT NULL,
"trend" text,
"text" text,
"extern_sichtbar" boolean DEFAULT false NOT NULL,
"created_by" uuid,
"created_at" timestamp with time zone DEFAULT now() NOT NULL
);
--> statement-breakpoint
ALTER TABLE "project" ADD COLUMN "ziel" text;--> statement-breakpoint
ALTER TABLE "project" ADD COLUMN "nicht_ziele" text;--> statement-breakpoint
ALTER TABLE "project" ADD COLUMN "liefergegenstaende" text;--> statement-breakpoint
ALTER TABLE "project" ADD COLUMN "zieldreieck_flex" text;--> statement-breakpoint
ALTER TABLE "project" ADD COLUMN "phase" text DEFAULT 'definition' NOT NULL;--> statement-breakpoint
ALTER TABLE "project" ADD COLUMN "abschlussvermerk" text;--> statement-breakpoint
ALTER TABLE "risk" ADD COLUMN "strategie" text;--> statement-breakpoint
ALTER TABLE "risk" ADD COLUMN "owner_user_id" uuid;--> statement-breakpoint
ALTER TABLE "change_entry" ADD CONSTRAINT "change_entry_project_id_project_id_fk" FOREIGN KEY ("project_id") REFERENCES "public"."project"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
ALTER TABLE "change_entry" ADD CONSTRAINT "change_entry_created_by_user_id_fk" FOREIGN KEY ("created_by") REFERENCES "public"."user"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
ALTER TABLE "phase_gate" ADD CONSTRAINT "phase_gate_project_id_project_id_fk" FOREIGN KEY ("project_id") REFERENCES "public"."project"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
ALTER TABLE "phase_gate" ADD CONSTRAINT "phase_gate_reviewed_by_user_id_fk" FOREIGN KEY ("reviewed_by") REFERENCES "public"."user"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
ALTER TABLE "project_status" ADD CONSTRAINT "project_status_project_id_project_id_fk" FOREIGN KEY ("project_id") REFERENCES "public"."project"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
ALTER TABLE "project_status" ADD CONSTRAINT "project_status_created_by_user_id_fk" FOREIGN KEY ("created_by") REFERENCES "public"."user"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
CREATE INDEX "idx_change_entry_project" ON "change_entry" USING btree ("project_id");--> statement-breakpoint
CREATE INDEX "idx_phase_gate_project" ON "phase_gate" USING btree ("project_id");--> statement-breakpoint
CREATE INDEX "idx_project_status_project" ON "project_status" USING btree ("project_id");--> statement-breakpoint
ALTER TABLE "risk" ADD CONSTRAINT "risk_owner_user_id_user_id_fk" FOREIGN KEY ("owner_user_id") REFERENCES "public"."user"("id") ON DELETE set null ON UPDATE no action;
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+21
View File
@@ -57,6 +57,27 @@
"when": 1780415208906,
"tag": "0007_project_description",
"breakpoints": true
},
{
"idx": 8,
"version": "7",
"when": 1780577284868,
"tag": "0008_lead_crm",
"breakpoints": true
},
{
"idx": 9,
"version": "7",
"when": 1780669990802,
"tag": "0009_pm_insights",
"breakpoints": true
},
{
"idx": 10,
"version": "7",
"when": 1780672129310,
"tag": "0010_leitfaden_phases",
"breakpoints": true
}
]
}
+333
View File
@@ -125,11 +125,27 @@ export const project = pgTable(
.references(() => area.id, { onDelete: 'restrict' }),
name: text('name').notNull(),
description: text('description'),
// Maxime / roter Faden (ein Satz) — Leitsatz fürs ganze Team (Buch Kap. 4 Strategie).
maxime: text('maxime'),
// Definition (Leitfaden Phase 1) — Kurzfassung; Volltext-Steckbrief lebt in Outline.
ziel: text('ziel'), // SMART formuliert
nichtZiele: text('nicht_ziele'), // Scope-Schutz
liefergegenstaende: text('liefergegenstaende'),
// Zieldreieck (Leitfaden Kap. 1): welche Ecke gibt zuerst nach, wenn es eng wird.
zieldreieckFlex: text('zieldreieck_flex', { enum: ['leistung', 'zeit', 'aufwand'] }),
kind: text('kind', { enum: ['kundenprojekt', 'internes_projekt'] }).notNull(),
verantwortlicheUserId: uuid('verantwortliche_user_id').references(() => user.id, {
onDelete: 'set null',
}),
arbeitsmodus: text('arbeitsmodus', { enum: ['cycle', 'kanban'] }),
// Projekt-Modus / Intensität — muss laut Buch jederzeit ans Team kommuniziert sein.
modus: text('modus', { enum: ['relax', 'standard', 'eskalation', 'taskforce'] })
.notNull()
.default('standard'),
// Projektlebenszyklus (Leitfaden Kap. 2): aktuelle Phase.
phase: text('phase', { enum: ['definition', 'planung', 'umsetzung', 'abschluss'] })
.notNull()
.default('definition'),
outlineSteckbriefUrl: text('outline_steckbrief_url'),
steckbriefFreigegeben: boolean('steckbrief_freigegeben').notNull().default(false),
planeProjectUrl: text('plane_project_url'),
@@ -146,6 +162,8 @@ export const project = pgTable(
archiviert: boolean('archiviert').notNull().default(false),
archiviertAm: timestamp('archiviert_am', { withTimezone: true }),
lessonsLearnedUrl: text('lessons_learned_url'),
// Abschluss (Leitfaden Phase 4): kurzer Abschlussvermerk — Ziel erreicht? Aufwand vs. Plan?
abschlussvermerk: text('abschlussvermerk'),
createdBy: uuid('created_by').references(() => user.id, { onDelete: 'set null' }),
createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
@@ -174,6 +192,9 @@ export const milestone = pgTable(
.notNull()
.default('open'),
description: text('description'),
// Ergebnis-Übersicht („Patchnotes") + konkreter Kundennutzen je Meilenstein (Buch Kap. 4).
ergebnis: text('ergebnis'),
kundennutzen: text('kundennutzen'),
order: integer('order').notNull().default(0),
createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
},
@@ -429,6 +450,294 @@ export const blocker = pgTable(
}),
);
// ----------------------------------------------------------------------------
// lead — qualitatives Vertriebs-Dossier (CRM). Reicher als `deal`: Stammdaten,
// Pain, Geschäftliches, Soft Factors, Strategie. Ein Lead kann optional zu einem
// Pipeline-`deal` promoted werden (promoted_deal_id). Spiegelt die interne
// Lead-Schablone (9 Abschnitte).
// ----------------------------------------------------------------------------
export const lead = pgTable(
'lead',
{
id: uuid('id')
.default(sql`gen_random_uuid()`)
.primaryKey(),
areaId: uuid('area_id')
.notNull()
.references(() => area.id, { onDelete: 'restrict' }),
// 1. Stammdaten
firma: text('firma').notNull(),
status: text('status', { enum: ['cold', 'warm', 'hot', 'won', 'lost'] })
.notNull()
.default('cold'),
score: integer('score').notNull().default(0), // 0-10
ownerUserId: uuid('owner_user_id').references(() => user.id, { onDelete: 'set null' }),
branche: text('branche'),
subSegment: text('sub_segment'), // Nische
standorte: text('standorte'),
mitarbeiterzahl: text('mitarbeiterzahl'),
umsatz: text('umsatz'),
website: text('website'),
quelle: text('quelle'), // wie auf uns aufmerksam / wie gefunden
// 3. Pain & Bedarf
painPoint: text('pain_point'),
statusQuoKosten: text('status_quo_kosten'),
bestehendeLoesung: text('bestehende_loesung'),
wechselgrund: text('wechselgrund'),
persoenlicherErfolg: text('persoenlicher_erfolg'),
// 4. Geschäftliches
budgetIndikation: text('budget_indikation'),
entscheidungshorizont: text('entscheidungshorizont'),
compellingEvent: text('compelling_event'),
mitbewerber: text('mitbewerber'),
buyingCenter: text('buying_center'),
beschaffungsweg: text('beschaffungsweg'),
// 5. Soft Factors
kommunikationsstil: text('kommunikationsstil'),
vorlieben: text('vorlieben'),
hotButtons: text('hot_buttons'),
noGos: text('no_gos'),
druckpunkte: text('druckpunkte'),
anker: text('anker'),
vertrauenslevel: integer('vertrauenslevel'), // 1-5, nullable
// 6. Strategie
nutzenHypothese: text('nutzen_hypothese'),
differenzierer: text('differenzierer'),
naechsterSchritt: text('naechster_schritt'),
naechsterSchrittDatum: date('naechster_schritt_datum'),
risiken: text('risiken'),
planB: text('plan_b'),
// 8. Offene Fragen / 9. Anhänge (leichtgewichtige Listen als JSONB)
offeneFragen: jsonb('offene_fragen')
.$type<Array<{ text: string; done: boolean }>>()
.notNull()
.default([]),
anhaenge: jsonb('anhaenge')
.$type<Array<{ label: string; url: string }>>()
.notNull()
.default([]),
// Promotion → Pipeline-Deal
promotedDealId: uuid('promoted_deal_id').references(() => deal.id, { onDelete: 'set null' }),
createdBy: uuid('created_by').references(() => user.id, { onDelete: 'set null' }),
createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
},
(t) => ({
idxStatus: index('idx_lead_status').on(t.status),
idxOwner: index('idx_lead_owner').on(t.ownerUserId),
}),
);
// ----------------------------------------------------------------------------
// lead_contact — Kontaktperson(en) eines Leads (Schablone Abschnitt 2).
// ----------------------------------------------------------------------------
export const leadContact = pgTable(
'lead_contact',
{
id: uuid('id')
.default(sql`gen_random_uuid()`)
.primaryKey(),
leadId: uuid('lead_id')
.notNull()
.references(() => lead.id, { onDelete: 'cascade' }),
name: text('name').notNull(),
rolle: text('rolle'), // Rolle / Titel
funktion: text('funktion', {
enum: ['entscheider', 'influencer', 'gatekeeper', 'end_user', 'champion'],
}),
email: text('email'),
telefon: text('telefon'),
linkedin: text('linkedin'),
imBuyingCenterSeit: text('im_buying_center_seit'),
sprache: text('sprache'), // Sprache / bevorzugte Anrede
isPrimary: boolean('is_primary').notNull().default(false),
order: integer('order').notNull().default(0),
createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
},
(t) => ({
idxLead: index('idx_lead_contact_lead').on(t.leadId),
}),
);
// ----------------------------------------------------------------------------
// lead_touchpoint — Austausch-Log (Schablone Abschnitt 7). Jeder Kontakt eine Zeile.
// ----------------------------------------------------------------------------
export const leadTouchpoint = pgTable(
'lead_touchpoint',
{
id: uuid('id')
.default(sql`gen_random_uuid()`)
.primaryKey(),
leadId: uuid('lead_id')
.notNull()
.references(() => lead.id, { onDelete: 'cascade' }),
datum: date('datum').notNull(),
kanal: text('kanal', {
enum: ['call', 'mail', 'linkedin', 'termin', 'event', 'sonstiges'],
}).notNull(),
bearbeiterUserId: uuid('bearbeiter_user_id').references(() => user.id, { onDelete: 'set null' }),
inhalt: text('inhalt').notNull(),
outcome: text('outcome'),
followUpBis: date('follow_up_bis'),
createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
},
(t) => ({
idxLead: index('idx_lead_touchpoint_lead').on(t.leadId),
idxFollowUp: index('idx_lead_touchpoint_followup').on(t.followUpBis),
}),
);
// ----------------------------------------------------------------------------
// stakeholder — Stakeholder-Analyse pro Projekt (Buch Kap. 4). Interesse ×
// Einfluss ergibt die Macht/Interesse-Matrix; Haltung = Grundeinstellung.
// ----------------------------------------------------------------------------
export const stakeholder = pgTable(
'stakeholder',
{
id: uuid('id')
.default(sql`gen_random_uuid()`)
.primaryKey(),
projectId: uuid('project_id')
.notNull()
.references(() => project.id, { onDelete: 'cascade' }),
name: text('name').notNull(),
rolle: text('rolle'),
interesse: text('interesse', { enum: ['niedrig', 'mittel', 'hoch'] })
.notNull()
.default('mittel'),
einfluss: text('einfluss', { enum: ['niedrig', 'mittel', 'hoch'] })
.notNull()
.default('mittel'),
haltung: text('haltung', { enum: ['pro', 'neutral', 'contra'] })
.notNull()
.default('neutral'),
beduerfnis: text('beduerfnis'), // Was braucht die Person, in welcher Priorität?
notiz: text('notiz'),
order: integer('order').notNull().default(0),
createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
},
(t) => ({
idxProject: index('idx_stakeholder_project').on(t.projectId),
}),
);
// ----------------------------------------------------------------------------
// risk — Risiko- & Chancen-Register pro Projekt (Buch Kap. 4). `kind`
// unterscheidet Gefahr vs. Chance. Showstopper = bringt das Projekt zum Stillstand.
// ----------------------------------------------------------------------------
export const risk = pgTable(
'risk',
{
id: uuid('id')
.default(sql`gen_random_uuid()`)
.primaryKey(),
projectId: uuid('project_id')
.notNull()
.references(() => project.id, { onDelete: 'cascade' }),
kind: text('kind', { enum: ['risiko', 'chance'] })
.notNull()
.default('risiko'),
title: text('title').notNull(), // ausformulierter Satz
wahrscheinlichkeit: text('wahrscheinlichkeit', { enum: ['niedrig', 'mittel', 'hoch'] })
.notNull()
.default('mittel'),
auswirkung: text('auswirkung', { enum: ['niedrig', 'mittel', 'hoch'] })
.notNull()
.default('mittel'),
herkunft: text('herkunft', { enum: ['intern', 'extern'] }),
showstopper: boolean('showstopper').notNull().default(false),
massnahme: text('massnahme'), // Gegenmaßnahme bzw. Nutzungsidee bei Chancen
// Strategie (Leitfaden Kap. 4): vermeiden / verlagern / mindern / akzeptieren.
strategie: text('strategie', { enum: ['vermeiden', 'verlagern', 'mindern', 'akzeptieren'] }),
ownerUserId: uuid('owner_user_id').references(() => user.id, { onDelete: 'set null' }),
status: text('status', { enum: ['offen', 'beobachtet', 'eingetreten', 'geschlossen'] })
.notNull()
.default('offen'),
createdBy: uuid('created_by').references(() => user.id, { onDelete: 'set null' }),
createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
},
(t) => ({
idxProject: index('idx_risk_project').on(t.projectId),
idxShowstopper: index('idx_risk_showstopper').on(t.showstopper),
}),
);
// ----------------------------------------------------------------------------
// project_status — Statusbericht pro Projekt (Leitfaden Kap. 5 „Status sichtbar
// machen"): Ampel + Trend + 2-3 Sätze. Jüngster Eintrag speist statusCache.
// ----------------------------------------------------------------------------
export const projectStatus = pgTable(
'project_status',
{
id: uuid('id')
.default(sql`gen_random_uuid()`)
.primaryKey(),
projectId: uuid('project_id')
.notNull()
.references(() => project.id, { onDelete: 'cascade' }),
ampel: text('ampel', { enum: ['green', 'amber', 'red'] }).notNull(),
trend: text('trend', { enum: ['besser', 'gleich', 'schlechter'] }),
text: text('text'), // 2-3 Sätze Erläuterung
externSichtbar: boolean('extern_sichtbar').notNull().default(false),
createdBy: uuid('created_by').references(() => user.id, { onDelete: 'set null' }),
createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
},
(t) => ({
idxProject: index('idx_project_status_project').on(t.projectId),
}),
);
// ----------------------------------------------------------------------------
// phase_gate — Gate-Review am Phasenende (Leitfaden Kap. 5 „Reviews an
// Meilensteinen"): Ergebnis erreicht? Folgephase freigegeben?
// ----------------------------------------------------------------------------
export const phaseGate = pgTable(
'phase_gate',
{
id: uuid('id')
.default(sql`gen_random_uuid()`)
.primaryKey(),
projectId: uuid('project_id')
.notNull()
.references(() => project.id, { onDelete: 'cascade' }),
phase: text('phase', { enum: ['definition', 'planung', 'umsetzung', 'abschluss'] }).notNull(),
ergebnisErreicht: boolean('ergebnis_erreicht').notNull(),
notiz: text('notiz'),
reviewedBy: uuid('reviewed_by').references(() => user.id, { onDelete: 'set null' }),
reviewedAt: timestamp('reviewed_at', { withTimezone: true }).notNull().defaultNow(),
},
(t) => ({
idxProject: index('idx_phase_gate_project').on(t.projectId),
}),
);
// ----------------------------------------------------------------------------
// change_entry — Änderungs-Log (Leitfaden Kap. 5 „Mit Änderungen umgehen"):
// bewusste Entscheidung über Änderungen, die das Zieldreieck bewegen.
// ----------------------------------------------------------------------------
export const changeEntry = pgTable(
'change_entry',
{
id: uuid('id')
.default(sql`gen_random_uuid()`)
.primaryKey(),
projectId: uuid('project_id')
.notNull()
.references(() => project.id, { onDelete: 'cascade' }),
titel: text('titel').notNull(),
auswirkung: text('auswirkung'), // Auswirkung aufs Zieldreieck
entscheidung: text('entscheidung', { enum: ['offen', 'genehmigt', 'abgelehnt'] })
.notNull()
.default('offen'),
createdBy: uuid('created_by').references(() => user.id, { onDelete: 'set null' }),
createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
},
(t) => ({
idxProject: index('idx_change_entry_project').on(t.projectId),
}),
);
// ----------------------------------------------------------------------------
// Type-Helper für Code, der mit den Entitäten arbeitet.
// ----------------------------------------------------------------------------
@@ -476,3 +785,27 @@ export type NewCampaign = typeof campaign.$inferInsert;
export type LeadHandover = typeof leadHandover.$inferSelect;
export type NewLeadHandover = typeof leadHandover.$inferInsert;
export type Lead = typeof lead.$inferSelect;
export type NewLead = typeof lead.$inferInsert;
export type LeadContact = typeof leadContact.$inferSelect;
export type NewLeadContact = typeof leadContact.$inferInsert;
export type LeadTouchpoint = typeof leadTouchpoint.$inferSelect;
export type NewLeadTouchpoint = typeof leadTouchpoint.$inferInsert;
export type Stakeholder = typeof stakeholder.$inferSelect;
export type NewStakeholder = typeof stakeholder.$inferInsert;
export type Risk = typeof risk.$inferSelect;
export type NewRisk = typeof risk.$inferInsert;
export type ProjectStatus = typeof projectStatus.$inferSelect;
export type NewProjectStatus = typeof projectStatus.$inferInsert;
export type PhaseGate = typeof phaseGate.$inferSelect;
export type NewPhaseGate = typeof phaseGate.$inferInsert;
export type ChangeEntry = typeof changeEntry.$inferSelect;
export type NewChangeEntry = typeof changeEntry.$inferInsert;
+218 -1
View File
@@ -1,7 +1,7 @@
// Seed-Skript: idempotent. Legt Areas, Test-Mitarbeiter (inkl. Admin Dejan) und
// Dummy-Daten (Projekte, Deals, Kampagnen, Tageseinträge, Blocker) an.
import { sql } from 'drizzle-orm';
import { sql, eq } from 'drizzle-orm';
import { createDbClient } from './client.js';
import {
area,
@@ -15,6 +15,13 @@ import {
dayEntry,
todo,
blocker,
lead,
leadContact,
leadTouchpoint,
risk,
stakeholder,
projectStatus,
changeEntry,
} from './schema.js';
const AREAS = [
@@ -366,6 +373,216 @@ export async function seed(connectionString: string): Promise<void> {
]);
}
// ----- Leads (CRM-Dossiers) -----
const existingLeads = await db.select().from(lead);
if (existingLeads.length === 0) {
const sales = areaBySlug.vertrieb!;
const [l1] = await db
.insert(lead)
.values({
areaId: sales.id,
firma: 'Alpenhof Hotels GmbH',
status: 'hot',
score: 8,
ownerUserId: anna.id,
branche: 'Hotellerie',
subSegment: 'Internationale/deutsche Hotelketten',
standorte: 'München, Wien, Zürich',
mitarbeiterzahl: '350+',
umsatz: '~ 80 Mio € (2025)',
website: 'https://alpenhof-hotels.example',
quelle: 'LinkedIn-Profil im MitApp-Verzeichnis',
painPoint:
'Projektmanagement-Workflows laufen über zig Excel-Listen, nichts ist zentral. Onboarding neuer Häuser dauert ewig.',
statusQuoKosten: 'Mehrere Personentage pro Woche an manueller Koordination.',
bestehendeLoesung: 'Excel + E-Mail, vereinzelt Trello',
wechselgrund: 'Skaliert nicht mit dem Wachstum, zu fehleranfällig.',
persoenlicherErfolg: 'Will als Onboarding-Manager sichtbar Zeit einsparen und entlasten.',
budgetIndikation: 'noch offen, vermutlich 5-stellig p.a.',
entscheidungshorizont: 'Q3',
compellingEvent: 'Zwei neue Häuser kommen im Herbst dazu.',
mitbewerber: 'keine konkret bekannt',
buyingCenter: 'Onboarding-Manager (Champion), COO (Entscheider)',
beschaffungsweg: 'direkt',
kommunikationsstil: 'freundlich, pragmatisch, mag konkrete Beispiele',
hotButtons: 'Zeitersparnis, weniger manuelle Pflege, KI-Unterstützung',
nutzenHypothese:
'KI-gestützte PM-Workflows sparen dem Onboarding-Team messbar Zeit bei jedem neuen Haus.',
differenzierer: 'Eigene Erfahrung in genau dieser Nische + KI-/Prozessautomatisierung.',
naechsterSchritt: 'Discovery-Call vereinbaren',
naechsterSchrittDatum: isoDateOffset(4),
vertrauenslevel: 3,
offeneFragen: [
{ text: 'Wer hält das Budget?', done: false },
{ text: 'Welche Tools sind heute schon im Einsatz?', done: true },
],
anhaenge: [],
createdBy: anna.id,
})
.returning();
if (l1) {
await db.insert(leadContact).values({
leadId: l1.id,
name: 'Sascha Haiss',
rolle: 'Onboarding Manager',
funktion: 'champion',
linkedin: 'https://www.linkedin.com/in/example',
sprache: 'Deutsch, per Du',
isPrimary: true,
order: 0,
});
await db.insert(leadTouchpoint).values([
{
leadId: l1.id,
datum: pickWerktag(2),
kanal: 'linkedin',
bearbeiterUserId: anna.id,
inhalt: 'Erste Nachricht über das MitApp-Profil geschickt, Bezug auf KI-Optimierung für PM.',
outcome: 'positiv geantwortet, Interesse an kurzem Austausch',
followUpBis: isoDateOffset(4),
},
]);
}
}
// ----- Risiken / Chancen / Stakeholder / Modus (PM-Insights) -----
const existingRisks = await db.select().from(risk);
if (existingRisks.length === 0) {
const someProject = (await db.select().from(project).orderBy(project.createdAt).limit(1))[0];
if (someProject) {
await db
.update(project)
.set({
modus: 'eskalation',
maxime: someProject.maxime ?? 'Pilot ohne Scope-Creep bis zum Stichtag liefern.',
})
.where(eq(project.id, someProject.id));
await db.insert(risk).values([
{
projectId: someProject.id,
kind: 'risiko',
title: 'Kunde liefert die Stripe-Account-Daten nicht rechtzeitig.',
wahrscheinlichkeit: 'hoch',
auswirkung: 'hoch',
herkunft: 'extern',
showstopper: true,
massnahme: 'Eskalation an Kundenkontakt, Deadline schriftlich fixieren.',
status: 'offen',
createdBy: dejan.id,
},
{
projectId: someProject.id,
kind: 'risiko',
title: 'Interne Ressourcen werden für ein anderes Projekt abgezogen.',
wahrscheinlichkeit: 'mittel',
auswirkung: 'hoch',
herkunft: 'intern',
massnahme: 'Kapazität mit der Geschäftsführung absichern.',
status: 'beobachtet',
createdBy: dejan.id,
},
{
projectId: someProject.id,
kind: 'chance',
title: 'Kunde will bei Erfolg weitere Standorte anbinden.',
wahrscheinlichkeit: 'mittel',
auswirkung: 'hoch',
massnahme: 'Pilot als Referenz sauber dokumentieren.',
status: 'offen',
createdBy: dejan.id,
},
]);
await db.insert(stakeholder).values([
{
projectId: someProject.id,
name: 'GF Schmidt',
rolle: 'Auftraggeber',
interesse: 'hoch',
einfluss: 'hoch',
haltung: 'pro',
beduerfnis: 'Pünktlicher Go-Live, klare Status-Reports',
order: 0,
},
{
projectId: someProject.id,
name: 'IT-Abteilung Kunde',
rolle: 'Technik',
interesse: 'mittel',
einfluss: 'hoch',
haltung: 'neutral',
beduerfnis: 'Saubere Schnittstellen, wenig Mehraufwand',
order: 1,
},
{
projectId: someProject.id,
name: 'Sachbearbeitung',
rolle: 'End-User',
interesse: 'hoch',
einfluss: 'niedrig',
haltung: 'pro',
beduerfnis: 'Einfaches, schnelles Auftragsformular',
order: 2,
},
]);
}
}
// ----- Statusbericht / Phase / Definition / Änderung (Leitfaden) -----
const existingStatus = await db.select().from(projectStatus);
if (existingStatus.length === 0) {
const someProject = (await db.select().from(project).orderBy(project.createdAt).limit(1))[0];
if (someProject) {
await db
.update(project)
.set({
phase: 'umsetzung',
ziel:
someProject.ziel ??
'Auftragsportal live bis 30.09., mind. 3 Auftragstypen, vom Kunden abgenommen.',
nichtZiele:
someProject.nichtZiele ??
'Keine Migration der Altbestellungen. Keine mobile App in dieser Phase.',
liefergegenstaende:
someProject.liefergegenstaende ??
'Portal-Frontend, Stripe-Anbindung, Admin-Übersicht, Schulungsunterlagen.',
zieldreieckFlex: someProject.zieldreieckFlex ?? 'aufwand',
statusCache: 'amber',
trendCache: 'gleich',
})
.where(eq(project.id, someProject.id));
await db.insert(projectStatus).values([
{
projectId: someProject.id,
ampel: 'green',
trend: 'besser',
text: 'Setup steht, erste Auftragstypen umgesetzt. Im Plan.',
externSichtbar: true,
createdBy: dejan.id,
},
{
projectId: someProject.id,
ampel: 'amber',
trend: 'gleich',
text: 'Stripe-Zugang vom Kunden noch offen — gefährdet den Pilottermin. Maßnahme läuft.',
externSichtbar: true,
createdBy: dejan.id,
},
]);
await db.insert(changeEntry).values({
projectId: someProject.id,
titel: 'Kunde wünscht zusätzlichen Auftragstyp „Express".',
auswirkung: 'Mehr Umfang → Aufwand steigt, Termin gefährdet.',
entscheidung: 'offen',
createdBy: dejan.id,
});
}
}
await db.update(user).set({ updatedAt: new Date() }).where(sql`true`);
} finally {
await pool.end();