feat: Projekt Scanner integrieren, Whisper in die Einstellungen

Der eigenstaendige Projekt Scanner zieht komplett ins CRM ein und laeuft
parallel zur bestehenden App weiter - jede geteilte Ressource ist verdoppelt
statt geteilt, damit die alte Installation unberuehrt bleibt:

- eigene Datenbank perinco_scanner, legt sich beim Start selbst an
- eigener SCANNER_ENCRYPTION_KEY, eigenes Upload-Verzeichnis
- eigener Scheduler mit Zeitversatz, damit nicht beide Instanzen gleichzeitig
  mit denselben Portal-Cookies scrapen (Rate-Limits, CAPTCHA, doppelter RAM)
- Sperre gegen ueberlappende Laeufe: Scheduler und "Jetzt scannen" teilen sie,
  ein zweiter Aufruf bekommt 409 statt doppelter OpenAI-Kosten

Backend unter /api/scanner hinter der CRM-Anmeldung; die HTTP-Basic-Auth des
Originals entfaellt. CV-PDFs kommen als Stream mit Token statt aus einem
statischen Verzeichnis. Bestandsdaten holt "npm run scanner:import" aus der
alten Datenbank, ohne sie zu veraendern.

Oberflaeche in Tailwind und CI-Farben neu gebaut: Menuepunkt Scanner mit
aufklappbaren Unterpunkten, Einstellungen als eigener Reiter.

Whisper hat keinen eigenen Menuepunkt mehr, sondern ist ein Reiter in den
Einstellungen. Damit diese Geraeteeinstellung jeder Rolle offensteht, sind die
Einstellungen jetzt fuer alle sichtbar - welche Reiter erscheinen, entscheidet
die Rolle.

Ausserdem: kein festes Admin-Passwort mehr im Quelltext, playwright exakt auf
1.60.0 gepinnt (nutzt den vorhandenen Chromium-Build des Servers), technische
Dokumentation mit Funktionszeichnungen unter docs/.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Sascha Wolf
2026-08-06 15:08:59 +02:00
co-authored by Claude Opus 5
commit 82d1b7eab4
106 changed files with 24133 additions and 0 deletions
+197
View File
@@ -0,0 +1,197 @@
import type {
AppUser,
CalendarEvent,
Lead,
LeadConnection,
Opportunity,
Role,
} from '../types';
const TOKEN_KEY = 'perinco_crm_token';
export function getToken(): string | null {
return localStorage.getItem(TOKEN_KEY);
}
export function setToken(token: string) {
localStorage.setItem(TOKEN_KEY, token);
}
export function clearToken() {
localStorage.removeItem(TOKEN_KEY);
}
export class ApiError extends Error {
status: number;
constructor(message: string, status: number) {
super(message);
this.status = status;
}
}
/** Wird bei 401 gefeuert, damit die App zurueck auf den Login springt. */
type UnauthorizedHandler = () => void;
let onUnauthorized: UnauthorizedHandler | null = null;
export function setUnauthorizedHandler(handler: UnauthorizedHandler | null) {
onUnauthorized = handler;
}
export async function apiRequest<T>(path: string, options: RequestInit = {}): Promise<T> {
const headers = new Headers(options.headers);
// JSON ist der Normalfall, aber nicht der einzige: der CV-Upload des Scanners
// schickt FormData, dort muss der Browser die multipart-Grenze selbst setzen.
if (options.body && !headers.has('Content-Type') && !(options.body instanceof FormData)) {
headers.set('Content-Type', 'application/json');
}
const token = getToken();
if (token) headers.set('Authorization', `Bearer ${token}`);
let response: Response;
try {
response = await fetch(`/api${path}`, { ...options, headers });
} catch {
throw new ApiError('Server nicht erreichbar. Bitte Verbindung pruefen.', 0);
}
if (response.status === 401) {
clearToken();
onUnauthorized?.();
}
const isJson = response.headers.get('content-type')?.includes('application/json');
const payload = isJson ? await response.json().catch(() => null) : null;
if (!response.ok) {
const message =
(payload && typeof payload === 'object' && 'error' in payload && String(payload.error)) ||
`Anfrage fehlgeschlagen (HTTP ${response.status}).`;
throw new ApiError(message, response.status);
}
return payload as T;
}
/** Kurzform fuer die Aufrufe in dieser Datei. */
const request = apiRequest;
// ---------- Auth ----------
export const authApi = {
login: (identifier: string, password: string) =>
request<{ token: string; user: AppUser }>('/auth/login', {
method: 'POST',
body: JSON.stringify({ identifier, password }),
}),
me: () => request<{ user: AppUser }>('/auth/me'),
/**
* Eigene Kalenderfarbe und eigenes Foto setzen - ohne Adminrechte.
* null setzt zurueck: Farbe auf die Palettenfarbe, Foto auf die Initiale.
*/
updateMe: (input: { color?: string | null; avatar?: string | null }) =>
request<{ user: AppUser }>('/auth/me', { method: 'PATCH', body: JSON.stringify(input) }),
changePassword: (current_password: string, new_password: string) =>
request<{ ok: true }>('/auth/change-password', {
method: 'POST',
body: JSON.stringify({ current_password, new_password }),
}),
};
// ---------- Benutzerverwaltung (nur admin) ----------
export interface UserInput {
username: string;
name: string;
email?: string | null;
password?: string;
role?: Role;
color?: string | null;
avatar?: string | null;
is_active?: boolean;
}
export const usersApi = {
list: () => request<AppUser[]>('/users'),
/**
* Aktive Benutzer - fuer jeden Angemeldeten abrufbar. Der Kalender braucht
* die Liste fuer @-Mentions, Teilnehmer und Farben, auch fuer Rolle "user".
*/
directory: () => request<AppUser[]>('/users/directory'),
create: (input: UserInput) =>
request<AppUser>('/users', { method: 'POST', body: JSON.stringify(input) }),
update: (id: number, input: Partial<UserInput>) =>
request<AppUser>(`/users/${id}`, { method: 'PATCH', body: JSON.stringify(input) }),
remove: (id: number) => request<{ ok: true }>(`/users/${id}`, { method: 'DELETE' }),
};
// ---------- Leads ----------
export type LeadInput = Partial<Omit<Lead, 'id' | 'created_at' | 'updated_at'>>;
export const leadsApi = {
list: () => request<Lead[]>('/leads'),
create: (input: LeadInput) =>
request<Lead>('/leads', { method: 'POST', body: JSON.stringify(input) }),
update: (id: number, input: LeadInput) =>
request<Lead>(`/leads/${id}`, { method: 'PATCH', body: JSON.stringify(input) }),
remove: (id: number) => request<{ ok: true }>(`/leads/${id}`, { method: 'DELETE' }),
};
// ---------- Opportunities ----------
export type OpportunityInput = Partial<
Omit<Opportunity, 'id' | 'created_at' | 'updated_at' | 'contacts'>
> & {
/** Ansprechpartner werden immer komplett ersetzt. */
contacts?: { lead_id: number; role?: string | null }[];
};
export const opportunitiesApi = {
list: () => request<Opportunity[]>('/opportunities'),
create: (input: OpportunityInput) =>
request<Opportunity>('/opportunities', { method: 'POST', body: JSON.stringify(input) }),
update: (id: number, input: OpportunityInput) =>
request<Opportunity>(`/opportunities/${id}`, { method: 'PATCH', body: JSON.stringify(input) }),
remove: (id: number) => request<{ ok: true }>(`/opportunities/${id}`, { method: 'DELETE' }),
};
// ---------- Kalender ----------
export interface EventInput {
title: string;
description?: string | null;
location?: string | null;
/** `YYYY-MM-DDTHH:MM` oder `YYYY-MM-DD HH:MM:SS` */
starts_at: string;
ends_at: string;
all_day?: boolean;
participant_ids?: number[];
}
export const eventsApi = {
list: () => request<CalendarEvent[]>('/events'),
create: (input: EventInput) =>
request<CalendarEvent>('/events', { method: 'POST', body: JSON.stringify(input) }),
update: (id: number, input: Partial<EventInput>) =>
request<CalendarEvent>(`/events/${id}`, { method: 'PATCH', body: JSON.stringify(input) }),
remove: (id: number) => request<{ ok: true }>(`/events/${id}`, { method: 'DELETE' }),
};
// ---------- Verbindungen ----------
export interface ConnectionInput {
from_lead_id: number;
to_lead_id: number;
type?: LeadConnection['type'];
label?: string | null;
strength?: number;
}
export const connectionsApi = {
list: () => request<LeadConnection[]>('/connections'),
create: (input: ConnectionInput) =>
request<LeadConnection>('/connections', { method: 'POST', body: JSON.stringify(input) }),
update: (id: number, input: Partial<Omit<ConnectionInput, 'from_lead_id' | 'to_lead_id'>>) =>
request<LeadConnection>(`/connections/${id}`, { method: 'PATCH', body: JSON.stringify(input) }),
remove: (id: number) => request<{ ok: true }>(`/connections/${id}`, { method: 'DELETE' }),
};