diff --git a/.dev/session-log.md b/.dev/session-log.md index 0e32952..68b5fad 100644 --- a/.dev/session-log.md +++ b/.dev/session-log.md @@ -10,3 +10,42 @@ Rejected: - Use a grouped enharmonic dropdown that forces users through reset-like interaction. Open: - User will review the visual result. +## 2026-05-15 10:21 [saved] +Goal: Deutschsprachigen Contributor Guide für dieses Angular-Repository erstellen. +Decisions: +- `AGENTS.md` bleibt auf Deutsch, weil der Nutzer ausdrücklich deutsche Ausgabe verlangt hat. +- Guide nutzt Standard-Contributor-Struktur, weil der Nutzer konkrete Abschnitte vorgegeben hat. +- Firebase-Konfigurationshinweis bleibt enthalten, weil Builds eine ignorierte `firebase.ts` benötigen. +Rejected: +- Kein rein agenteninternes Minimal-AGENTS.md. +Open: Keine. + +## 2026-05-15 10:55 [saved] +Goal: Deutsche Dokumentation sprachlich an Nutzererwartung anpassen. +Decisions: +- Korrekte Umlaute und `ß` sind Pflicht, weil deutsche Doku keine ASCII-Umschreibungen verwenden soll. +- Nutzeranleitungen verwenden sichtbare UI-Begriffe, weil technische Enums für Anwender ungeeignet sind. +- ASCII-Dateinamen bleiben für Links stabil, weil nur sichtbarer Dokumenttext korrigiert werden musste. +Rejected: +- Technische Rollenwerte wie `leader` in Nutzeranleitungen. +Open: Keine. + +## 2026-05-15 10:48 [saved] +Goal: Anwenderhandbuch unter `man/` mit Seiten und Tutorials erstellen. +Decisions: +- `man/` ist rein anwenderorientiert, weil der Nutzer keine technische Beschreibung wollte. +- Seiten- und Tutorialdateien sind getrennt, weil Nachschlagen und Lernen unterschiedliche Nutzungssituationen sind. +- Wiki-Links verbinden Handbuchseiten, Tutorials und Berechtigungen, weil Anwender navigierend lernen sollen. +Rejected: +- Technische Implementierungsdetails im Anwenderhandbuch. +Open: Keine. + +## 2026-05-15 10:35 [saved] +Goal: Ausführliche Projektdokumentation unter `docs/` erstellen. +Decisions: +- Dokumentation nach Seite und Querschnitt getrennt, weil Routen und Technik unabhängig gepflegt werden. +- `docs/index.md` ist zentrale Navigation, weil viele Einzeldokumente angelegt wurden. +- Parallele Agents wurden nach Fachbereichen eingesetzt, weil der Nutzer parallele Dokumentarbeit verlangte. +Rejected: +- Eine einzige große Projektdokumentation. +Open: Keine. diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..a9238aa --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,36 @@ +# Repository Guidelines + +## Projektstruktur & Modulorganisation + +Dies ist eine Angular-Anwendung. Der Hauptcode liegt in `src/app`, Feature-Bereiche liegen unter `src/app/modules` (`songs`, `shows`, `guest`, `presentation`, `user`, `brand`). Gemeinsame Services befinden sich in `src/app/services`; wiederverwendbare UI-Komponenten, Pipes, Direktiven und Guards liegen in `src/app/widget-modules`. Statische Assets und PWA-Icons liegen in `src/assets` sowie in den `src/*icon*`-Dateien. Globale Styles stehen in `src/styles` und `src/custom-theme.scss`. Unit-Tests liegen neben den Implementierungen als `*.spec.ts`. + +## Build-, Test- und Entwicklungsbefehle + +- `npm start` oder `ng serve`: startet den lokalen Angular-Dev-Server. +- `npm run build:dev`: erstellt einen Development-Build. +- `npm run build`: erstellt einen Production-Build in `dist/wgenerator`. +- `npm test`: führt Angular-Unit-Tests mit dem Vitest-Runner aus. +- `npm run lint`: führt Angular ESLint aus und wendet automatische Fixes an. +- `npm run deploy`: baut die Production-Version und deployt über Firebase. + +Nutze `npm ci -f` für eine saubere Dependency-Installation wie im Gitea-CI-Workflow. + +## Coding Style & Namenskonventionen + +Verwende TypeScript, vorhandene Angular-Standalone-Konventionen und LESS für generierte Component-Styles. Die Formatierung wird über `.editorconfig` und `.prettierrc` gesteuert: 2 Leerzeichen Einrückung, keine Tabs, Semikolons, Single Quotes, keine Leerzeichen in geschweiften Klammern und Trailing Commas, soweit in ES5 gültig. Angular-Selektoren müssen den Prefix `app` nutzen: Components als kebab-case-Elemente, Direktiven als camelCase-Attribute. + +## Testrichtlinien + +Tests nutzen Vitest über Angulars `@angular/build:unit-test`-Builder. Lege Specs direkt neben die getestete Datei und nutze das Suffix `*.spec.ts`. Gemeinsame Angular-Testdefaults und Jasmine-Kompatibilitätshelfer sind in `src/test-vitest.ts` konfiguriert; nutze diese Helfer statt Provider in einzelnen Specs zu duplizieren. Führe vor Behaviour-Änderungen `npm test` aus. + +## Commit- & Pull-Request-Richtlinien + +Die jüngsten Commits nutzen kurze, imperative Nachrichten in Kleinschreibung, zum Beispiel `fix css issues` oder `optimize song filter`. Halte Commits auf eine Änderung fokussiert. Pull Requests sollten eine kurze Zusammenfassung, Test- oder Build-Ergebnisse, verlinkte Issues oder Tasks bei Bedarf und Screenshots für sichtbare UI-Änderungen enthalten. + +## Sicherheit & Konfiguration + +`src/environments/firebase.ts` wird von Git ignoriert, aber von `environment.ts` und Production-Builds benötigt. CI erzeugt die Datei aus Secrets; lokale Entwickler brauchen eine eigene Kopie mit Firebase-Projektwerten. Committe keine Secrets und keinen generierten Build-Output. + +## Deutsche Dokumentation + +Deutschsprachige Markdown-Dokumentation muss korrekte Umlaute und `ß` verwenden, nicht ASCII-Umschreibungen wie `ae`, `oe`, `ue` oder `ss`. Nutzeranleitungen müssen die sichtbaren Begriffe aus der Oberfläche verwenden, nicht technische Enum-Werte. Beispiel: `Benutzer`, `Lobpreisleiter`, `Präsentator` und `nur den Liedtext anzeigen` statt `user`, `leader`, `presenter` oder `hide`. diff --git a/docs/data-model.md b/docs/data-model.md new file mode 100644 index 0000000..aa99cae --- /dev/null +++ b/docs/data-model.md @@ -0,0 +1,135 @@ +# Datenmodell + +## Überblick + +Die Anwendung speichert fachliche Daten in Firestore und Song-Anhänge in Firebase Storage. Firestore-Dokumente werden über AngularFire als Live-Observables gelesen; Dokument-IDs werden in den Services als `id` in die Objekte übernommen. + +Zentrale Collections: + +- `users` +- `songs` +- `shows` +- `guest` +- `global` + +Subcollections: + +- `songs/{songId}/files` +- `shows/{showId}/songs` + +## `users/{uid}` + +Benutzerprofile ergänzen Firebase Auth um Anwendungsdaten: + +- `id`: Firestore-Dokument-ID, entspricht der Firebase-Auth-UID. +- `name`: Anzeigename. +- `role`: Semikolon-getrennte Rollenliste. +- `chordMode`: bevorzugte Akkorddarstellung. +- `songUsage`: Map von `songId` auf Nutzungszähler. + +`songUsage` wird beim Hinzufügen oder Entfernen von Show-Songs inkrementell aktualisiert. Die Admin-Migration `rebuildSongUsage` kann die Werte aus Shows neu berechnen. + +## `songs/{songId}` + +Ein Song enthält Stammdaten, musikalische Angaben, rechtliche Angaben und Bearbeitungshistorie: + +- `number`, `title`, `type`, `status` +- `key`, `tempo`, `text`, `flags`, `final`, `comment` +- `legalType`, `legalOwner`, `legalOwnerId` +- `artist`, `label`, `termsOfUse`, `origin` +- `edits`: Liste aus Bearbeitername und Timestamp + +Typen: + +- `type`: `Praise`, `Worship` oder `Misc`. +- `status`: `draft`, `set` oder `final`. +- `legalOwner`: `CCLI` oder `other`. +- `legalType`: `open` oder `allowed`. + +Beim Aktualisieren eines Songs ergänzt `SongService` einen Eintrag in `edits`. + +## `songs/{songId}/files/{fileId}` + +Die Subcollection enthält Metadaten zu Dateien in Firebase Storage: + +- `name`: Dateiname. +- `path`: Storage-Verzeichnis des Songs. +- `createdAt`: Erstellzeitpunkt. + +`UploadService` lädt Dateien nach Firebase Storage hoch und schreibt anschließend das Metadaten-Dokument. `FileService` erzeugt Download-URLs und entfernt Dateien aus Storage und Firestore. + +## `shows/{showId}` + +Shows beschreiben Veranstaltungen und den Präsentationszustand: + +- `showType`: Veranstaltungstyp. +- `date`: Firestore-Timestamp. +- `owner`: Benutzer-ID des Besitzers. +- `songIds`: denormalisierter Index der enthaltenen Ursprungssongs. +- `public`: Kennzeichen für öffentliche Show-Typen. +- `reportedType`: `null`, `pending`, `reported` oder `not-required`. +- `published`: Veröffentlichung in Listen. +- `archived`: Archivstatus. +- `order`: Reihenfolge der Show-Song-Dokument-IDs. +- `shareId`: Verweis auf ein Gastfreigabe-Dokument. + +Präsentationsfelder: + +- `presentationSongId` +- `presentationDynamicCaption` +- `presentationDynamicText` +- `presentationSection` +- `presentationZoom` +- `presentationBackground` + +`presentationBackground` erlaubt `none`, `blue`, `green`, `leder`, `praise` und `bible`. + +`ShowService` unterscheidet öffentliche und private Show-Typen. Beim Anlegen werden `owner`, leere `order`, leere `songIds` und `public` aus dem Show-Typ berechnet. + +## `shows/{showId}/songs/{showSongId}` + +Show-Songs sind Snapshots von Songs innerhalb einer Show. Sie erweitern das Song-Modell um showbezogene Felder: + +- `songId`: ID des Ursprungssongs. +- `key`: aktuelle Tonart in der Show. +- `keyOriginal`: ursprüngliche Tonart. +- `chordMode`: Akkorddarstellung des Benutzers zum Zeitpunkt des Hinzufügens. +- `addedLive`: Kennzeichen für live hinzugefügte Songs. + +Beim Hinzufügen kopiert `ShowSongService` die aktuellen Songdaten in die Subcollection, aktualisiert `users/{uid}.songUsage` und fügt die Ursprungssong-ID zu `shows/{showId}.songIds` hinzu. Beim Entfernen wird die Reihenfolge angepasst, der Nutzungszähler reduziert und `songIds` entfernt, wenn kein weiterer Show-Song denselben Ursprungssong nutzt. + +## `guest/{guestId}` + +Gastfreigaben sind öffentlich lesbare Snapshots einer Show: + +- `showType` +- `date` +- `updatedAt` +- `songs`: Liste der freigegebenen Songs + +`GuestShowService` erstellt oder aktualisiert das Gastdokument und schreibt die erzeugte `shareId` zurück an die Show. Die öffentliche URL hat das Format `/guest/{shareId}`. + +## `global/config` + +Globale Konfiguration: + +- `ccliLicenseId`: CCLI-Lizenznummer. + +`ConfigService` liest das Dokument gecacht. + +## `global/static` + +Laufzeitstatus der Anwendung: + +- `currentShow`: ID der aktuell ausgewählten Show für die Präsentation. + +`GlobalSettingsService` liest und schreibt dieses Dokument. Die Präsentationsauswahl setzt `currentShow`; Remote- und Monitoransicht verwenden den Wert zur Synchronisierung. + +## Denormalisierung und Migrationen + +Zwei Felder sind bewusst denormalisiert: + +- `users/{uid}.songUsage` für Nutzungszähler pro Benutzer. +- `shows/{showId}.songIds` für schnelle Abfragen und Anzeigeinformationen zu verwendeten Songs. + +Für beide Datenbestände existieren Admin-Migrationen im README. Sie sollten nach strukturellen Korrekturen oder historischen Datenproblemen manuell ausgeführt werden. diff --git a/docs/development.md b/docs/development.md new file mode 100644 index 0000000..c5d7c74 --- /dev/null +++ b/docs/development.md @@ -0,0 +1,131 @@ +# Entwicklungsworkflow + +## Voraussetzungen + +Das Projekt ist eine Angular-Anwendung mit Node.js-Abhängigkeiten aus `package.json`. Der CI-Workflow verwendet `node:20-bullseye`; lokale Entwicklung sollte daher eine kompatible Node-Version verwenden. + +Installiere Abhängigkeiten mit: + +```bash +npm ci -f +``` + +Die Option `-f` entspricht dem Gitea-CI-Workflow. + +## Lokale Konfiguration + +Für lokale Builds muss `src/environments/firebase.ts` existieren. Die Datei wird nicht versioniert und enthält die Firebase-Projektwerte. + +Minimalstruktur: + +```ts +export const firebase = { + apiKey: '...', + authDomain: '...', + databaseURL: 'https://worshipgenerator.firebaseio.com', + projectId: '...', + storageBucket: '...', + messagingSenderId: '...', + appId: '...', +}; +``` + +Ohne diese Datei schlagen Angular-Builds fehl, weil `environment.ts` und `environment.prod.ts` sie importieren. + +## Entwicklungsserver + +Starte die Anwendung lokal mit: + +```bash +npm start +``` + +Der Befehl führt `ng serve` aus. In `angular.json` ist `development` die Standardkonfiguration für `serve`. + +## Build-Varianten + +Development-Build: + +```bash +npm run build:dev +``` + +Production-Build: + +```bash +npm run build +``` + +Der Production-Build nutzt `environment.prod.ts`, aktiviert Output-Hashing und schreibt nach `dist/wgenerator`. Firebase Hosting erwartet den Browser-Build unter `dist/wgenerator/browser`. + +## Tests und Linting + +Unit-Tests: + +```bash +npm test +``` + +Linting mit automatischen Fixes: + +```bash +npm run lint +``` + +Tests liegen als `*.spec.ts` neben den Implementierungen. Der Angular Unit-Test-Builder nutzt Vitest und lädt gemeinsame Testkonfiguration aus `src/test-vitest.ts`. + +## Codeorganisation + +Neue fachliche Funktionen sollten in das passende Feature-Modul unter `src/app/modules` einsortiert werden. Gemeinsame Services gehören nach `src/app/services`; wiederverwendbare UI-Komponenten, Pipes, Direktiven und Guards nach `src/app/widget-modules`. + +Der bestehende Stil verwendet: + +- TypeScript und Angular-Module mit lazy geladenen Feature-Modulen. +- Standalone-Komponenten dort, wo sie bereits im Code genutzt werden. +- LESS für Component-Styles. +- RxJS-Observables für Firestore-Livedaten. +- Services als fachliche Fassade über `DbService`. + +## Datenzugriff in neuen Funktionen + +Firestore-Zugriffe sollten über `DbService` oder vorhandene Fachservices erfolgen. Direkte AngularFire-Zugriffe sind nur sinnvoll, wenn der vorhandene Wrapper eine benötigte Operation nicht abbildet. + +Bei neuen fachlichen Datenflüssen ist zu prüfen: + +- ob ein Live-Observable oder ein einmaliger Promise-Zugriff benötigt wird, +- ob `shareReplay` sinnvoll ist, um Listener wiederzuverwenden, +- ob denormalisierte Felder wie `songUsage` oder `songIds` aktualisiert werden müssen, +- ob Firestore-Regeln und UI-Rollen die neue Aktion angemessen abdecken. + +## Rollen und UI-Zugriff + +Neue geschützte Routen sollten `AuthGuard` und bei Bedarf `RoleGuard` mit `requiredRoles` nutzen. Sichtbare Aktionen in Templates sollten über `*appRole` und bei besitzabhängigen Aktionen über `*appOwner` gesteuert werden. + +Da Firestore-Regeln für fachliche Collections nur Login voraussetzen, müssen rollenbasierte Einschränkungen in Routing, UI und Services konsistent umgesetzt werden. + +## Deployment-Ablauf + +Für ein reguläres Deployment: + +```bash +npm run deploy +``` + +Der Befehl baut die Production-Version und führt anschließend `firebase deploy` aus. Für einen Beta-Channel: + +```bash +npm run deploy-beta +``` + +Vor Deployments sollten mindestens Build und relevante Tests lokal oder im CI erfolgreich sein. + +## Manuelle Admin-Wartung + +Das README beschreibt zwei manuelle Browser-Konsolenbefehle für Admins: + +```js +await window.wgeneratorAdmin.rebuildSongUsage() +await window.wgeneratorAdmin.rebuildShowSongIds() +``` + +Diese Migrationen sind read-heavy und sollten bewusst ausgeführt werden, wenn historische Daten nachgezogen oder Indizes rekonstruiert werden müssen. diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000..8e98652 --- /dev/null +++ b/docs/index.md @@ -0,0 +1,52 @@ +# Projektdokumentation + +`wgenerator` ist eine Angular-Anwendung zur Verwaltung von Liedern, Veranstaltungen und Live-Präsentationen. Die Dokumentation ist nach fachlichen Seiten und technischen Querschnittsthemen getrennt, damit Änderungen an einer Route oder einem Modul gezielt nachvollzogen werden können. + +## Einstieg + +- [Technischer Aufbau](technical-architecture.md) +- [Datenmodell](data-model.md) +- [Rollen und Berechtigungen](roles-and-permissions.md) +- [Betrieb und Konfiguration](operations.md) +- [Entwicklung und Qualitätssicherung](development.md) + +## Seitendokumentation + +### Lieder + +- [Liedliste](pages/songs-list.md) +- [Lieddetails](pages/song-detail.md) +- [Lied anlegen](pages/song-new.md) +- [Lied bearbeiten](pages/song-edit.md) + +### Veranstaltungen + +- [Veranstaltungsliste](pages/shows-list.md) +- [Veranstaltungsdetails](pages/show-detail.md) +- [Veranstaltung anlegen](pages/show-new.md) +- [Veranstaltung bearbeiten](pages/show-edit.md) + +### Präsentation + +- [Präsentation auswählen](pages/presentation-select.md) +- [Präsentationssteuerung](pages/presentation-remote.md) +- [Präsentationsmonitor](pages/presentation-monitor.md) + +### Benutzer + +- [Login](pages/user-login.md) +- [Benutzerprofil](pages/user-info.md) +- [Benutzer anlegen](pages/user-new.md) +- [Passwort zurücksetzen](pages/user-password.md) +- [Passwort-E-Mail gesendet](pages/user-password-send.md) +- [Logout](pages/user-logout.md) + +### Öffentlich zugängliche Seiten + +- [Branding](pages/brand.md) +- [Neue Benutzer ohne Rollen](pages/brand-new-user.md) +- [Gastansicht](pages/guest.md) + +## Fachlicher Ablauf + +Lieder werden in der Lieddatenbank gepflegt. Eine Leitung erstellt daraus Veranstaltungen, sortiert Songs, veröffentlicht Abläufe und teilt optional eine Gastansicht. Das Präsentationsteam wählt eine aktuelle Veranstaltung aus und steuert Folien, Hintergründe, freien Text und Zoom live über die Remote-Seite. Der Monitor liest diese Zustände in Echtzeit und rendert die Ausgabe für Beamer oder Display. diff --git a/docs/operations.md b/docs/operations.md new file mode 100644 index 0000000..ad0abcc --- /dev/null +++ b/docs/operations.md @@ -0,0 +1,120 @@ +# Betrieb und Konfiguration + +## Lokale Einrichtung + +Abhängigkeiten werden wie im CI-Workflow installiert: + +```bash +npm ci -f +``` + +Der lokale Entwicklungsserver startet mit: + +```bash +npm start +``` + +`npm start` führt `ng serve` aus. Die Standard-Serve-Konfiguration ist `development`. + +## Firebase-Konfiguration + +`src/environments/environment.ts` und `src/environments/environment.prod.ts` importieren beide `src/environments/firebase.ts`. Diese Datei ist nicht versioniert und muss lokal vorhanden sein. In CI wird sie aus Secrets erzeugt. + +Beispielstruktur: + +```ts +export const firebase = { + apiKey: '...', + authDomain: '...', + databaseURL: 'https://worshipgenerator.firebaseio.com', + projectId: '...', + storageBucket: '...', + messagingSenderId: '...', + appId: '...', +}; +``` + +Die Anwendung nutzt `environment.url` für Rücksprung-URLs, zum Beispiel beim Passwort-Reset. Aktuell zeigt sowohl Development als auch Production auf `https://worshipgenerator.web.app`. + +## Firebase Hosting und Emulatoren + +`firebase.json` veröffentlicht den Production-Build aus `dist/wgenerator/browser`. Alle Routen werden per Rewrite auf `/index.html` geleitet, damit Angular-Routing direkt auf Hosting funktioniert. + +Cache-Verhalten: + +- HTML-/SPA-Routen ohne Dateiendung: `Cache-Control: max-age=1`. +- JS- und CSS-Dateien: `Cache-Control: max-age=846000`. + +Konfigurierte Emulator-Ports: + +- Firestore: `8080` +- Realtime Database: `9000` +- Hosting: `5000` + +## Build, Test und Lint + +Wichtige Befehle: + +```bash +npm run build:dev +npm run build +npm test +npm run lint +``` + +- `npm run build:dev` baut mit Development-Konfiguration, ohne Optimierung und mit Source Maps. +- `npm run build` baut die Production-Version mit File-Replacement auf `environment.prod.ts` und Output-Hashing. +- `npm test` führt Unit-Tests mit Vitest aus. +- `npm run lint` führt Angular ESLint aus und wendet automatische Fixes an. + +Production-Budgets sind in `angular.json` definiert: initiale Warnung ab `500kB`, Fehler ab `10MB`; Component-Styles warnen ab `40kB` und schlagen ab `80kB` fehl. + +## CI + +Der Gitea-Workflow `.gitea/workflows/angular-build.yml` läuft bei Pushes auf den Branch `dev` in einem `node:20-bullseye`-Container. + +Die Pipeline: + +1. checkt den Code aus, +2. installiert Abhängigkeiten mit `npm ci -f`, +3. erzeugt `src/environments/firebase.ts` aus Secrets, +4. führt `npm run build` aus. + +Die Pipeline deployt nicht automatisch. + +## Deployment + +Production-Build: + +```bash +npm run build +``` + +Deployment nach Firebase: + +```bash +npm run deploy +``` + +Beta-Deployment in einen Firebase-Hosting-Channel: + +```bash +npm run deploy-beta +``` + +`npm run deploy` baut zuerst die Production-Version und führt anschließend `firebase deploy` aus. Für lokale Deployments muss die Firebase CLI authentifiziert sein und Zugriff auf das Zielprojekt besitzen. + +## Manuelle Migrationen + +Das README dokumentiert zwei Admin-Migrationen, die im Browser mit einem angemeldeten Admin-Benutzer über `window.wgeneratorAdmin` ausgeführt werden: + +```js +await window.wgeneratorAdmin.rebuildSongUsage() +await window.wgeneratorAdmin.rebuildShowSongIds() +``` + +`rebuildSongUsage` rekonstruiert die Song-Nutzungszähler unter `users/{uid}.songUsage` aus nicht archivierten Shows und deren Show-Songs. + +`rebuildShowSongIds` rekonstruiert den `songIds`-Index auf Show-Dokumenten aus `shows/{showId}/songs`. + +Beide Migrationen lesen viele Dokumente und sind als manuelle Wartungsoperationen gedacht. diff --git a/docs/pages/brand-new-user.md b/docs/pages/brand-new-user.md new file mode 100644 index 0000000..8ac9a02 --- /dev/null +++ b/docs/pages/brand-new-user.md @@ -0,0 +1,32 @@ +# Neuer Benutzer ohne Rollen + +## Route + +`/brand/new-user` + +## Zweck + +Die Seite begrüßt neu registrierte Benutzer, die noch keine Berechtigungen erhalten haben. Sie macht sichtbar, dass der Account existiert, aber noch administrative Freischaltung benötigt. + +## Datenquellen + +- `NewUserComponent` liest den aktuellen Benutzer über `UserService.user$`. +- Die angezeigte Person stammt aus dem Firestore-Dokument `users/{uid}`. + +## UI + +Die Ansicht zeigt `BrandComponent`, die Begrüßung `WILLKOMMEN`, den Namen des aktuellen Benutzers und den Hinweis, dass noch keine Berechtigungen zugeteilt wurden. + +## Aktionen + +Die Seite bietet keine eigene Aktion. Der nächste fachliche Schritt ist die Rollenvergabe durch einen Administrator auf `/user/info`. + +## Rollen und Berechtigungen + +Die Route ist öffentlich konfiguriert, zeigt den personalisierten Inhalt aber nur, wenn `UserService.user$` einen Benutzer liefert. Sie ist für angemeldete Benutzer ohne Rollen gedacht. + +## Technische Hinweise + +- Nach erfolgreicher Selbstregistrierung navigiert `UserSessionService.createNewUser` zu dieser Route. +- Die Seite prüft Rollen nicht selbst und vergibt keine Rechte. +- Wenn kein Benutzer aus `user$` kommt, wird nur das Branding angezeigt. diff --git a/docs/pages/brand.md b/docs/pages/brand.md new file mode 100644 index 0000000..cb92394 --- /dev/null +++ b/docs/pages/brand.md @@ -0,0 +1,30 @@ +# Branding + +## Route + +`/brand` + +## Zweck + +Die Seite zeigt eine einfache Markenansicht mit Logo und Copyright-Hinweis. + +## Datenquellen + +Die Seite lädt keine fachlichen Daten. `BrandComponent` rendert nur statische Inhalte und `LogoComponent`. + +## UI + +Die Ansicht besteht aus dem Logo und dem Copyright-Text `© 2019 - 2026 - Benjamin Ifland`. + +## Aktionen + +Die Seite bietet keine interaktiven Aktionen. + +## Rollen und Berechtigungen + +Die Seite ist öffentlich erreichbar und hat keinen Guard. + +## Technische Hinweise + +- `BrandComponent` ist als Standalone-Import im `BrandModule` eingebunden. +- Die Komponente wird in `/brand/new-user` wiederverwendet, damit der Freischaltungszustand dieselbe Markenansicht nutzt. diff --git a/docs/pages/guest.md b/docs/pages/guest.md new file mode 100644 index 0000000..fdc5f2a --- /dev/null +++ b/docs/pages/guest.md @@ -0,0 +1,38 @@ +# Gastansicht + +## Route + +`/guest/:id` + +## Zweck + +Die Gastansicht zeigt eine öffentlich geteilte Version einer Veranstaltung. Sie richtet sich an externe Personen ohne Login und stellt Veranstaltungstyp, Datum und Liedtexte bereit. + +## Datenquellen + +- `GuestComponent` liest die Routen-ID aus `ActivatedRoute.params`. +- `GuestShowDataService.read(id)` lädt den initialen Datensatz aus der Firestore-Collection `guest`. +- `GuestShowDataService.read$(id)` abonniert anschließend Live-Updates für denselben Datensatz. +- `GuestShowService.share(show, songs)` erstellt oder aktualisiert Gastdatensätze aus einer Veranstaltung und erzeugt die URL `/guest/{shareId}`. + +## UI + +Die geladene Veranstaltung zeigt links den übersetzten Veranstaltungstyp und rechts das Datum im Format `dd.MM.yyyy`. Die Songs werden in einem Swiper dargestellt. Jede Folie enthält Titel, optional Künstler und den Liedtext über `SongTextComponent`. + +Für Lade-, Fehler- und Nicht-gefunden-Zustände zeigt die Seite einfache Meldungen. + +## Aktionen + +Die Gastseite selbst bietet keine Bearbeitungsaktionen. Benutzer können durch die Song-Folien wischen; Aktualisierungen am geteilten Datensatz erscheinen über das Live-Abonnement. + +## Rollen und Berechtigungen + +Die Route ist öffentlich erreichbar und nicht durch Authentifizierung geschützt. Zugriffsschutz erfolgt ausschließlich über die Kenntnis der Share-ID in der URL. + +## Technische Hinweise + +- Der Zustand der Seite ist als `GuestShowState` modelliert: `loading`, `loaded`, `not-found` oder `error`. +- Datumswerte werden normalisiert und unterstützen `Date`, Firestore-Timestamps mit `toDate`, Objekte mit `seconds`, Strings und Zahlen. +- Falls der initiale Ladevorgang keinen Datensatz findet, wird `not-found` angezeigt. +- Fehler beim initialen Laden oder bei Live-Aktualisierungen führen zu einer Fehlermeldung. +- `ensureSwiperElement()` registriert das Web Component für den Swiper. diff --git a/docs/pages/presentation-monitor.md b/docs/pages/presentation-monitor.md new file mode 100644 index 0000000..f50e5f2 --- /dev/null +++ b/docs/pages/presentation-monitor.md @@ -0,0 +1,82 @@ +# Seite: Präsentationsmonitor + +## Route + +`/presentation/monitor` + +Die Route öffnet die Vollbildausgabe für Beamer oder Display. Sie wird typischerweise über den Button `Präsentation starten` auf `/presentation/remote` geöffnet. + +## Zweck + +Der Monitor rendert den aktuellen Präsentationszustand der aktiven Show. Er zeigt Titelfolie, leere Fläche, freien Text oder Liedabschnitte und ergänzt bei Liedern die rechtlichen Angaben. + +## Datenfluss + +Die `MonitorComponent` liest `global/static.currentShow` über `GlobalSettingsService.get$`. Aus dieser ID lädt sie die Show über `ShowService.read$(showId)` und übernimmt daraus die Live-Felder für Anzeigezustand, Datum, Veranstaltungstyp, Zoom, Hintergrund und freien Text. + +Für Song-Inhalte beobachtet der Monitor `presentationSongId`. Bei `title`, `dynamicText` oder fehlender Song-ID wird kein Song gesetzt. Bei anderen Werten lädt er den passenden Show-Song über `ShowSongService.read$(showId, presentationSongId)`. + +Konfigurationsdaten für rechtliche Hinweise kommen aus `ConfigService.get$()`. Die Komponente `app-legal` nutzt diese Daten unter anderem für die CCLI-Lizenznummer. + +## UI-Anzeige + +Beim Initialisieren ruft der Monitor `openFullscreen()` auf. Die Anzeige liegt als fixierte Vollbildfläche über der Anwendung und blendet den Mauszeiger aus. + +Der Monitor kennt folgende Zustände: + +- `title`: zeigt den übersetzten Veranstaltungstyp und das Datum. +- `empty`: zeigt die leere Präsentationsfläche mit Logo beziehungsweise Hintergrund. +- `dynamicText`: zeigt `presentationDynamicCaption` und `presentationDynamicText`. +- Show-Song-ID: rendert `app-song-text` mit Songtitel, Liedtext und aktivem Abschnitt. + +Bei Songs werden Akkorde ausgeblendet (`chordMode="hide"`), Kommentare nicht angezeigt und die interne Abschnittsnavigation des Song-Text-Widgets deaktiviert. Der aktive Abschnitt kommt aus `presentationSection`. + +## Zusammenspiel von Remote und Monitor + +Der Monitor ist ein reiner Live-Reader. Alle Bedienhandlungen erfolgen in der Remote-Steuerung; der Monitor reagiert auf die Felder, die dort auf der aktiven Show gespeichert werden. + +Wenn die Remote `presentationSongId`, `presentationSection`, `presentationZoom`, `presentationBackground`, `presentationDynamicCaption` oder `presentationDynamicText` ändert, aktualisiert der Monitor seine Darstellung über die abonnierten Datenströme. Beim Wechsel der aktiven Show über `/presentation/select` liest der Monitor die neue `currentShow` aus den globalen Settings und richtet die Ausgabe darauf aus. + +## Live-Felder auf der Show + +Der Monitor wertet folgende Felder aus: + +- `presentationSongId`: entscheidet über Titelfolie, Leerseite, freien Text oder Songanzeige. +- `presentationSection`: bestimmt den aktiven Abschnitt im Songtext. +- `presentationDynamicCaption`: Überschrift für den freien Text. +- `presentationDynamicText`: Inhalt für den freien Text; Zeilenumbrüche bleiben durch die Monitor-Styles erhalten. +- `presentationZoom`: wird als Pixelwert auf die Vollbildfläche gesetzt. +- `presentationBackground`: schaltet die Hintergrundgrafik. + +Zusätzlich nutzt er `showType` und `date` für die Titelfolie. + +## Hintergründe + +`presentationBackground` unterstützt diese Werte: + +- `none`: schwarzer Hintergrund ohne Bild. +- `blue`: `assets/bg-dark-blue.jpg` +- `green`: `assets/bg-dark-green.jpg` +- `leder`: `assets/bg-leder.jpg` +- `praise`: `assets/bg-praise.jpg` +- `bible`: `assets/bg-bible.jpg` + +Die Bildhintergründe werden vollflächig gerendert, weich eingeblendet und je nach Motiv mit Blur und reduzierter Deckkraft versehen. Bei aktivem Bildhintergrund wird das Logo in Songzuständen vollständig ausgeblendet. + +## Rechtliche Angaben + +Bei Songanzeige rendert `app-legal` die verfügbaren Metadaten des Songs: + +- Künstler +- Label +- Nutzungsbedingungen +- Herkunft +- Liednummer beziehungsweise CCLI-Liednummer + +Wenn `song.legalOwner` den Wert `CCLI` hat und Konfiguration geladen ist, wird zusätzlich die CCLI-Lizenznummer aus `ConfigService` angezeigt. + +## Technische Besonderheiten + +Songwechsel werden um 600 ms verzögert. Vor dem Umschalten setzt die Komponente intern `songId` auf `empty`, damit die `songSwitch`-Animation sauber zwischen den Zuständen wechseln kann. Ein laufender Timeout wird beim nächsten Wechsel oder beim Zerstören der Komponente abgebrochen. + +Die Show-Daten werden mit `shareReplay(1)` geteilt, damit die separaten Streams für allgemeine Präsentationsdaten und Song-Ladevorgänge dieselbe Show-Quelle verwenden. Subscriptions werden über `destroy$` beendet. diff --git a/docs/pages/presentation-remote.md b/docs/pages/presentation-remote.md new file mode 100644 index 0000000..33b00d3 --- /dev/null +++ b/docs/pages/presentation-remote.md @@ -0,0 +1,74 @@ +# Seite: Präsentationssteuerung + +## Route + +`/presentation/remote` + +Dies ist die Standardseite des Presentation-Moduls. Ein Aufruf von `/presentation` leitet auf diese Route weiter. + +## Zweck + +Die Remote-Seite ist die Live-Bedienoberfläche für das Präsentationsteam. Sie bestimmt, welche Folie der Monitor zeigt, welche Hintergrundgrafik aktiv ist, wie groß der Text dargestellt wird und welcher freie Text live eingeblendet werden soll. + +## Datenfluss + +Die `RemoteComponent` liest zuerst `global/static.currentShow` über `GlobalSettingsService.get$`. Sobald eine aktuelle Show vorhanden ist, lädt sie: + +- die Show über `ShowService.read$(showId)` +- die zugeordneten Show-Songs über `ShowSongService.list$(showId)` +- die verfügbaren Songs für das Live-Hinzufügen über `SongService.list$()` + +Die Show-Songs werden mit `TextRenderingService.parse(song.text, null, false)` in Präsentationsabschnitte zerlegt. Für die Anzeige nutzt die Remote nur die Song-IDs, Titel und geparsten Abschnitte. Die sichtbare Reihenfolge folgt `show.order`; Songs, die nicht in dieser Reihenfolge stehen, werden in der Abschnittsliste nicht gerendert. + +Änderungen schreibt die Remote direkt auf das aktuelle Show-Dokument. Freier Text wird über Subjects gesammelt und mit `debounceTime(1000)` verzögert gespeichert, damit beim Tippen nicht jeder Tastendruck sofort einen Schreibvorgang auslöst. + +## UI-Bedienung + +Oben zeigt die Karte den Veranstaltungstyp und das Datum der aktiven Show. Über das Ordner-Symbol gelangt man zur Auswahlseite `/presentation/select`. + +Die Bedienfläche enthält feste Ziele und die nach Show-Reihenfolge sortierten Songs: + +- `Veranstaltung`: setzt `presentationSongId` auf `title` und zeigt auf dem Monitor die Titelfolie. +- `Leer`: setzt `presentationSongId` auf `empty` und zeigt eine leere Präsentationsfläche. +- Songtitel: setzt die Song-ID mit `presentationSection: -1`; der Monitor lädt den Song, ohne einen konkreten Abschnitt auszuwählen. +- Songabschnitt: setzt die Song-ID und den Abschnittsindex. Angezeigt werden Abschnittstyp, Abschnittsnummer und die erste Textzeile des Abschnitts. +- `Freier Text`: setzt `presentationSongId` auf `dynamicText`. Überschrift und Text werden über die Eingabefelder darunter gepflegt. + +Am unteren Rand befinden sich die Live-Einstellungen: + +- `Präsentation starten` öffnet `/presentation/monitor`. +- `Hintergrund` setzt `presentationBackground`. +- Der Slider setzt `presentationZoom` im Bereich von 10 bis 100 in Schritten von 2. + +Zusätzlich bindet die Seite `app-add-song` mit `addedLive="true"` ein. Damit können Songs während der Präsentation zur Show hinzugefügt werden; die Remote bekommt die aktualisierte Show-Song-Liste anschließend über die Live-Datenströme. + +## Zusammenspiel von Remote und Monitor + +Remote und Monitor kommunizieren nicht direkt miteinander. Die Remote schreibt den gewünschten Präsentationszustand auf die aktive Show, der Monitor liest dieselben Felder live und rendert daraus die Ausgabe. + +Für den Betrieb bedeutet das: + +- Die Auswahlseite setzt `global/static.currentShow`. +- Die Remote liest diese Show, zeigt deren Songs und schreibt Präsentationsbefehle auf das Show-Dokument. +- Der Monitor liest dieselbe Show und aktualisiert seine Anzeige, sobald sich die Live-Felder ändern. + +Dadurch kann die Remote auf einem Bediengerät laufen, während der Monitor auf einem Beamer- oder Display-Gerät geöffnet ist. + +## Live-Felder auf der Show + +Die Remote pflegt folgende Felder aus `Show`: + +- `presentationSongId`: aktiver Inhalt. Besondere Werte sind `title`, `empty` und `dynamicText`; ansonsten enthält das Feld eine Show-Song-ID. +- `presentationSection`: Index des aktiven Liedabschnitts. Bei Titeln, Leerseite, freiem Text oder Songtitel-Auswahl wird `-1` verwendet. +- `presentationDynamicCaption`: Überschrift des freien Textes. +- `presentationDynamicText`: Inhalt des freien Textes; Zeilenumbrüche werden vom Monitor erhalten. +- `presentationZoom`: Schriftgröße für den Monitor. +- `presentationBackground`: Hintergrundmodus. Unterstützt sind `none`, `blue`, `green`, `leder`, `praise` und `bible`. + +## Technische Besonderheiten + +Die Komponente nutzt `ChangeDetectionStrategy.OnPush` und ruft nach Live-Updates `markForCheck()` auf. Subscriptions werden über `destroy$` mit `takeUntil` beendet. + +Der aktive Show-Kontext wird aus `GlobalSettingsService` abgeleitet und mit `distinctUntilChanged()` stabilisiert. Sobald sich `currentShow` ändert, laden Show und Show-Songs automatisch neu. + +Die Remote ist tastaturbedienbar: auswählbare Folien reagieren neben Klicks auch auf `Enter` und `Space` und sind als `role="button"` mit `tabindex="0"` ausgezeichnet. diff --git a/docs/pages/presentation-select.md b/docs/pages/presentation-select.md new file mode 100644 index 0000000..b304899 --- /dev/null +++ b/docs/pages/presentation-select.md @@ -0,0 +1,54 @@ +# Seite: Präsentation auswählen + +## Route + +`/presentation/select` + +Die Route gehört zum Presentation-Modul. Der leere Presentation-Pfad leitet auf `/presentation/remote` weiter; die Auswahlseite wird über den Ordner-Button der Remote-Steuerung geöffnet. + +## Zweck + +Die Seite legt fest, welche Veranstaltung live präsentiert wird. Sie ist der Einstiegspunkt, wenn das Präsentationsteam vor oder während einer Veranstaltung auf eine andere Show wechseln muss. + +## Datenfluss + +Die `SelectComponent` lädt Shows über `ShowService.list$(true)`. Dadurch werden veröffentlichte Veranstaltungen angezeigt; eigene unveröffentlichte Shows werden in diesem Modus nicht zusätzlich eingeblendet. Anschließend filtert die Komponente clientseitig auf Shows, deren Datum neuer ist als ein Monat vor dem aktuellen Zeitpunkt. + +Die Liste wird nach Datum sortiert und zeigt pro Eintrag den Besitzer, den übersetzten Veranstaltungstyp und das Datum. Bei der Auswahl einer Show passieren zwei Schreibvorgänge: + +- `GlobalSettingsService.set({currentShow: show.id})` schreibt die aktive Show in das globale Dokument `global/static`. +- `ShowService.update$(show.id, {presentationSongId: 'title'})` setzt die Präsentation der gewählten Show auf die Titelfolie. + +Danach navigiert die Seite nach `/presentation/remote`. + +## UI-Bedienung + +Die Seite zeigt eine Karte mit der Überschrift `Bitte eine Veranstaltung auswählen`. Wenn keine passende Veranstaltung vorhanden ist, erscheint der Hinweis `Es ist derzeit keine Veranstaltung vorhanden`. + +Jede verfügbare Veranstaltung wird als vollbreiter Button dargestellt. Ein Klick auf einen Eintrag aktiviert diese Show global und öffnet direkt die Remote-Steuerung. Die Seite besitzt kein eigenes Menü. + +## Zusammenspiel von Remote und Monitor + +Die Auswahlseite steuert nicht direkt den Monitor. Sie bestimmt aber über `global/static.currentShow`, welche Show Remote und Monitor anschließend beobachten. Da beide Seiten denselben globalen Wert lesen, wechseln Remote-Steuerung und Monitor auf dieselbe Veranstaltung, sobald die Auswahl gespeichert ist. + +Das zusätzliche Setzen von `presentationSongId` auf `title` sorgt dafür, dass der Monitor nach dem Wechsel nicht versehentlich den zuletzt aktiven Liedabschnitt oder freien Text der Show anzeigt, sondern mit der Veranstaltungsfolie startet. + +## Live-Felder auf der Show + +Die Auswahlseite schreibt nur ein Präsentationsfeld auf der Show: + +- `presentationSongId`: wird beim Auswählen auf `title` gesetzt. + +Alle weiteren Live-Felder werden anschließend über die Remote-Steuerung gepflegt: + +- `presentationSection` +- `presentationDynamicCaption` +- `presentationDynamicText` +- `presentationZoom` +- `presentationBackground` + +## Technische Besonderheiten + +Die aktive Show liegt nicht im lokalen Komponentenstatus, sondern im globalen Settings-Dokument. Das macht den Wechsel geräteübergreifend sichtbar: Ein Gerät kann die Show auswählen, während ein anderes Gerät bereits den Monitor geöffnet hat. + +Die Showliste wird über RxJS im Template mit `AsyncPipe` angezeigt. Die Komponente blendet den Inhalt beim Initialisieren über den `fade`-Trigger ein. diff --git a/docs/pages/show-detail.md b/docs/pages/show-detail.md new file mode 100644 index 0000000..94c2741 --- /dev/null +++ b/docs/pages/show-detail.md @@ -0,0 +1,128 @@ +# Seite: Veranstaltungsdetails + +## Route + +`/shows/:showId` + +Die Route zeigt eine einzelne Veranstaltung anhand der URL-Variable `showId`. In `shows-routing.module.ts` ist kein eigener `canActivate`-Guard für diese Detailroute definiert. + +## Zweck + +Die Detailseite ist der zentrale Arbeitsbereich für eine Veranstaltung. Hier werden die Ablaufreihenfolge gepflegt, Lieder für diese Veranstaltung angepasst, Texte angezeigt, die Veranstaltung veröffentlicht oder archiviert, ein Gastlink erzeugt, die CCLI-Meldung abgeschlossen und ein DOCX-Dokument exportiert. + +## Datenquellen + +- `ActivatedRoute.params` liefert `showId`. +- `ShowService.read$(showId)` laedt das Show-Dokument. +- `ShowSongService.list$(showId)` laedt die Lieder aus der Subcollection `shows/{showId}/songs`. +- `SongService.list$()` wird nur für unveröffentlichte Shows geladen, damit weitere Lieder hinzugefügt werden können. +- `GuestShowService.share(show, songs)` erzeugt oder aktualisiert die Gastansicht für geteilte veröffentlichte Veranstaltungen. +- `DocxService.create(showId, options?)` laedt Show, Show-Songs, Besitzer und Konfiguration für den DOCX-Export. +- `UserService` wird beim Archivieren genutzt, um Song-Nutzungszaehler zu verringern oder wieder zu erhoehen. + +## Wichtige UI-Elemente + +- `app-page-frame` mit Titel `Veranstaltungen`. +- Hauptkarte mit Veranstaltungstyp, Datum und Status im Kopf. +- Metazeile mit öffentlich/geschlossen, Besitzername, Veröffentlichungs-Badge und CCLI-Melde-Badge für den Besitzer. +- Checkbox `Text anzeigen`. +- Icon-Aktionen für Textgroesse und Vollbild. +- Drag-and-drop-Liedliste mit `app-song`-Einträgen. +- `app-add-song` zum Hinzufügen weiterer Lieder bei unveröffentlichten Veranstaltungen. +- Vollbild-/Swiper-Ansicht mit Uhrzeit, nächstem Lied und Tastatursteuerung. +- Aktionsleiste für Archivierung, Veröffentlichung, Teilen, CCLI, Bearbeiten und DOCX-Download. + +## Aktionen + +- Reihenfolge ändern: Drag-and-drop aktualisiert `show.order`. +- Lied hinzufügen: nur bei unveröffentlichten Shows, über `app-add-song`. +- Tonart ändern: die Tonart eines Show-Songs wird direkt in der Show-Subcollection gespeichert. +- Liedtext für diese Veranstaltung bearbeiten: speichert nur den Text des Show-Songs, nicht den globalen Song. +- Lied entfernen: entfernt den Show-Song, passt `order` an und entfernt die Song-ID aus `songIds`, wenn kein weiteres Vorkommen desselben Songs in der Show existiert. +- Text anzeigen: blendet Liedtexte ein und aktiviert je nach Lied die Akkorddarstellung. +- Vollbild starten: aktiviert die Swiper-Ansicht, vergroessert den Text und nutzt Browser-Fullscreen. +- Vollbild verlassen: setzt Textgroesse und Fullscreen zurück. +- DOCX herunterladen: öffnet ein Menü mit zwei Exportvarianten. + +## Veröffentlichung + +Die Aktion `Veröffentlichen` setzt `published` auf `true`. + +- Geschlossene bzw. nicht öffentliche Shows erhalten `reportedType: 'not-required'`. +- Öffentliche Shows werden auf CCLI-pflichtige Lieder geprüft. +- Wenn mindestens ein Show-Song `legalOwner === 'CCLI'` und eine `legalOwnerId` hat, wird `reportedType: 'pending'` gesetzt. +- Wenn keine CCLI-Meldung erforderlich ist, wird `reportedType: 'not-required'` gesetzt. + +Die Aktion `Veröffentlichung zurückziehen` setzt `published` auf `false` und `reportedType` auf `null`. + +Veröffentlichte Veranstaltungen sind in der Detailseite inhaltlich weitgehend gesperrt: Die Reihenfolge ist nicht per Drag-and-drop änderbar, es werden keine neuen Songs geladen, und die Bearbeiten-Aktion für Showkopf sowie Song-Bearbeitung stehen nicht zur Verfügung. + +## Archivierung + +Die Aktion `Archivieren` öffnet einen Bestätigungsdialog. Nach Bestätigung setzt die Seite `archived: true`. + +Beim Archivieren wird für jeden geladenen Show-Song `UserService.decSongCount(songId)` aufgerufen. Beim Wiederherstellen setzt die Seite `archived: false` und ruft entsprechend `UserService.incSongCount(songId)` auf. + +Archivierte Shows verschwinden aus den normalen Listen und können in der Veranstaltungsliste für eigene Veranstaltungen über den Archiv-Filter wieder sichtbar gemacht werden. + +## CCLI-Meldung + +Die CCLI-Aktion erscheint nur für veröffentlichte Shows mit `reportedType === 'pending'`. + +Der Report-Dialog sammelt eindeutige CCLI-pflichtige Lieder aus der aktuellen Reihenfolge. Eindeutigkeit wird über `songId` oder ersatzweise `title:legalOwnerId` hergestellt. Für jedes Lied zeigt der Dialog Titel, CCLI-Nummer und einen Link zu `https://reporting.ccli.com/search?s={nummer}`. + +Nach Klick auf `Alle CCLI-Titel wurden gemeldet` setzt die Seite `reportedType` auf `reported`. + +## Teilen + +Die Teilen-Aktion ist nur für veröffentlichte Shows sichtbar. + +`GuestShowService.share()` schreibt die für Gaeste benötigten Daten in die Guest-Show-Datenquelle: + +- `showType` +- `date` +- `updatedAt` +- geordnete Songliste + +Wenn die Show noch keine `shareId` hat, wird ein neuer Guest-Show-Eintrag angelegt und die `shareId` im Show-Dokument gespeichert. Wenn bereits eine `shareId` existiert, wird die bestehende Gastansicht aktualisiert. + +Der Share-Dialog zeigt den Link `/guest/{shareId}`, erzeugt einen QR-Code und bietet über Clipboard/Web Share API eine Teilen-Aktion an. + +## DOCX-Export + +Der Download-Button öffnet ein Menü mit zwei Varianten: + +- `Ablauf für Lobpreisgruppe`: erstellt ein DOCX mit Songtexten und Akkorden entsprechend dem jeweiligen `chordMode`. +- `Handout mit Copyright Infos`: erstellt ein DOCX mit `chordMode: 'hide'` und Copyright-/Lizenzinformationen. + +`DocxService` laedt die Bibliothek `docx` dynamisch, rendert die Songs in `show.order`, transponiert Texte über `TextRenderingService.parse()` und erzeugt den Download im Browser über einen temporaeren Blob-Link. + +## Statuslogik + +Der Seitenstatus im Kopf wird so berechnet: + +- `veröffentlicht`, wenn `show.published` wahr ist +- `gemeldet`, wenn `show.reportedType === 'reported'` +- sonst `entwurf` + +Badge-Typen: + +- `reportedType: 'pending'` wird als Fehler-/Warnstatus dargestellt. +- `reportedType: 'reported'` wird als OK-Status dargestellt. +- `reportedType: 'not-required'` und fehlender Meldewert erhalten keinen hervorgehobenen Badge. +- `published` wird als OK-Status dargestellt, nicht veröffentlichte Shows ohne Hervorhebung. + +## Berechtigungen + +- Die Route selbst hat im Shows-Routing keinen eigenen Guard. +- Archivieren, Wiederherstellen, Veröffentlichen, Veröffentlichung zurückziehen, Teilen, CCLI-Meldung und Bearbeiten sind per `RoleDirective` auf `leader` und per `OwnerDirective` auf den Besitzer der Show beschränkt. +- Der DOCX-Download ist in der Aktionsleiste ohne diese Owner-/Leader-Einschränkung sichtbar. +- Die Bearbeiten-Aktion für den Showkopf erscheint nur bei unveröffentlichten Shows. + +## Technische Hinweise + +- `show$` und `songs$` werden mit `shareReplay({bufferSize: 1, refCount: true})` geteilt. +- Die Seite haelt `showSongs` als lokale Liste, weil Sortierung, Export, Teilen und CCLI-Meldung die geordnete Liste synchron benoetigen. +- `orderedShowSongs(show)` mappt `show.order` auf die geladenen Show-Songs und filtert fehlende Einträge aus. +- Keyboard-Navigation im Vollbild reagiert auf Pfeiltasten und steuert das Swiper-Element. +- `getSongKeyColumnWidth()` berechnet eine stabile Spaltenbreite für Tonart-Labels inklusive Transposition. diff --git a/docs/pages/show-edit.md b/docs/pages/show-edit.md new file mode 100644 index 0000000..e73fa73 --- /dev/null +++ b/docs/pages/show-edit.md @@ -0,0 +1,59 @@ +# Seite: Veranstaltung bearbeiten + +## Route + +`/shows/:showId/edit` + +Die Route bearbeitet den Showkopf einer bestehenden Veranstaltung anhand der URL-Variable `showId`. In `shows-routing.module.ts` ist für diese Route kein eigener `canActivate`-Guard definiert. + +## Zweck + +Die Seite ändert Datum und Veranstaltungstyp einer vorhandenen Veranstaltung. Sie ist für Korrekturen an den Kopfdaten gedacht; Songauswahl, Reihenfolge, Texte, Veröffentlichung, Archivierung, Teilen, CCLI-Meldung und DOCX-Export werden auf der Detailseite verwaltet. + +## Datenquellen + +- `ActivatedRoute.params` liefert `showId`. +- `ShowService.read$(showId)` laedt die Show einmalig. +- `ShowService.SHOW_TYPE_PUBLIC` und `ShowService.SHOW_TYPE_PRIVATE` liefern die auswählbaren Typen. +- `ShowService.update$(id, data)` speichert die Änderungen. +- `ShowDataService.update()` schreibt die Aktualisierung in `shows/{id}`. + +`EditComponent` haelt außerdem `ShowDataService.list$` als `shows$`, nutzt diesen Stream in der aktuellen Vorlage aber nicht sichtbar. + +## Wichtige UI-Elemente + +- `app-page-frame` mit Titel `Veranstaltungen`. +- Karte `Veranstaltung ändern` mit Rücksprung zur Detailseite `/shows/{id}`. +- Formularfeld `Art der Veranstaltung` als gruppierte Auswahl. +- Formularfeld `Datum` mit Material-Datepicker. +- Button `Speichern`. + +## Aktionen + +- Seite laden: liest die Show und befüllt das Formular mit `id`, `date` und `showType`. +- Speichern: markiert alle Felder als berührt, prüft Pflichtfelder und aktualisiert Datum sowie Typ. +- Nach dem Speichern: Navigation zurück nach `/shows/{id}`. + +## Statuslogik + +Beim Initialisieren wird das Formular zuerst zurückgesetzt und danach einmalig aus der geladenen Show befüllt. Das Speichern bricht ab, wenn das Formular ungültig ist oder `id`, `date` oder `showType` fehlen. + +Beim Speichern wird nur Folgendes geändert: + +- `date` als Firestore `Timestamp.fromDate(date)` +- `showType` + +Die Seite ändert keine Werte für `published`, `reportedType`, `archived`, `order`, `songIds` oder `shareId`. + +## Berechtigungen + +- Die Route selbst hat im Shows-Routing keinen eigenen Guard. +- Der Einstieg zur Bearbeitungsseite ist auf der Detailseite nur für `leader`, den Besitzer der Show und unveröffentlichte Shows sichtbar. +- Direkte URL-Aufrufe werden auf Komponentenebene nicht zusätzlich durch `RoleDirective` oder `OwnerDirective` abgefangen. + +## Technische Hinweise + +- Das Formular ist ein Reactive Form mit den Controls `id`, `date` und `showType`. +- Die Show wird mit `take(1)` nur einmal in das Formular übernommen. +- Die Typauswahl verwendet dieselben Konstanten wie die Neuanlage und zeigt die Werte über `ShowTypePipe` an. +- Änderungen am Feld `showType` berechnen `public` nicht neu; gespeichert wird nur der Typ. Falls der Öffentlich-/Privat-Status nach Typwechsel relevant ist, muss diese Logik separat berücksichtigt werden. diff --git a/docs/pages/show-new.md b/docs/pages/show-new.md new file mode 100644 index 0000000..3a9709b --- /dev/null +++ b/docs/pages/show-new.md @@ -0,0 +1,59 @@ +# Seite: Veranstaltung anlegen + +## Route + +`/shows/new` + +Die Route ist im Shows-Routing mit `RoleGuard` geschuetzt und verlangt die Rolle `leader`. + +## Zweck + +Die Seite erstellt den Kopf einer neuen Veranstaltung. Nach der Anlage wird direkt zur Detailseite navigiert, wo Lieder hinzugefügt und der weitere Ablauf gepflegt werden. + +## Datenquellen + +- `ShowService.SHOW_TYPE_PUBLIC` und `ShowService.SHOW_TYPE_PRIVATE` liefern die auswählbaren Veranstaltungstypen. +- `ShowService.new$(data)` erstellt das Show-Dokument. +- `UserService.user$` wird innerhalb von `ShowService.new$()` verwendet, um den Besitzer zu setzen. +- `ShowDataService.add()` schreibt die neue Show in die Firestore-Collection `shows`. + +`NewComponent` haelt außerdem `ShowDataService.list$` als `shows$`, nutzt diesen Stream in der aktuellen Vorlage aber nicht sichtbar. + +## Wichtige UI-Elemente + +- `app-page-frame` mit Titel `Veranstaltungen`. +- Karte `Neue Veranstaltung` mit Rücksprung nach `/shows`. +- Formularfeld `Art der Veranstaltung` als gruppierte Auswahl. +- Formularfeld `Datum` mit Material-Datepicker. +- Button `Anlegen`. + +## Aktionen + +- Formular ausfuellen: Typ und Datum sind Pflichtfelder. +- Anlegen: markiert alle Felder als berührt, prüft die Formularvaliditaet und ruft `ShowService.new$()` auf. +- Nach erfolgreicher Anlage: Navigation zu `/shows/{id}`. + +## Statuslogik + +Beim Initialisieren wird das Formular zurückgesetzt. Das Speichern bricht ab, wenn Pflichtfelder fehlen oder kein Benutzer ermittelt werden kann. + +`ShowService.new$()` ergänzt die eingegebenen Daten um: + +- `owner`: ID des aktuellen Benutzers +- `order: []` +- `songIds: []` +- `public`: abgeleitet daraus, ob `showType` in `SHOW_TYPE_PUBLIC` enthalten ist + +Veröffentlichungs-, Melde- und Archivstatus werden auf dieser Seite nicht direkt gesetzt. + +## Berechtigungen + +- Zugriff auf die Route erfordert `leader`. +- Die Seite selbst enthält keine zusätzliche Owner-Prüfung, da die Show erst beim Speichern für den aktuellen Benutzer erzeugt wird. + +## Technische Hinweise + +- Das Formular ist ein typisiertes Reactive Form mit `FormControl` und `FormControl`. +- Die Auswahl trennt öffentliche und private Veranstaltungstypen in `mat-optgroup`. +- Die Anzeige der Typen erfolgt über `ShowTypePipe`. +- `ShowService.new$()` gibt `null` zurück, wenn kein `showType` oder kein Benutzer vorhanden ist; die Navigation nutzt dann defensiv einen leeren String. diff --git a/docs/pages/shows-list.md b/docs/pages/shows-list.md new file mode 100644 index 0000000..c5f596f --- /dev/null +++ b/docs/pages/shows-list.md @@ -0,0 +1,75 @@ +# Seite: Veranstaltungsliste + +## Route + +`/shows` + +Die Route ist der Standardpfad des Shows-Moduls. In `shows-routing.module.ts` ist kein eigener `canActivate`-Guard auf dieser Route definiert. + +## Zweck + +Die Veranstaltungsliste ist der Einstieg in den Veranstaltungsbereich. Sie trennt eigene, noch zu bearbeitende Veranstaltungen von bereits veröffentlichten Veranstaltungen und bietet für berechtigte Benutzer Filter sowie den Einstieg zur Neuanlage. + +## Datenquellen + +- `ShowService.list$()` liefert die für den aktuellen Benutzer sichtbaren Veranstaltungen. +- `ShowService.list$(false, true)` liefert eigene Veranstaltungen inklusive archivierter eigener Einträge. +- `ShowService.listPublicSince$(lastMonths)` fragt veröffentlichte, nicht archivierte Veranstaltungen serverseitig nach Zeitraum ab. +- Falls die serverseitige Abfrage keine Ergebnisse liefert, nutzt die Liste einen lokalen Fallback aus geladenen veröffentlichten und nicht archivierten Shows. +- `FilterStoreService.showFilter$` speichert Zeitraum, Ersteller, Veranstaltungstyp und Archiv-Filter. +- `UserService.user$` bestimmt den aktuellen Benutzer und dessen Rolle. +- `FilterComponent.owners$()` baut die Ersteller-Auswahl aus den in Shows verwendeten `owner`-IDs und `UserService.getUserbyId$()`. + +## Wichtige UI-Elemente + +- Seitenrahmen `app-page-frame` mit Titel `Veranstaltungen`. +- Sidebar mit `app-filter`, sichtbar für Rollen mit Sidebar-Zugriff. +- Karte `Meine Veranstaltungen` für eigene Entwürfe, nicht gemeldete veröffentlichte Veranstaltungen und optional archivierte Veranstaltungen. +- Karte `Veröffentlichte Veranstaltungen` für veröffentlichte, nicht archivierte Veranstaltungen. +- Listeneintraege zeigen Datum, Erstellername, übersetzten Veranstaltungstyp und optional ein Status-Badge. +- Button `Neue Veranstaltung anlegen`, der nach `/shows/new` führt. +- Hinweiszeile bei aktiven Filtern mit Anzahl der angezeigten Veranstaltungen und Aktion `Filter zurücksetzen`. + +## Aktionen + +- Veranstaltung öffnen: Klick auf einen Listeneintrag navigiert relativ zu `show.id`, also nach `/shows/:showId`. +- Neue Veranstaltung anlegen: nur über den Button in `Meine Veranstaltungen`. +- Filter ändern: Zeitraum, Ersteller, Veranstaltungstyp und Archiv-Anzeige werden direkt im `FilterStoreService` aktualisiert. +- Filter zurücksetzen: stellt den Standardfilter wieder her. + +## Statuslogik + +Der Standardfilter ist: + +- Zeitraum: letzter Monat +- Ersteller: alle +- Veranstaltungstyp: alle +- Archiviert: aus + +Öffentliche Veranstaltungen werden absteigend nach Datum sortiert und zusätzlich nach Ersteller und Veranstaltungstyp gefiltert. Der Zeitraum wird in 30-Tage-Monaten berechnet; `alle` nutzt den Wert `99999`. + +Eigene Veranstaltungen erscheinen in `Meine Veranstaltungen`, wenn sie dem aktuellen Benutzer gehören und eine der folgenden Bedingungen erfüllen: + +- nicht veröffentlicht +- `reportedType === 'pending'` +- archiviert und der Archiv-Filter ist aktiv + +Status-Badges in `Meine Veranstaltungen`: + +- `archiviert`, wenn `show.archived` gesetzt ist +- `nicht gemeldet`, wenn die Show veröffentlicht ist +- `unveröffentlicht`, wenn die Show nicht veröffentlicht ist + +## Berechtigungen + +- Die Route selbst hat im Shows-Routing keinen eigenen Guard. +- Sidebar und Filter sind nur sichtbar, wenn die Rolle `admin` oder `leader` enthält. +- Der Button `Neue Veranstaltung anlegen` ist per `RoleDirective` auf `leader` beschränkt. +- Benutzer ohne Sidebar-Zugriff sehen nur die veröffentlichten Veranstaltungen ohne Filterbereich. + +## Technische Hinweise + +- `ShowService.list$()` filtert archivierte Shows grundsaetzlich aus, lässt eigene archivierte Shows aber zu, wenn `includeOwnArchived` aktiv ist. +- `ShowDataService.listPublicSince$()` verwendet Firestore-Constraints `published == true`, optional `date >= startTimestamp` und `orderBy('date', 'desc')`; archivierte Shows werden danach clientseitig entfernt. +- Die Seite nutzt `combineLatest`, `switchMap`, `map` und `shareReplay`-basierte Streams; die Darstellung erfolgt komplett reaktiv über `AsyncPipe`. +- Filterwerte bleiben über `FilterStoreService` erhalten und werden sowohl in der Sidebar als auch für die Listenberechnung verwendet. diff --git a/docs/pages/song-detail.md b/docs/pages/song-detail.md new file mode 100644 index 0000000..f44b0ea --- /dev/null +++ b/docs/pages/song-detail.md @@ -0,0 +1,67 @@ +# Lieddetails + +## Route + +`/songs/:songId` + +Die Detailseite ist ein Child-Pfad des Songs-Moduls. Der übergeordnete `/songs`-Eintrag im App-Router verlangt Authentifizierung und die Rolle `user`. Die Detailroute selbst definiert keinen zusätzlichen `canActivate`-Guard. + +## Zweck + +Die Detailseite ist die primäre Leseseite für einen einzelnen Song. Sie zeigt Stammdaten, Liedtext, Akkorddarstellung, Kommentare, Attribute, Anhänge und nutzerbezogene Verwendungsinformationen. Außerdem bietet sie rollenabhängige Aktionen zum Bearbeiten, Löschen und zum Hinzufügen des Songs zu einer eigenen unveröffentlichten Veranstaltung. + +## Datenquellen + +- `SongService.read$(songId)` liest den Song aus der Collection `songs`. +- `FileDataService.read$(songId)` liest die Subcollection `songs/{songId}/files`. +- `UserService.user$` liefert den angemeldeten Benutzer, dessen bevorzugter `chordMode` für die Liedtextanzeige genutzt wird. +- `UserService.user$` liefert außerdem `songUsage`, aus dem die nutzerbezogene Verwendungsanzahl des Songs bestimmt wird. +- `ShowService.list$()` liefert Shows, um eigene Shows des Benutzers zu finden und unveröffentlichte Veranstaltungen für die Aktion `Zu Veranstaltung hinzufügen` anzubieten. +- `ShowSongService.new$()` erstellt beim Hinzufügen zu einer Show den Show-Song-Eintrag. + +## Wichtige UI-Elemente + +Die Seite verwendet `app-page-frame` ohne Menü. Im Content-Bereich liegt eine Detail-Card mit der Überschrift aus Liednummer und Titel sowie einem Zurück-Link zur Liste. + +Für berechtigte Rollen werden Stammdaten angezeigt: + +- Typ +- Tonart +- Tempo +- Status +- Rechteinhaber und Rechteinhaber-ID +- CCLI-Link, wenn `legalOwner === 'CCLI'` und eine `legalOwnerId` vorhanden ist +- Künstler +- Verlag +- Quelle +- Verwendungsanzahl mit Tooltip + +Der Liedtext wird über `app-song-text` gerendert. Die Komponente erhält den Songtext, den Chord-Modus des Benutzers und `validateChordNotation=true`. Wenn `showSwitch` aktiv ist, kann die Akkordanzeige zwischen Ausblenden, nur erste Strophe und Anzeigen wechseln. + +Attribute aus `song.flags` werden als Chips dargestellt. Der Kommentar wird als eigener Textblock angezeigt. Anhänge erscheinen in einer separaten Card `Anhänge`; jeder Anhang löst seine Firebase-Storage-Download-URL auf und wird als externer Link geöffnet. + +## Aktionen + +- `Bearbeiten`: navigiert nach `/songs/:songId/edit`. +- `Löschen`: löscht den Song über `SongService.delete(songId)` und navigiert anschließend zurück nach `/songs`. +- `Zu Veranstaltung hinzufügen`: erstellt einen Show-Song-Eintrag, hängt dessen ID an die Reihenfolge (`order`) der gewählten Show an und navigiert zur Show unter `/shows/:showId`. +- Akkordschalter im Songtext: wechselt den lokalen Chord-Modus der Anzeige. + +## Berechtigungen + +Der Seitenzugriff erfordert über die Parent-Route die Rolle `user`. Innerhalb der Seite gelten zusätzliche Rollen: + +- `leader` und `contributor`: sehen Metadaten, Attribute, Kommentar und Verwendungsinformationen. +- `contributor`: sieht die Aktion `Bearbeiten`. +- `leader`: sieht `Zu Veranstaltung hinzufügen`, sofern unveröffentlichte Shows vorhanden sind. +- `admin`: sieht die Aktion `Löschen`. + +## Relevante technische Hinweise + +Die Song-ID wird aus den Routenparametern gelesen und in mehreren Observables verwendet. `song$`, `files$`, `songCount$`, `songUsageShows$` und `songUsageTooltip$` reagieren dadurch auf Parameteränderungen. + +Die Verwendungsanzeige kombiniert zwei Quellen: den Zähler `user.songUsage[song.id]` und eine aus Shows berechnete Liste eigener Shows, deren `songIds` den Song enthalten. Der Tooltip zeigt entweder einen Leerzustand, einen Hinweis auf noch nicht indexierte Show-Zuordnungen oder eine datierte Liste der gefundenen Shows. + +Anhänge sind Metadaten in Firestore und Binärdaten in Firebase Storage. Die Detailseite kann Anhänge nur öffnen; Upload und Löschen werden auf der Bearbeitungsseite erledigt. + +Das Löschen fragt im aktuellen Komponentenstand keine Bestätigung ab. Dokumentations- und UI-Texte sollten deshalb deutlich machen, dass die Aktion direkt über den Service ausgeführt wird. diff --git a/docs/pages/song-edit.md b/docs/pages/song-edit.md new file mode 100644 index 0000000..812ea63 --- /dev/null +++ b/docs/pages/song-edit.md @@ -0,0 +1,83 @@ +# Lied bearbeiten + +## Route + +`/songs/:songId/edit` + +Die Route ist im Songs-Modul als `path: ':songId/edit'` definiert. Der übergeordnete `/songs`-Eintrag im App-Router verlangt Authentifizierung und die Rolle `user`. Die Edit-Route selbst definiert keinen zusätzlichen `canActivate`-Guard, verwendet aber `EditSongGuard` als `canDeactivate`-Guard. + +## Zweck + +Die Bearbeitungsseite bündelt die Pflege eines Songs. Sie erlaubt das Bearbeiten von Inhalt, musikalischen Angaben, rechtlichen Metadaten und Attributen, verwaltet Anhänge und zeigt die letzte Änderungshistorie. Sie ist die Anschlussseite nach dem Anlegen eines neuen Songs und die zentrale Stelle für spätere Songpflege. + +## Aufbau + +`EditComponent` ist eine Container-Komponente innerhalb eines `app-page-frame` ohne Menü. Sie rendert drei Teilbereiche: + +- `EditSongComponent`: Formular für Songtext, Stammdaten und Rechtsinformationen. +- `EditFileComponent`: Upload und Verwaltung angehängter Dateien. +- `HistoryComponent`: Anzeige der letzten gespeicherten Änderungen. + +Der Container hält über `ViewChild` eine Referenz auf `EditSongComponent`, damit der `EditSongGuard` beim Verlassen der Route ungespeicherte Formularänderungen prüfen kann. + +## Datenquellen + +- `SongService.read$(songId)` lädt den Song für Formular und Historie. +- `EditService.createSongForm(song)` erzeugt das reaktive Formular aus dem geladenen Song. +- `SongService.update$(songId, data)` speichert Änderungen und ergänzt einen Eintrag in `song.edits`. +- `UserService.currentUser()` liefert beim Speichern den Namen des aktuellen Benutzers für die Änderungshistorie. +- `FileDataService.read$(songId)` liest vorhandene Anhänge aus `songs/{songId}/files`. +- `UploadService` schreibt neue Dateien nach Firebase Storage unter `/attachments/{songId}` und speichert die Metadaten anschließend in Firestore. +- `FileService` löst Download-URLs auf und löscht Anhänge aus Storage sowie aus der Firestore-Subcollection. + +## Wichtige UI-Elemente + +Der Song-Editor zeigt eine Card mit der Überschrift `{Nummer} bearbeiten` und einem Zurück-Link zur Detailseite. Das Formular enthält: + +- Titel +- Typ +- Tonart +- Tempo +- Status +- Songtext +- Kommentar +- Attribute als Chips +- rechtlicher Status +- Rechteinhaber +- Rechteinhaber-ID mit CCLI-Link, wenn der Rechteinhaber CCLI ist +- Künstler +- Verlag / Copyright +- Nutzungsbedingungen +- abweichende Quelle + +Während das Songtextfeld fokussiert ist, zeigt die Seite eine Vorschau über `app-song-text` sowie Bearbeitungshinweise zum Aufbau von Strophen, Refrain, Bridge und Akkordzeilen. Akkordvalidierungsfehler werden unter `Akkordschreibweise korrigieren` mit Zeile, Meldung, betroffenem Token und optionalem Vorschlag angezeigt. + +Der Dateibereich zeigt eine Upload-Auswahl, einen Upload-Button, während des Uploads einen Fortschrittsbalken und die vorhandenen Anhänge. Jeder Anhang kann geöffnet und über ein Papierkorb-Symbol gelöscht werden. + +Die Historie zeigt vorhandene `song.edits` mit Benutzername und Datum. + +## Aktionen + +- `Speichern`: validiert das Formular, speichert die Rohwerte über `SongService.update$()`, markiert das Formular als unverändert und navigiert nach `/songs/:songId`. +- Attribut hinzufügen: Eingabe im Chip-Feld wird bei Enter, Komma oder Blur an die semikolongetrennte `flags`-Liste angehängt. +- Attribut entfernen: entfernt den Chip und schreibt die verbleibenden Attribute zurück in `flags`. +- Datei auswählen: übernimmt die aktuelle Dateiauswahl aus dem File-Input. +- Datei hochladen: lädt die erste ausgewählte Datei nach Firebase Storage und speichert danach die Dateimetadaten. +- Datei löschen: entfernt die Datei aus Firebase Storage und löscht den Firestore-Metadatensatz. +- Seite verlassen mit ungespeicherten Änderungen: öffnet einen Speicherdialog; bei Bestätigung wird vor der Navigation gespeichert. + +## Berechtigungen + +Der Zugriff auf das Songs-Modul erfordert Authentifizierung und die Rolle `user`. Die Edit-Route selbst erzwingt in `songs-routing.module.ts` keine `contributor`-Rolle. Der Einstieg aus der Detailseite ist allerdings nur für `contributor` sichtbar, weil der Button `Bearbeiten` rollenabhängig gerendert wird. + +Für die Dokumentation ist deshalb wichtig: Die UI versteckt den regulären Einstieg für Nicht-Contributors, die Route selbst enthält aber keinen zusätzlichen Aktivierungs-Guard. Falls direkte URL-Aufrufe ebenfalls verhindert werden sollen, müsste die Route analog zu `/songs/new` mit einem `RoleGuard` erweitert werden. + +## Relevante technische Hinweise + +Die Akkordvalidierung wird bei jeder Änderung des Songtextes aktualisiert. `TextRenderingService.validateChordNotation()` erkennt unter anderem alternative Schreibweisen wie `is/es`, falsche Dur/Moll-Großschreibung, nicht normalisierte Suffixe, unbekannte Akkordtokens und Tabulatoren in Akkordzeilen. Validierungsfehler werden als Formularfehler `chordNotation` am Text-Control gesetzt; dadurch ist der Speichern-Button deaktiviert, solange der Text ungültig ist. + +`SongService.update$()` liest vor dem Speichern den aktuellen Song, hängt einen neuen Historieneintrag mit Benutzername und `Timestamp.now()` an und schreibt anschließend die Änderungen. Dadurch wird die Historie nur bei Speichervorgängen über diesen Service erweitert. + +Der Upload-Service ignoriert Upload-Fehler im aktuellen Stand bewusst im Error-Callback. Die UI zeigt Fortschritt und erfolgreiche Metadaten danach über die Dateiliste, aber keine eigene Fehlermeldung. + +Der `EditSongGuard` schützt nur vor Navigation aus dem Angular-Router heraus. Er fragt `EditSongComponent.askForSave(nextState)` ab und navigiert nach dem Dialog selbst weiter. Bei nicht dirty Formularen wird die Navigation direkt erlaubt. diff --git a/docs/pages/song-new.md b/docs/pages/song-new.md new file mode 100644 index 0000000..4947b96 --- /dev/null +++ b/docs/pages/song-new.md @@ -0,0 +1,51 @@ +# Lied anlegen + +## Route + +`/songs/new` + +Die Route ist im Songs-Modul als `path: 'new'` definiert. Sie verwendet zusätzlich zum übergeordneten `/songs`-Schutz einen `RoleGuard` mit `requiredRoles: ['contributor']`. + +## Zweck + +Die Seite legt einen neuen Song mit minimalen Pflichtdaten an. Sie erfasst nur Liednummer und Titel, erstellt daraus einen Firestore-Datensatz und leitet den Benutzer anschließend direkt auf die Bearbeitungsseite weiter, damit Text, Metadaten, Rechteinformationen und Anhänge ergänzt werden können. + +## Datenquellen + +- `SongService.list$()` liefert die vorhandenen Songs. +- `NewComponent.getFreeSongNumber()` ermittelt aus den vorhandenen Liednummern die erste freie positive Nummer. +- `SongService.new(songNumber, title)` erstellt den neuen Song. +- `SongDataService.add()` schreibt den Datensatz in die Collection `songs`. + +Beim Erstellen setzt `SongService.new()` zusätzlich Standardwerte: + +- `status: 'draft'` +- `legalType: 'open'` + +## Wichtige UI-Elemente + +Die Seite verwendet `app-page-frame` ohne Menü und eine Card mit der Überschrift `Neues Lied`. Die Card besitzt einen Zurück-Link zur Liedliste. + +Das Formular besteht aus zwei Feldern: + +- `Nummer`: numerische Liednummer, Pflichtfeld +- `Titel`: Songtitel, Pflichtfeld + +Beim Initialisieren wird das Formular zurückgesetzt. Danach wird aus der Songliste automatisch die erste freie Liednummer eingetragen. Der Titel bleibt leer und muss vom Benutzer ausgefüllt werden. + +## Aktionen + +- `Anlegen`: liest die Formularwerte, erstellt den Song und navigiert nach `/songs/{newSongId}/edit`. +- Zurück-Link der Card: führt zurück zur Liedliste. + +Wenn keine Nummer vorhanden ist, bricht `onSave()` ab. Eine explizite Prüfung auf doppelte Nummern findet in dieser Komponente nicht statt; die automatische Vorbelegung soll Kollisionen im normalen Ablauf vermeiden. + +## Berechtigungen + +Der Zugriff auf das Songs-Modul erfordert Authentifizierung und die Rolle `user`. Diese konkrete Route verlangt zusätzlich die Rolle `contributor`. Benutzer ohne diese Rolle sollen nicht auf die Anlegeseite gelangen. + +## Relevante technische Hinweise + +Das Formular ist ein reaktives Angular-Formular mit `FormGroup` und `Validators.required` für beide Felder. Die Komponente nutzt `take(1)` und `takeUntilDestroyed()`, um die vorhandene Songliste einmalig auszuwerten und die Subscription sauber zu beenden. + +Die neue Song-ID kommt von Firestore. Nach erfolgreichem Anlegen wird nicht die Detailseite geöffnet, sondern bewusst die Bearbeitungsroute. Dadurch bleibt der Anlegeprozess kurz und die vollständige Pflege des Songs findet im Editor statt. diff --git a/docs/pages/songs-list.md b/docs/pages/songs-list.md new file mode 100644 index 0000000..232babe --- /dev/null +++ b/docs/pages/songs-list.md @@ -0,0 +1,65 @@ +# Liedliste + +## Route + +`/songs` + +Die Route liegt im Songs-Modul als leerer Child-Pfad (`path: ''`). Der übergeordnete App-Router lädt das Modul unter `/songs`, schützt es mit `AuthGuard` und `RoleGuard` und verlangt die Rolle `user`. Vor dem Anzeigen der Seite lädt `SongListResolver` einmalig die vollständig geladene Songliste. + +## Zweck + +Die Liedliste ist der zentrale Einstieg in die Songdatenbank. Sie zeigt alle Songs nach Liednummer sortiert, ermöglicht das schnelle Auffinden über Suche und Filter und macht wichtige Pflegehinweise direkt in der Liste sichtbar. Von hier aus wechseln Benutzer in die Detailseite eines Songs oder, mit entsprechender Berechtigung, in den Anlegeprozess. + +## Datenquellen + +- `SongListResolver` nutzt `SongService.listLoaded$()` und wartet mit `take(1)` auf die erste geladene Liste aus Firestore. +- `SongService` delegiert die Datenzugriffe an `SongDataService`, das die Collection `songs` über `DbService.col$('songs')` liest und per `shareReplay` cacht. +- Die aktuellen Filterwerte kommen aus `FilterStoreService.songFilter$`. +- Die Textsuche läuft über `searchSongs`; zusätzliche Filter werden in `SongListComponent.filter()` geprüft. +- `TextRenderingService.validateChordNotation()` validiert den Songtext jedes sichtbaren Listeneintrags auf Akkordschreibweisen. + +## Wichtige UI-Elemente + +Die Seite verwendet `app-page-frame` mit dem Titel `Lieder`. Im Sidebar-Bereich befindet sich `app-filter`; der Hauptbereich enthält eine Liste in einer Card. + +Jeder Listeneintrag zeigt: + +- Liednummer +- Titel +- Status- und Warnsymbole +- Tonart + +Wenn ein Filter aktiv ist, erscheint oberhalb der Liste ein Hinweis mit der Anzahl gefundener Lieder und der Aktion `Filter zurücksetzen`. Zusätzlich setzt `menuBadge` am Page-Frame ein optisches Signal, dass die Liste gefiltert ist. + +Die Filterkomponente bietet: + +- Freitextsuche nach Titel oder Text +- Filter nach Songtyp (`Praise`, `Worship`, `Misc`) +- Tonartfilter nach Grundton, Vorzeichen und Dur/Moll +- Option `Parallele Tonart einschließen` +- Filter nach rechtlichem Status +- Filter nach Attributen aus den im Bestand vorhandenen `flags` + +Nicht passende Tonart-Grundtöne werden deaktiviert, wenn im aktuellen Songbestand keine passende Tonart existiert. + +## Aktionen + +- Klick auf einen Listeneintrag navigiert relativ zur Song-ID, also auf `/songs/:songId`. +- `Filter zurücksetzen` leert die gespeicherten Songfilter im `FilterStoreService`. +- `Neuen Song anlegen` navigiert auf `/songs/new`. + +## Berechtigungen + +Der Zugriff auf das Songs-Modul erfordert Authentifizierung und die Rolle `user`. Innerhalb der Liedliste sind zusätzliche Informationen rollenabhängig: + +- `contributor`: sieht Statusindikatoren für `draft`, `set` und `final`. +- `contributor`: sieht den Button `Neuen Song anlegen`. +- Rechtliche Warnungen für Songs mit `legalType === 'open'` werden unabhängig vom Contributor-Status am Eintrag angezeigt. + +## Relevante technische Hinweise + +Die Liste sortiert Songs clientseitig nach `number`. Der Resolver verwendet die geladene Songliste ohne `startWith([])`, damit die Route erst nach der ersten echten Firestore-Antwort angezeigt wird. Die spätere Filterung kombiniert `combineLatest` aus Filterstore und Routendaten. + +Die Akkordvalidierung wird pro gefiltertem Song ausgeführt und markiert betroffene Titel mit einem Stern. Die Validierung verändert keine Daten; sie dient nur als Hinweis für Pflegebedarf. + +Der Tonartfilter basiert auf `matchesKeyFilter()` aus `key.helper.ts`. Er unterstützt Dur/Moll, `#`/`b`-Varianten und optional parallele Tonarten. Die Filterwerte bleiben im zentralen Filterstore erhalten und werden beim erneuten Öffnen der Seite wieder in das Formular übernommen. diff --git a/docs/pages/user-info.md b/docs/pages/user-info.md new file mode 100644 index 0000000..aa18bbf --- /dev/null +++ b/docs/pages/user-info.md @@ -0,0 +1,39 @@ +# Benutzerprofil + +## Route + +`/user/info` + +## Zweck + +Die Seite zeigt das Profil des angemeldeten Benutzers, dessen Rollen und persönliche Anzeigeeinstellungen. Administratoren sehen zusätzlich die Benutzerverwaltung. + +## Datenquellen + +- `InfoComponent` liest den aktuellen Benutzer über `UserService.user$`. +- Änderungen an Benutzerdaten werden über `UserService.update$(uid, data)` in `users/{uid}` gespeichert. +- Die Admin-Liste verwendet `UsersComponent`, `UserComponent` und `UserService.list$()` für alle Benutzer. + +## UI + +Im Profilbereich werden Begrüßung, Rollenanzeige und die bevorzugte Akkordanzeige dargestellt. Die Akkordanzeige ist ein Auswahlfeld mit den Werten leer, `hide`, `onlyFirst` und `show`. + +Für Administratoren erscheint zusätzlich eine Karte `registrierte Benutzer`. Jeder Listeneintrag kann angeklickt werden und wechselt dann in einen Bearbeitungsmodus mit Namensfeld und Mehrfachauswahl für Rollen. + +## Aktionen + +- Akkordmodus ändern: speichert `chordMode` direkt am aktuellen Benutzer. +- Abmelden: navigiert nach `../logout`. +- Benutzer bearbeiten: Administratoren können Namen und Rollen einzelner Benutzer ändern. +- Bearbeitung schließen: beendet den Bearbeitungsmodus des Benutzerlisteneintrags. + +## Rollen und Berechtigungen + +Die Route ist durch `AuthGuard` geschützt und setzt einen angemeldeten Benutzer voraus. Die Benutzerverwaltung wird über `*appRole="['admin']"` nur für Administratoren angezeigt. In `RoleDirective` gilt `admin` als Vollberechtigung; andere Rollen werden gegen die angeforderte Rollenliste geprüft. + +## Technische Hinweise + +- Rollen werden als semikolongetrennter String im Feld `role` gespeichert und für die UI in Arrays umgewandelt. +- Verfügbare Rollen kommen aus `ROLE_TYPES`: `admin`, `user`, `member`, `leader`, `presenter`, `contributor`. +- Die Rollenanzeige nutzt `RolePipe`; bei fehlenden Rollen erscheint ein Warnhinweis. +- Die Methode `transdormUserRoles` enthält einen Schreibfehler im Namen, ist aber die aktuell verwendete UI-Hilfsmethode. diff --git a/docs/pages/user-login.md b/docs/pages/user-login.md new file mode 100644 index 0000000..2aaee68 --- /dev/null +++ b/docs/pages/user-login.md @@ -0,0 +1,36 @@ +# Login + +## Route + +`/user/login` + +## Zweck + +Die Seite meldet bestehende Benutzer mit E-Mail-Adresse und Passwort an. Nach erfolgreicher Anmeldung wird der Benutzer zur Startseite weitergeleitet. + +## Datenquellen + +- `LoginComponent` verwaltet ein reaktives Formular mit den Feldern `user` und `pass`. +- `UserService.login(user, password)` delegiert an `UserSessionService.login`. +- `UserSessionService` verwendet Firebase Auth (`signInWithEmailAndPassword`) und lädt danach den zugehörigen Datensatz aus `users/{uid}`. + +## UI + +Die Ansicht zeigt das Anwendungslogo, zwei Eingabefelder und drei vollbreite Aktionsbuttons. Fehlercodes aus Firebase Auth werden über `AuthMessagePipe` in deutsche Meldungen übersetzt. + +## Aktionen + +- `Anmelden`: validiert das Formular, führt den Login aus, initialisiert bei Bedarf `songUsage` und navigiert bei Erfolg nach `/`. +- `Passwort zurücksetzen`: navigiert nach `/user/password`. +- `neuen Benutzer anlegen`: navigiert nach `/user/new`. +- `Enter` in einem Eingabefeld löst ebenfalls den Login aus. + +## Rollen und Berechtigungen + +Die Login-Seite ist öffentlich erreichbar. Die spätere Nutzbarkeit geschützter Bereiche hängt vom geladenen Benutzerdokument und dessen Rollen ab. + +## Technische Hinweise + +- Das Formular verlangt eine gültige E-Mail-Adresse und ein Passwort. +- Wenn Firebase Auth erfolgreich ist, aber kein passender Firestore-Benutzer existiert, liefert der Login keine Benutzer-ID zurück. +- Bekannte Fehlercodes wie `auth/user-not-found`, `auth/wrong-password` und `auth/invalid-email` werden lokalisiert angezeigt. diff --git a/docs/pages/user-logout.md b/docs/pages/user-logout.md new file mode 100644 index 0000000..700f374 --- /dev/null +++ b/docs/pages/user-logout.md @@ -0,0 +1,34 @@ +# Abmelden + +## Route + +`/user/logout` + +## Zweck + +Die Seite beendet die aktuelle Benutzersitzung und leitet danach zur Startseite weiter. + +## Datenquellen + +- `LogoutComponent` nutzt `UserService.logout()`. +- `UserService.logout()` delegiert an `UserSessionService.logout`. +- `UserSessionService` ruft Firebase Auth `signOut` auf. + +## UI + +Die Komponente hat aktuell kein sichtbares Template. Sie dient als technische Navigationsroute für den Logout-Vorgang. + +## Aktionen + +- Nach Initialisierung der View wird der Benutzer abgemeldet. +- Nach erfolgreichem Logout navigiert die Komponente nach `/`. + +## Rollen und Berechtigungen + +Die Route ist nicht durch einen Guard geschützt. Ist kein Benutzer angemeldet, läuft der Logout-Aufruf trotzdem über Firebase Auth und die anschließende Weiterleitung bleibt gleich. + +## Technische Hinweise + +- Der Logout wird in `ngAfterViewInit` gestartet. +- Der asynchrone Ablauf wird bewusst ohne sichtbaren Zwischenzustand ausgeführt. +- Fehlerbehandlung oder Fehlermeldungen sind in der Komponente nicht implementiert. diff --git a/docs/pages/user-new.md b/docs/pages/user-new.md new file mode 100644 index 0000000..1bc90f9 --- /dev/null +++ b/docs/pages/user-new.md @@ -0,0 +1,34 @@ +# Benutzer anlegen + +## Route + +`/user/new` + +## Zweck + +Die Seite erstellt einen neuen Benutzeraccount. Sie ist für die Selbstregistrierung gedacht und vergibt noch keine fachlichen Rollen. + +## Datenquellen + +- `NewComponent` verwaltet ein reaktives Formular mit `email`, `name` und `password`. +- `UserService.createNewUser(email, name, password)` delegiert an `UserSessionService.createNewUser`. +- `UserSessionService` erstellt den Firebase-Auth-Benutzer und legt anschließend `users/{uid}` in Firestore an. + +## UI + +Die Ansicht besteht aus einer Karte mit den Feldern Name, E-Mail-Adresse und Passwort sowie einem Button `Benutzer anlegen`. Fehlercodes werden über `AuthMessagePipe` angezeigt. + +## Aktionen + +- `Benutzer anlegen`: validiert das Formular, erstellt den Auth-Account, schreibt das Firestore-Benutzerdokument und navigiert danach zu `/brand/new-user`. +- Schließen über `closeLink="../"`: führt zurück zur übergeordneten Benutzerroute. + +## Rollen und Berechtigungen + +Die Seite ist öffentlich erreichbar. Neue Benutzer erhalten initial keine Rolle. Das angelegte Dokument enthält `name`, `chordMode: 'onlyFirst'` und `songUsage: {}`; ein Administrator muss später passende Rollen vergeben. + +## Technische Hinweise + +- Das Passwort muss mindestens sechs Zeichen lang sein. +- Firebase-Fehler wie `auth/email-already-in-use`, `auth/invalid-email` und `auth/weak-password` werden in deutsche Meldungen übersetzt. +- Nach der Registrierung ist der Benutzer durch Firebase Auth angemeldet, befindet sich aber ohne Rollen im Freischaltungszustand. diff --git a/docs/pages/user-password-send.md b/docs/pages/user-password-send.md new file mode 100644 index 0000000..aec6e4c --- /dev/null +++ b/docs/pages/user-password-send.md @@ -0,0 +1,30 @@ +# Passwort-Mail gesendet + +## Route + +`/user/password-send` + +## Zweck + +Die Seite bestätigt, dass eine E-Mail zum Setzen eines neuen Passworts gesendet wurde. + +## Datenquellen + +Die Seite lädt keine eigenen Daten. `PasswordSendComponent` rendert ausschließlich statischen Inhalt. + +## UI + +Die Ansicht besteht aus einer Karte mit dem Hinweis, dass die E-Mail gesendet wurde und einen Link zur Eingabe des neuen Passworts enthält. + +## Aktionen + +Die Seite bietet keine eigene Aktion. Die fachliche Aktion findet vorher auf `/user/password` statt. + +## Rollen und Berechtigungen + +Die Seite ist öffentlich erreichbar. Eine aktive Anmeldung oder Rolle ist nicht erforderlich. + +## Technische Hinweise + +- Es findet keine erneute Prüfung statt, ob die Reset-Mail tatsächlich zugestellt wurde. +- Die Route dient nur als Erfolgsziel nach `UserService.changePassword`. diff --git a/docs/pages/user-password.md b/docs/pages/user-password.md new file mode 100644 index 0000000..bbeff5a --- /dev/null +++ b/docs/pages/user-password.md @@ -0,0 +1,35 @@ +# Passwort zurücksetzen + +## Route + +`/user/password` + +## Zweck + +Die Seite fordert für eine E-Mail-Adresse eine Passwort-Zurücksetzung an. + +## Datenquellen + +- `PasswordComponent` verwaltet ein reaktives Formular mit dem Feld `user`. +- `UserService.changePassword(user)` delegiert an `UserSessionService.changePassword`. +- `UserSessionService` ruft Firebase Auth `sendPasswordResetEmail` mit `environment.url` als Rücksprung-URL auf. + +## UI + +Die Ansicht zeigt eine Karte `Passwort zurücksetzen`, ein E-Mail-Feld und den Button `neues Passwort anfordern`. Fehlercodes werden innerhalb der Button-Zeile angezeigt. + +## Aktionen + +- `neues Passwort anfordern`: validiert die E-Mail-Adresse, sendet die Reset-Mail und navigiert bei Erfolg nach `/user/password-send`. +- `Enter` im Eingabefeld löst dieselbe Aktion aus. +- Schließen über `closeLink="../"`: führt zurück zur übergeordneten Benutzerroute. + +## Rollen und Berechtigungen + +Die Seite ist öffentlich erreichbar. Eine aktive Anmeldung oder Rolle ist nicht erforderlich. + +## Technische Hinweise + +- Das Formular verlangt eine gültige E-Mail-Adresse. +- Firebase Auth entscheidet, ob die Adresse bekannt ist und ob eine Reset-Mail gesendet werden kann. +- Fehlercodes werden mit `AuthMessagePipe` lokalisiert; unbekannte Fehler werden als `Unbekannter Fehler` angezeigt. diff --git a/docs/roles-and-permissions.md b/docs/roles-and-permissions.md new file mode 100644 index 0000000..06b725b --- /dev/null +++ b/docs/roles-and-permissions.md @@ -0,0 +1,69 @@ +# Rollen und Berechtigungen + +## Rollenmodell + +Die Anwendung definiert Rollen in `src/app/services/user/roles.ts`: + +- `admin` +- `user` +- `member` +- `leader` +- `presenter` +- `contributor` +- `none` + +Ein Benutzerprofil liegt in Firestore unter `users/{uid}`. Das Feld `role` enthält eine oder mehrere Rollen als Semikolon-getrennte Zeichenkette, zum Beispiel `leader;presenter`. Neue Benutzer werden mit Name, Akkordmodus und leerem `songUsage` angelegt; Rollen werden anschließend über die Benutzerverwaltung vergeben. + +## Authentifizierung + +Firebase Auth verwaltet die Anmeldung. `UserSessionService` beobachtet `authState`, liest das zugehörige Benutzerprofil aus `users/{uid}` und stellt daraus `user$`, `userId$`, `loggedIn$` und Benutzerlisten bereit. + +Beim Login initialisiert der Service fehlende `songUsage`-Daten mit einem leeren Objekt. Passwort-Reset-Mails werden über Firebase Auth mit der in `environment.url` konfigurierten Rücksprung-URL versendet. + +## Routenberechtigungen + +`AuthGuard` leitet nicht angemeldete Benutzer nach `/user/login` um. `RoleGuard` prüft die in der Route definierten `requiredRoles`; Benutzer mit `admin` werden immer zugelassen. + +Die Hauptrouten sind wie folgt geschützt: + +- `/songs`: Login und Rolle `user`. +- `/shows`: Login und Rolle `leader` oder `member`. +- `/presentation`: Login und Rolle `presenter`. +- `/user/info`: Login. +- `/user/login`, `/user/new`, `/user/password` und `/user/password-send`: öffentlich. +- `/brand`: öffentlich. +- `/guest`: öffentlich. + +Zusätzliche Modulrechte: + +- `/songs/new`: Rolle `contributor`. +- `/shows/new`: Rolle `leader`. + +Wenn ein Benutzer keine passende Rolle besitzt, leitet `RoleGuard` auf eine rollenabhängige Standardroute um. Benutzer ohne Rollen landen auf `/brand/new-user`. + +## Template- und Aktionsrechte + +`RoleDirective` (`*appRole`) blendet UI-Elemente anhand der Benutzerrollen ein oder aus. `admin` erhält auch hier umfassenden Zugriff. Die Rollenprüfung wertet die Semikolon-getrennte Rollenliste aus. + +`OwnerDirective` (`*appOwner`) begrenzt Aktionen auf Besitzer fachlicher Objekte, insbesondere bei Shows. Dadurch kann die Oberfläche zwischen eigenen und fremden Shows unterscheiden. + +Diese Direktiven steuern die sichtbaren Aktionen in der Oberfläche. Fachliche Services prüfen zusätzlich einzelne Voraussetzungen, zum Beispiel ob ein aktueller Benutzer vorhanden ist. + +## Firestore-Regeln + +Die serverseitigen Regeln in `firestore.rules` sind bewusst grob: + +- `users/{uid}`: Benutzer dürfen ihr eigenes Dokument erstellen und schreiben; Admins dürfen Benutzer schreiben und listen; angemeldete Benutzer dürfen Benutzerdaten lesen. +- `guest/{guestId}`: Lesen ist öffentlich, Schreiben benötigt Login. +- `songs`, `songs/{song}/files`, `shows`, `shows/{show}/songs` und `global`: Lesen und Schreiben benötigt Login. + +Die Regeln unterscheiden bei den fachlichen Collections nicht nach Rollen. Rollenbasierte Zugriffskontrolle findet daher primär in Angular-Routing, Direktiven und Services statt. + +## Administrative Funktionen + +Einige Wartungsfunktionen verlangen in den Services explizit die Rolle `admin`: + +- `UserSongUsageService.rebuildSongUsage()` baut `users/{uid}.songUsage` aus allen nicht archivierten Shows neu auf. +- `ShowSongIndexService.rebuildShowSongIds()` schreibt den `songIds`-Index aller Shows neu. + +Beide Funktionen sind für manuelle Migrationen vorgesehen und werden im README über `window.wgeneratorAdmin` beschrieben. diff --git a/docs/technical-architecture.md b/docs/technical-architecture.md new file mode 100644 index 0000000..17ba234 --- /dev/null +++ b/docs/technical-architecture.md @@ -0,0 +1,90 @@ +# Technische Architektur + +## Überblick + +Wgenerator ist eine Angular-Anwendung mit Firebase als Backend. Die App wird als Single Page Application gebaut und über Firebase Hosting ausgeliefert. Authentifizierung, Firestore und Storage werden über `@angular/fire` eingebunden. + +Der Anwendungseinstieg liegt in `src/main.ts`; die fachlichen Bereiche werden über `src/app/app-routing.module.ts` lazy geladen. Der Standardpfad `/` leitet nach `/songs` weiter. + +## Frontend-Struktur + +Der fachliche Code liegt unter `src/app/modules`: + +- `songs`: Liedliste, Lieddetails, Bearbeitung, Anhänge, Textdarstellung, Tonarten und Transposition. +- `shows`: Veranstaltungslisten, Show-Details, Bearbeitung, Song-Zuordnung, Archivierung, Veröffentlichung, Gastfreigaben und DOCX-Export. +- `presentation`: Auswahl, Fernsteuerung und Monitoransicht für Live-Präsentationen. +- `user`: Login, Logout, Registrierung, Passwort-Reset und Benutzerinformationen. +- `brand`: Start- und Hinweisbereich für neue oder noch nicht berechtigte Benutzer. +- `guest`: öffentliche Gastansicht für freigegebene Shows. + +Gemeinsame Services liegen in `src/app/services`. Wiederverwendbare UI-Bausteine, Pipes, Guards und Direktiven liegen in `src/app/widget-modules`. + +## Routing und Modulgrenzen + +Die Hauptrouten sind: + +- `/songs`: `SongsModule`, mit Authentifizierung und Rolle `user`. +- `/shows`: `ShowsModule`, mit Authentifizierung und Rolle `leader` oder `member`. +- `/presentation`: `PresentationModule`, mit Authentifizierung und Rolle `presenter`. +- `/user`: `UserModule`, teilweise öffentlich und teilweise per `AuthGuard` geschützt. +- `/brand`: `BrandModule`, öffentlich. +- `/guest`: `GuestModule`, öffentlich. + +Zusätzliche Modulrouten schränken einzelne Aktionen ein. Beispielsweise benötigt `/songs/new` die Rolle `contributor` und `/shows/new` die Rolle `leader`. + +## Datenzugriff + +Der technische Firestore-Zugriff ist in `DbService` gekapselt. Der Service stellt Wrapper für Collections und Dokumente bereit: + +- `col$` und `doc$` liefern Live-Observables mit `idField`. +- `add`, `set`, `update` und `delete` kapseln Schreiboperationen. +- Query-Constraints werden bei Bedarf an `col$` übergeben. + +Fachservices bauen darauf auf: + +- `SongDataService` und `SongService` verwalten `songs`. +- `FileDataService`, `FileService` und `UploadService` verwalten Firestore-Metadaten und Firebase-Storage-Dateien zu Songs. +- `ShowDataService`, `ShowService`, `ShowSongDataService` und `ShowSongService` verwalten Shows und deren eingebettete Show-Songs. +- `GuestShowDataService` und `GuestShowService` verwalten öffentliche Gastfreigaben. +- `UserSessionService`, `UserService` und `UserSongUsageService` verwalten Authentifizierung, Benutzerprofile, Rollen und Nutzungszähler. +- `ConfigService` und `GlobalSettingsService` lesen beziehungsweise schreiben Dokumente unter `global`. + +Mehrere Datenströme werden mit `shareReplay` gecacht, um Firestore-Listener bei Navigationen wiederzuverwenden. + +## Authentifizierung und Autorisierung + +Firebase Auth liefert den Login-Status. `UserSessionService` verbindet den Auth-User mit dem Firestore-Dokument `users/{uid}`. Rollen werden im Feld `role` als Semikolon-getrennte Zeichenkette gespeichert. + +`AuthGuard` schützt Routen, die einen Firebase-Login benötigen. `RoleGuard` liest `requiredRoles` aus der Route-Data-Konfiguration und erlaubt Zugriff, wenn der Benutzer mindestens eine passende Rolle besitzt. `admin` gilt in der Anwendung als übergeordnete Rolle. + +Die Firestore-Regeln erlauben angemeldeten Benutzern breite Lese- und Schreibzugriffe auf fachliche Collections. Deshalb sind UI-Guards und Services fachlich wichtig, ersetzen aber keine feingranulare serverseitige Autorisierung. + +## Präsentationsarchitektur + +Die Präsentation wird über Firestore synchronisiert: + +- `global/static.currentShow` enthält die aktuell ausgewählte Show. +- Das Show-Dokument enthält Präsentationsfelder wie `presentationSongId`, `presentationSection`, `presentationZoom`, `presentationBackground`, `presentationDynamicCaption` und `presentationDynamicText`. +- Die Remote-Ansicht schreibt diese Werte. +- Die Monitoransicht liest die Werte live und rendert den aktuellen Zustand. + +Damit können mehrere Browserfenster über Firestore als gemeinsamen Zustand zusammenarbeiten. + +## Firebase und Hosting + +Die Firebase-Konfiguration wird über `src/environments/firebase.ts` importiert. `environment.ts` und `environment.prod.ts` unterscheiden `production`, nutzen aber dieselbe URL `https://worshipgenerator.web.app`. + +`firebase.json` konfiguriert: + +- Firestore-Regeln aus `firestore.rules`. +- Firestore-Indexdatei `firestore.indexes.json`. +- Hosting aus `dist/wgenerator/browser`. +- SPA-Rewrite auf `/index.html`. +- Cache-Header für HTML-Routen und statische JS/CSS-Dateien. +- Emulator-Ports für Firestore, Realtime Database und Hosting. + +## Build, Tests und Qualität + +Angular nutzt den Builder `@angular/build:application`. LESS ist als Component-Style-Sprache konfiguriert; globale Styles kommen aus `src/custom-theme.scss`, `src/styles/styles.less` und `src/styles/shadow.less`. + +Unit-Tests laufen über den Angular Unit-Test-Builder mit Vitest und `src/test-vitest.ts` als Setup-Datei. Linting läuft über Angular ESLint. diff --git a/man/berechtigungen.md b/man/berechtigungen.md new file mode 100644 index 0000000..f9a4b23 --- /dev/null +++ b/man/berechtigungen.md @@ -0,0 +1,148 @@ +# Berechtigungen und Rollen + +## Zweck + +Berechtigungen steuern, welche Bereiche und Aktionen du im Worshipgenerator nutzen kannst. Sie sorgen dafür, dass jede Person nur die Funktionen sieht, die sie für ihre Aufgabe braucht. + +## Grundprinzip + +Ein Benutzerkonto kann eine oder mehrere Rollen haben. Rollen können kombiniert werden. Eine Person kann zum Beispiel Lieder pflegen, Veranstaltungen vorbereiten und Präsentationen starten, wenn sie dafür mehrere Rollen erhalten hat. + +Neue Benutzer haben zunächst keine Rollen. Ein Administrator muss ihnen die passenden Berechtigungen zuweisen. + +## Rollen in einfacher Sprache + +### Keine Berechtigung + +Diese Person hat ein Konto, ist aber noch nicht freigeschaltet. + +Typische Situation: + +- neues Konto wurde gerade angelegt +- Benutzer sieht den Hinweis, dass noch keine Berechtigungen zugeteilt wurden +- geschützte Arbeitsbereiche sind noch nicht nutzbar + +### Benutzer + +Diese Rolle erlaubt den Zugriff auf den Liederbereich. + +Typische Aktionen: + +- Liedliste öffnen +- Lieddetails ansehen +- Liedtexte und vorhandene Informationen lesen +- Lieder für die eigene Arbeit suchen + +### Mitarbeiter + +Diese Rolle ist für Personen gedacht, die Lieddaten mitpflegen. + +Typische Aktionen: + +- neue Lieder anlegen +- vorhandene Lieder bearbeiten +- ergänzende Angaben zu Liedern pflegen +- bei Lieddetails zusätzliche Bearbeitungsinformationen sehen + +### Lobpreisgruppe + +Diese Rolle ist für Teammitglieder gedacht, die Veranstaltungen sehen und mit vorbereiteten Abläufen arbeiten. + +Typische Aktionen: + +- Veranstaltungsliste öffnen +- Veranstaltungsdetails ansehen +- Lieder einer Veranstaltung nachvollziehen +- sich auf einen Einsatz vorbereiten + +### Lobpreisleiter + +Diese Rolle ist für Personen gedacht, die Veranstaltungen planen und verantworten. + +Typische Aktionen: + +- neue Veranstaltungen anlegen +- Veranstaltungen bearbeiten +- Lieder zu Veranstaltungen hinzufügen oder ordnen +- eigene Veranstaltungen verwalten +- Gastansichten für Veranstaltungen teilen +- auf leitungsbezogene Aktionen in Liedern und Veranstaltungen zugreifen + +### Präsentator + +Diese Rolle ist für Personen gedacht, die während einer Veranstaltung die Präsentation bedienen. + +Typische Aktionen: + +- Präsentationsbereich öffnen +- eine Veranstaltung für die Präsentation auswählen +- Präsentation starten +- Präsentation steuern +- Präsentationsmonitor nutzen + +### Administrator + +Diese Rolle ist für Personen gedacht, die Benutzer und Berechtigungen verwalten. + +Typische Aktionen: + +- Benutzerprofil mit Benutzerverwaltung öffnen +- registrierte Benutzer sehen +- Namen von Benutzern korrigieren +- Rollen vergeben oder entfernen +- alle rollenabhängigen Bereiche nutzen + +## Öffentliche Seiten + +Einige Seiten benötigen keine Anmeldung: + +- [Anmelden](pages/anmelden.md) +- [Benutzer anlegen](pages/benutzer-anlegen.md) +- [Passwort zurücksetzen](pages/passwort-zuruecksetzen.md) +- [Passwort-Mail gesendet](pages/passwort-mail-gesendet.md) +- [Branding](pages/branding.md) +- [Gastansicht](pages/gastansicht.md) + +Die Gastansicht ist öffentlich, aber nur über den passenden Link sinnvoll nutzbar. + +## Geschützte Bereiche + +Für diese Bereiche brauchst du eine Anmeldung und passende Rollen: + +- Lieder: Berechtigung **Benutzer** +- Lieder anlegen oder bearbeiten: Berechtigung **Mitarbeiter** +- Veranstaltungen ansehen: Berechtigung **Lobpreisleiter** oder **Lobpreisgruppe** +- Veranstaltungen anlegen: Berechtigung **Lobpreisleiter** +- Präsentation nutzen: Berechtigung **Präsentator** +- Benutzer verwalten: Berechtigung **Administrator** + +## Rollen prüfen + +Deine eigenen Rollen siehst du im [Benutzerprofil](pages/benutzerprofil.md). Dort werden sie in verständlicher Sprache angezeigt, zum Beispiel Lobpreisleiter oder Präsentator. + +Wenn du einen Bereich nicht öffnen kannst oder eine erwartete Schaltfläche fehlt, fehlt dir wahrscheinlich die passende Rolle. Wende dich dann an einen Administrator. + +## Rollen vergeben + +Nur Administratoren können Rollen vergeben. + +1. Als Administrator anmelden. +2. Das [Benutzerprofil](pages/benutzerprofil.md) öffnen. +3. Im Bereich `registrierte Benutzer` den gewünschten Benutzer auswählen. +4. Eine oder mehrere Rollen auswählen. +5. Die Bearbeitung schließen. + +## Hinweise + +- Vergib nur Rollen, die eine Person wirklich für ihre Aufgabe braucht. +- Für viele Aufgaben ist eine Kombination mehrerer Rollen sinnvoll. +- `Administrator` umfasst weitreichende Rechte und sollte sparsam vergeben werden. +- Ein neues Konto ohne Rollen ist normal und muss erst freigeschaltet werden. +- Sichtbare Menüpunkte und Aktionen können je nach Rolle unterschiedlich sein. + +## Links + +- [Benutzerprofil](pages/benutzerprofil.md) +- [Benutzer anlegen](pages/benutzer-anlegen.md) +- [Neuer Benutzer ohne Rollen](pages/neuer-benutzer-ohne-rollen.md) +- [Gastansicht](pages/gastansicht.md) diff --git a/man/index.md b/man/index.md new file mode 100644 index 0000000..f7863f2 --- /dev/null +++ b/man/index.md @@ -0,0 +1,59 @@ +# Benutzeranleitung + +Willkommen in der Benutzeranleitung für den Worshipgenerator. Diese Anleitung erklärt die Anwendung aus Anwendersicht: welche Seiten es gibt, welche Aufgaben dort erledigt werden und welche Berechtigungen dafür nötig sind. + +Die Anleitung beschreibt keine technischen Hintergründe. Wenn du wissen möchtest, wie die Anwendung intern aufgebaut ist, nutze stattdessen die [Projektdokumentation](../docs/index.md). + +## Schnellstart + +- [Erste Schritte](tutorials/erste-schritte.md) +- [Ein Lied finden und nutzen](tutorials/lied-finden-und-nutzen.md) +- [Neue Veranstaltung planen](tutorials/neue-veranstaltung-planen.md) +- [Veranstaltung veröffentlichen und teilen](tutorials/veranstaltung-veroeffentlichen-und-teilen.md) +- [Präsentation durchführen](tutorials/praesentation-durchfuehren.md) +- [CCLI-Meldung und Handout erstellen](tutorials/ccli-meldung-und-handout.md) +- [Benutzer und Berechtigungen verstehen](tutorials/benutzer-und-berechtigungen.md) + +## Grundlagen + +- [Berechtigungen und Rollen](berechtigungen.md) +- [Tutorial-Übersicht](tutorials/index.md) + +## Seiten im Bereich Lieder + +- [Liedliste](pages/lieder-liste.md) +- [Lieddetails](pages/lied-details.md) +- [Lied anlegen](pages/lied-anlegen.md) +- [Lied bearbeiten](pages/lied-bearbeiten.md) + +## Seiten im Bereich Veranstaltungen + +- [Veranstaltungsliste](pages/veranstaltungen-liste.md) +- [Veranstaltungsdetails](pages/veranstaltung-details.md) +- [Veranstaltung anlegen](pages/veranstaltung-anlegen.md) +- [Veranstaltung bearbeiten](pages/veranstaltung-bearbeiten.md) + +## Seiten im Bereich Präsentation + +- [Präsentation auswählen](pages/praesentation-auswaehlen.md) +- [Präsentation steuern](pages/praesentation-steuerung.md) +- [Präsentationsmonitor](pages/praesentation-monitor.md) + +## Benutzerkonto + +- [Anmelden](pages/anmelden.md) +- [Benutzerprofil](pages/benutzerprofil.md) +- [Benutzer anlegen](pages/benutzer-anlegen.md) +- [Passwort zurücksetzen](pages/passwort-zuruecksetzen.md) +- [Passwort-Mail gesendet](pages/passwort-mail-gesendet.md) +- [Abmelden](pages/abmelden.md) + +## Öffentliche Seiten + +- [Branding](pages/branding.md) +- [Neuer Benutzer ohne Rollen](pages/neuer-benutzer-ohne-rollen.md) +- [Gastansicht](pages/gastansicht.md) + +## Empfohlene Lesereihenfolge + +Wenn du neu bist, beginne mit [Erste Schritte](tutorials/erste-schritte.md) und lies danach [Berechtigungen und Rollen](berechtigungen.md). Wenn du bereits weißt, was du tun möchtest, springe direkt zum passenden Tutorial oder zur Seitendokumentation. diff --git a/man/pages/abmelden.md b/man/pages/abmelden.md new file mode 100644 index 0000000..a7caa83 --- /dev/null +++ b/man/pages/abmelden.md @@ -0,0 +1,36 @@ +# Abmelden + +## Zweck + +Über diese Seite beendest du deine aktuelle Anmeldung. Danach können geschützte Bereiche erst wieder genutzt werden, wenn du dich erneut anmeldest. + +## Erforderliche Berechtigung + +Keine bestimmte Rolle. In der Praxis nutzt du die Seite, wenn du angemeldet bist. + +## Sichtbare Elemente + +Die Abmeldung läuft ohne eigene Eingabemaske ab. Normalerweise siehst du nur, dass du zur Startseite weitergeleitet wirst. + +Der sichtbare Einstieg befindet sich im [Benutzerprofil](benutzerprofil.md) als Button `Abmelden`. + +## Schritte + +1. Öffne dein Benutzerprofil. +2. Wähle `Abmelden`. +3. Warte auf die Weiterleitung. +4. Du bist anschließend nicht mehr angemeldet. + +## Hinweise + +- Melde dich ab, wenn du ein gemeinsam genutztes Gerät verlässt. +- Nach dem Abmelden sind persönliche und geschützte Bereiche nicht mehr verfügbar. +- Öffentliche Seiten wie die Anmeldeseite, die Branding-Seite oder eine Gastansicht bleiben weiterhin erreichbar. +- Wenn du versehentlich abgemeldet wurdest, melde dich einfach erneut an. + +## Links + +- [Benutzerprofil](benutzerprofil.md) +- [Anmelden](anmelden.md) +- [Branding](branding.md) +- [Gastansicht](gastansicht.md) diff --git a/man/pages/anmelden.md b/man/pages/anmelden.md new file mode 100644 index 0000000..7a318f8 --- /dev/null +++ b/man/pages/anmelden.md @@ -0,0 +1,47 @@ +# Anmelden + +## Zweck + +Auf dieser Seite meldest du dich mit deinem bestehenden Benutzerkonto beim Worshipgenerator an. Nach der Anmeldung stehen dir die Bereiche zur Verfügung, für die du freigeschaltet bist. + +## Erforderliche Berechtigung + +Keine. Die Anmeldeseite ist öffentlich erreichbar. + +Du brauchst aber ein angelegtes Benutzerkonto mit E-Mail-Adresse und Passwort. Welche Bereiche du danach nutzen kannst, hängt von deinen Rollen ab. Mehr dazu steht unter [Berechtigungen und Rollen](../berechtigungen.md). + +## Sichtbare Elemente + +- Logo der Anwendung +- Feld `E-Mail Addresse` +- Feld `Passwort` +- Button `Anmelden` +- Button `Passwort zurücksetzen` +- Button `neuen Benutzer anlegen` +- Fehlermeldung, falls die Anmeldung nicht möglich ist + +## Schritte + +1. Öffne die Anmeldeseite. +2. Gib deine E-Mail-Adresse ein. +3. Gib dein Passwort ein. +4. Wähle `Anmelden`. +5. Alternativ kannst du nach der Eingabe in einem Feld die Eingabetaste drücken. + +Nach erfolgreicher Anmeldung wirst du zur Startseite weitergeleitet. Falls dein Konto noch keine Rolle hat, siehst du eine Hinweisseite, dass dir noch Berechtigungen zugeteilt werden müssen. + +## Hinweise + +- Achte darauf, die E-Mail-Adresse so einzugeben, wie sie beim Anlegen des Kontos verwendet wurde. +- Wenn das Passwort nicht stimmt, erscheint eine Fehlermeldung. +- Wenn du dein Passwort vergessen hast, nutze `Passwort zurücksetzen`. +- Wenn du noch kein Konto hast, nutze `neuen Benutzer anlegen`. +- Eine Anmeldung allein bedeutet noch nicht, dass alle Bereiche sichtbar sind. Die Rollen bestimmen, welche Menüpunkte und Aktionen du verwenden darfst. + +## Links + +- [Benutzer anlegen](benutzer-anlegen.md) +- [Passwort zurücksetzen](passwort-zuruecksetzen.md) +- [Benutzerprofil](benutzerprofil.md) +- [Neuer Benutzer ohne Rollen](neuer-benutzer-ohne-rollen.md) +- [Berechtigungen und Rollen](../berechtigungen.md) diff --git a/man/pages/benutzer-anlegen.md b/man/pages/benutzer-anlegen.md new file mode 100644 index 0000000..271c3b9 --- /dev/null +++ b/man/pages/benutzer-anlegen.md @@ -0,0 +1,45 @@ +# Benutzer anlegen + +## Zweck + +Auf dieser Seite erstellst du ein neues Benutzerkonto. Das Konto wird mit Name, E-Mail-Adresse und Passwort angelegt. Fachliche Berechtigungen erhältst du danach noch nicht automatisch. + +## Erforderliche Berechtigung + +Keine. Die Seite ist öffentlich erreichbar. + +Nach dem Anlegen brauchst du eine Freischaltung durch einen Administrator, bevor du geschützte Bereiche wie Lieder, Veranstaltungen oder Präsentation nutzen kannst. + +## Sichtbare Elemente + +- Karte `neuen Benutzer anlegen` +- Feld `Name` +- Feld `E-Mail Adresse` +- Feld `Passwort` +- Button `Benutzer anlegen` +- Schließen-Möglichkeit zurück zum vorherigen Benutzerbereich +- Fehlermeldung, falls das Konto nicht angelegt werden kann + +## Schritte + +1. Öffne die Seite zum Anlegen eines neuen Benutzers. +2. Gib deinen Namen ein. +3. Gib deine E-Mail-Adresse ein. +4. Gib ein Passwort ein. +5. Wähle `Benutzer anlegen`. +6. Nach erfolgreichem Anlegen gelangst du zur Seite für neue Benutzer ohne Rollen. + +## Hinweise + +- Verwende eine E-Mail-Adresse, auf die du Zugriff hast. Sie wird auch für das Zurücksetzen des Passworts verwendet. +- Das Passwort muss lang genug sein. Wenn es nicht akzeptiert wird, erscheint eine Fehlermeldung. +- Falls die E-Mail-Adresse bereits verwendet wird, kann kein zweites Konto mit derselben Adresse angelegt werden. +- Direkt nach der Registrierung bist du zwar angemeldet, hast aber noch keine Rollen. +- Bitte wende dich nach der Registrierung an einen Administrator, damit dir die passenden Berechtigungen zugeteilt werden. + +## Links + +- [Anmelden](anmelden.md) +- [Neuer Benutzer ohne Rollen](neuer-benutzer-ohne-rollen.md) +- [Benutzerprofil](benutzerprofil.md) +- [Berechtigungen und Rollen](../berechtigungen.md) diff --git a/man/pages/benutzerprofil.md b/man/pages/benutzerprofil.md new file mode 100644 index 0000000..db24bf7 --- /dev/null +++ b/man/pages/benutzerprofil.md @@ -0,0 +1,73 @@ +# Benutzerprofil + +## Zweck + +Im Benutzerprofil siehst du dein eigenes Konto, deine Rollen und deine bevorzugte Akkordanzeige. Von hier aus kannst du dich abmelden. Administratoren verwalten auf derselben Seite zusätzlich die registrierten Benutzer. + +## Erforderliche Berechtigung + +Du musst angemeldet sein. + +Für die normale Profilansicht ist keine bestimmte Rolle nötig. Die Benutzerverwaltung ist nur für Benutzer mit der Berechtigung **Administrator** sichtbar. + +## Sichtbare Elemente + +Für alle angemeldeten Benutzer: + +- Überschrift `Benutzer` +- Begrüßung mit deinem Namen, zum Beispiel `Hallo Maria` +- Anzeige deiner Rollen in verständlicher Sprache +- Warnhinweis, wenn dir noch keine Berechtigungen zugeteilt wurden +- Auswahlfeld `bevorzugte Anzeige der Akkorde` +- Hinweis, dass die Auswahl nur eine Voreinstellung ist +- Button `Abmelden` + +Für Administratoren zusätzlich: + +- Bereich `registrierte Benutzer` +- Liste aller registrierten Benutzer +- Name jedes Benutzers +- Rollen jedes Benutzers +- Bearbeitungsansicht mit Namensfeld und Rollenauswahl +- Schließen-Symbol zum Beenden der Bearbeitung + +## Schritte: Akkordanzeige ändern + +1. Öffne dein Benutzerprofil. +2. Öffne das Auswahlfeld `bevorzugte Anzeige der Akkorde`. +3. Wähle eine der Optionen: + - leere Auswahl: keine besondere Vorgabe + - `nur den Liedtext anzeigen` + - `in Strophen die Akkorde nur für die erste anzeigen` + - `alle anzeigen` +4. Die Änderung wird direkt übernommen. + +## Schritte: Abmelden + +1. Öffne dein Benutzerprofil. +2. Wähle `Abmelden`. +3. Du wirst abgemeldet und zur Startseite weitergeleitet. + +## Schritte: Benutzer verwalten + +Diese Schritte gelten nur für Administratoren. + +1. Öffne dein Benutzerprofil. +2. Scrolle zum Bereich `registrierte Benutzer`. +3. Wähle den Benutzer aus, den du bearbeiten möchtest. +4. Ändere bei Bedarf den Namen. +5. Wähle eine oder mehrere Rollen aus. +6. Schließe die Bearbeitung über das Schließen-Symbol. + +## Hinweise + +- Die Akkordanzeige ist deine persönliche Voreinstellung. Bei einzelnen Liedern kann die Anzeige trotzdem noch anders gewählt werden. +- Wenn bei deinem Konto der Hinweis erscheint, dass noch keine Berechtigungen zugeteilt wurden, kannst du geschützte Bereiche noch nicht nutzen. +- Rollen können kombiniert werden. Eine Person kann zum Beispiel gleichzeitig die Berechtigungen **Lobpreisleiter**, **Präsentator** und **Mitarbeiter** haben. +- Die Berechtigung **Administrator** sollte nur an Personen vergeben werden, die Benutzer und Berechtigungen verwalten dürfen. + +## Links + +- [Abmelden](abmelden.md) +- [Neuer Benutzer ohne Rollen](neuer-benutzer-ohne-rollen.md) +- [Berechtigungen und Rollen](../berechtigungen.md) diff --git a/man/pages/branding.md b/man/pages/branding.md new file mode 100644 index 0000000..90cba14 --- /dev/null +++ b/man/pages/branding.md @@ -0,0 +1,34 @@ +# Branding + +## Zweck + +Die Branding-Seite zeigt die öffentliche Markenansicht des Worshipgenerators. Sie dient als einfache neutrale Seite mit Logo und Copyright-Hinweis. + +## Erforderliche Berechtigung + +Keine. Die Seite ist öffentlich erreichbar. + +## Sichtbare Elemente + +- Logo der Anwendung +- Copyright-Hinweis `© 2019 - 2026 - Benjamin Ifland` + +## Schritte + +1. Öffne die Branding-Seite. +2. Prüfe bei Bedarf, ob du dich auf der richtigen Anwendung befindest. + +Weitere Eingaben oder Aktionen sind auf dieser Seite nicht vorgesehen. + +## Hinweise + +- Die Seite enthält keine persönlichen Daten. +- Du musst nicht angemeldet sein. +- Die Seite vergibt keine Berechtigungen und ändert keine Einstellungen. +- Neue Benutzer ohne Rollen sehen ebenfalls eine öffentliche Markenansicht, dort aber zusätzlich eine persönliche Begrüßung und einen Berechtigungshinweis. + +## Links + +- [Neuer Benutzer ohne Rollen](neuer-benutzer-ohne-rollen.md) +- [Anmelden](anmelden.md) +- [Gastansicht](gastansicht.md) diff --git a/man/pages/gastansicht.md b/man/pages/gastansicht.md new file mode 100644 index 0000000..1e32b4e --- /dev/null +++ b/man/pages/gastansicht.md @@ -0,0 +1,53 @@ +# Gastansicht + +## Zweck + +Die Gastansicht zeigt eine öffentlich geteilte Veranstaltung. Sie ist für Personen gedacht, die keinen eigenen Zugang zum Worshipgenerator brauchen, aber die Lieder einer Veranstaltung ansehen sollen. + +## Erforderliche Berechtigung + +Keine. Die Gastansicht ist öffentlich erreichbar. + +Du brauchst nur den passenden Link zur Gastansicht. Wer den Link kennt, kann die geteilten Inhalte öffnen. + +## Sichtbare Elemente + +Bei einer gültigen Gastansicht: + +- Veranstaltungstyp links oben +- Datum rechts oben +- Liedtitel +- optional Künstler oder Urheberangabe +- Liedtext +- Wischansicht für mehrere Lieder +- Scrollbalken innerhalb der Wischansicht + +Je nach Situation können auch diese Meldungen erscheinen: + +- `Gastansicht wird geladen.` +- `Für diesen Link wurde keine Gastansicht gefunden.` +- eine Fehlermeldung, falls die Gastansicht nicht geladen werden kann + +## Schritte + +1. Öffne den Link zur Gastansicht. +2. Warte, bis die Veranstaltung geladen ist. +3. Prüfe Veranstaltungstyp und Datum. +4. Lies das aktuell angezeigte Lied. +5. Wische oder scrolle zur nächsten Folie, um weitere Lieder zu sehen. +6. Lasse die Seite geöffnet, wenn du während der Veranstaltung mitlesen möchtest. + +## Hinweise + +- Für die Gastansicht ist keine Anmeldung nötig. +- Die Gastansicht ist zum Lesen gedacht. Du kannst dort keine Lieder oder Veranstaltungen bearbeiten. +- Änderungen an der geteilten Veranstaltung können in der Gastansicht automatisch sichtbar werden. +- Wenn der Link nicht mehr gültig ist oder falsch kopiert wurde, erscheint die Meldung, dass keine Gastansicht gefunden wurde. +- Teile den Link nur mit Personen, die die Liedtexte und Veranstaltungsinformationen sehen sollen. +- Die Gastansicht enthält nur die Inhalte, die für die geteilte Veranstaltung bereitgestellt wurden. + +## Links + +- [Branding](branding.md) +- [Anmelden](anmelden.md) +- [Berechtigungen und Rollen](../berechtigungen.md) diff --git a/man/pages/lied-anlegen.md b/man/pages/lied-anlegen.md new file mode 100644 index 0000000..13cd469 --- /dev/null +++ b/man/pages/lied-anlegen.md @@ -0,0 +1,59 @@ +# Lied anlegen + +[Zurück zur Übersicht](../index.md) | [Zur Liedliste](lieder-liste.md) + +## Zweck + +Auf der Seite `Neues Lied` legst du einen neuen Liedeintrag an. Beim Anlegen werden zuerst nur Liednummer und Titel erfasst. Danach wirst du direkt zur Bearbeitungsseite weitergeleitet, um Liedtext, Akkorde, Tonart, rechtliche Angaben und weitere Informationen zu ergänzen. + +Diese Seite ist für den ersten Schritt gedacht: einen neuen Eintrag im Liedbestand erstellen. + +## Erforderliche Berechtigung + +Du musst angemeldet sein und die Berechtigung **Mitarbeiter** haben. + +Wenn du nur die Berechtigung **Benutzer** hast, kannst du Lieder ansehen, aber keine neuen Lieder anlegen. + +## Seitenelemente + +- Überschrift `Neues Lied`. +- Zurück-Link zur Liedliste. +- Feld `Nummer`: Liednummer des neuen Liedes. +- Feld `Titel`: Titel des neuen Liedes. +- Button `Anlegen`: erstellt den neuen Liedeintrag. + +Beim Öffnen der Seite wird normalerweise automatisch eine freie Liednummer vorgeschlagen. Den Titel musst du selbst eintragen. + +## Schritt-für-Schritt-Aktionen + +### Neues Lied anlegen + +1. Öffne die [Liedliste](lieder-liste.md). +2. Klicke auf `Neuen Song anlegen`. +3. Prüfe die vorgeschlagene `Nummer`. +4. Ändere die Nummer nur, wenn du bewusst eine andere freie Liednummer verwenden möchtest. +5. Gib im Feld `Titel` den Liedtitel ein. +6. Klicke auf `Anlegen`. +7. Die Bearbeitungsseite wird geöffnet. +8. Ergänze dort Liedtext, Akkorde und weitere Angaben. Folge dafür der Anleitung [Lied bearbeiten](lied-bearbeiten.md). + +### Zur Liedliste zurückkehren + +1. Klicke auf den Zurück-Link in der Karte. +2. Du gelangst wieder zur [Liedliste](lieder-liste.md). + +## Hinweise und Fehlervermeidung + +- Lege ein Lied erst an, wenn du sicher bist, dass es noch nicht vorhanden ist. Suche vorher in der [Liedliste](lieder-liste.md) nach Titel und markanten Textstellen. +- Die vorgeschlagene Nummer soll helfen, doppelte Liednummern zu vermeiden. Prüfe trotzdem, ob die Nummer fachlich passt. +- `Nummer` und `Titel` sind Pflichtangaben. Ohne diese Angaben kann das Lied nicht sinnvoll angelegt werden. +- Ein neu angelegtes Lied ist zunächst ein Entwurf und hat rechtlich noch Klärungsbedarf. Ergänze die Angaben auf der Bearbeitungsseite, bevor das Lied regulär genutzt wird. +- Wenn der Button `Neuen Song anlegen` in der Liedliste nicht sichtbar ist, fehlt dir wahrscheinlich die Berechtigung **Mitarbeiter**. +- Wenn du dich vertippt hast, lege kein zweites Lied an. Öffne stattdessen die Bearbeitungsseite und korrigiere den Titel oder die Angaben dort. + +## Verwandte Seiten + +- [Liedliste](lieder-liste.md) +- [Lieddetails](lied-details.md) +- [Lied bearbeiten](lied-bearbeiten.md) +- [Zur Benutzeranleitung](../index.md) diff --git a/man/pages/lied-bearbeiten.md b/man/pages/lied-bearbeiten.md new file mode 100644 index 0000000..e0e9f62 --- /dev/null +++ b/man/pages/lied-bearbeiten.md @@ -0,0 +1,121 @@ +# Lied bearbeiten + +[Zurück zur Übersicht](../index.md) | [Zur Liedliste](lieder-liste.md) + +## Zweck + +Auf der Bearbeitungsseite pflegst du ein vorhandenes Lied. Hier änderst du Titel, Typ, Tonart, Tempo, Status, Liedtext, Akkorde, Kommentare, Attribute, rechtliche Angaben und Anhänge. + +Diese Seite wird nach dem Anlegen eines neuen Liedes automatisch geöffnet und ist auch über `Bearbeiten` in den [Lieddetails](lied-details.md) erreichbar. + +## Erforderliche Berechtigung + +Du musst angemeldet sein. Der normale Einstieg über den Button `Bearbeiten` ist für Benutzer mit der Berechtigung **Mitarbeiter** sichtbar. + +Wenn du den Button nicht siehst, darfst du das Lied in der Regel nicht bearbeiten. + +## Seitenelemente + +- Überschrift mit der Liednummer, zum Beispiel `12 bearbeiten`. +- Zurück-Link zur Detailseite des Liedes. +- Feld `Titel`: Name des Liedes. +- Feld `Typ`: Einordnung als `Lobpreis`, `Anbetung` oder `sonstiges`. +- Feld `Tonart`: Grundtonart des Liedes. +- Feld `Tempo`: Tempoangabe. +- Feld `Status`: Bearbeitungsstand des Liedes, zum Beispiel `Entwurf`, `offen` oder `final`. +- Feld `Songtext`: Liedtext mit Akkorden. +- Bereich `Akkordschreibweise korrigieren`: erscheint, wenn Akkorde nicht in der erwarteten Schreibweise erkannt werden. +- Vorschau und Bearbeitungshinweise: erscheinen, während du im Feld `Songtext` arbeitest. +- Feld `Kommentar`: interne Hinweise zum Lied. +- Feld `Attribute`: Schlagworte, die später in der Liedliste als Filter genutzt werden können. +- Feld `Rechtlicher Status`: `Klärung erforderlich` oder `OK`. +- Feld `Rechteinhaber`: zum Beispiel `CCLI` oder `andere`. +- Feld `Rechteinhaber ID`: zum Beispiel die CCLI-Liednummer. +- Felder `Künstler`, `Verlag / Copyright`, `Nutzungsbedingungen` und `abweichende Quelle`. +- Button `Speichern`. +- Bereich `Angehängte Dateien`: Dateien auswählen, hochladen, öffnen oder entfernen. +- Bereich `letzte Änderungen`: zeigt, wer das Lied zuletzt gespeichert hat und wann. + +## Schritt-für-Schritt-Aktionen + +### Stammdaten bearbeiten + +1. Öffne ein Lied in den [Lieddetails](lied-details.md). +2. Klicke auf `Bearbeiten`. +3. Ändere Titel, Typ, Tonart, Tempo oder Status. +4. Prüfe, ob die Angaben zum Lied passen. +5. Klicke auf `Speichern`. + +### Liedtext und Akkorde bearbeiten + +1. Klicke in das Feld `Songtext`. +2. Bearbeite den Liedtext. +3. Schreibe Akkorde jeweils in die Zeile über den zugehoerigen Liedtext. +4. Verwende Leerzeichen, um Akkorde an die richtige Position zu setzen. +5. Vermeide Tabulatoren. +6. Prüfe die Vorschau, solange das Textfeld aktiv ist. +7. Falls `Akkordschreibweise korrigieren` erscheint, korrigiere die dort genannten Zeilen. +8. Klicke auf `Speichern`, wenn keine Korrekturhinweise mehr offen sind. + +### Liedabschnitte strukturieren + +1. Schreibe Abschnittsbezeichnungen wie `Strophe`, `Refrain` oder `Bridge` als eigene Zeile. +2. Setze danach den zugehoerigen Liedtext. +3. Wiederhole Abschnittsbezeichnungen, wenn ein Abschnitt erneut beginnt. +4. Prüfe in der Vorschau, ob der Text gut lesbar dargestellt wird. + +### Attribute hinzufügen oder entfernen + +1. Klicke in das Feld `Attribute`. +2. Gib ein Schlagwort ein. +3. Bestätige mit Enter, Komma oder indem du das Feld verlässt. +4. Entferne ein Attribut über das Entfernen-Symbol am jeweiligen Schlagwort. +5. Speichere die Änderung. + +### Rechtliche Angaben pflegen + +1. Wähle den passenden `Rechtlicher Status`. +2. Wähle den `Rechteinhaber`. +3. Trage bei Bedarf die `Rechteinhaber ID` ein. +4. Wenn der Rechteinhaber `CCLI` ist, prüfe die CCLI-Nummer über den angezeigten Link. +5. Ergänze Künstler, Verlag, Nutzungsbedingungen und Quelle, soweit bekannt. +6. Speichere die Änderungen. + +### Datei anhängen + +1. Gehe zum Bereich `Angehängte Dateien`. +2. Wähle eine Datei aus. +3. Klicke auf das Upload-Symbol. +4. Warte, bis der Upload abgeschlossen ist. +5. Prüfe, ob die Datei in der Liste der Anhänge erscheint. + +### Anhang öffnen oder löschen + +1. Gehe zum Bereich `Angehängte Dateien`. +2. Öffne einen Anhang über den Dateilink. +3. Entferne einen falschen oder veralteten Anhang über das Papierkorb-Symbol. +4. Prüfe danach, ob nur noch die gewünschten Anhänge sichtbar sind. + +### Seite mit ungespeicherten Änderungen verlassen + +1. Wenn du die Seite mit ungespeicherten Änderungen verlassen möchtest, erscheint ein Hinweis. +2. Wähle `Speichern`, wenn deine Änderungen erhalten bleiben sollen. +3. Wähle `Änderungen verwerfen`, wenn du die Seite ohne Speichern verlassen möchtest. + +## Hinweise und Fehlervermeidung + +- Speichere nach größeren Textänderungen zeitnah, damit keine Arbeit verloren geht. +- Der Button `Speichern` kann deaktiviert sein, wenn Pflichtangaben fehlen oder die Akkordschreibweise korrigiert werden muss. +- Nutze für Akkorde die erwartete Schreibweise, zum Beispiel Großbuchstaben für Dur und Kleinbuchstaben für Moll. +- Verwende keine Tabulatoren in Akkordzeilen. Sie können die Darstellung verschieben. +- Setze den Status `final` erst, wenn Text, Akkorde, Tonart und rechtliche Angaben geprüft sind. +- Belasse den rechtlichen Status auf `Klärung erforderlich`, solange Rechteinhaber, CCLI-Nummer oder Nutzungsbedingungen nicht sicher geklärt sind. +- Verwende Attribute sparsam und einheitlich, damit der Attributfilter in der Liedliste nützlich bleibt. +- Lösche Anhänge nur, wenn du sicher bist, dass sie nicht mehr gebraucht werden. + +## Verwandte Seiten + +- [Lieddetails](lied-details.md) +- [Liedliste](lieder-liste.md) +- [Lied anlegen](lied-anlegen.md) +- [Zur Benutzeranleitung](../index.md) diff --git a/man/pages/lied-details.md b/man/pages/lied-details.md new file mode 100644 index 0000000..1e52e0b --- /dev/null +++ b/man/pages/lied-details.md @@ -0,0 +1,98 @@ +# Lieddetails + +[Zurück zur Übersicht](../index.md) | [Zur Liedliste](lieder-liste.md) + +## Zweck + +Die Lieddetails zeigen ein einzelnes Lied mit Liedtext, Akkorden und weiteren Informationen. Von hier aus kannst du das Lied lesen, Anhänge öffnen, es zu einer eigenen Veranstaltung hinzufügen oder es mit passender Berechtigung bearbeiten. + +Die Seite ist die normale Ansicht, wenn du ein Lied aus der Liedliste geöffnet hast. + +## Erforderliche Berechtigung + +Du musst angemeldet sein und mindestens die Berechtigung **Benutzer** haben. + +Zusätzliche sichtbare Bereiche und Aktionen hängen von deiner Rolle ab: + +- Mit **Lobpreisleiter** oder **Mitarbeiter** siehst du zusätzliche Liedangaben wie Typ, Tonart, Tempo, Status, Rechteinformationen, Attribute, Kommentare und Verwendungsinformationen. +- Mit **Lobpreisleiter** kannst du ein Lied zu einer eigenen, noch nicht veröffentlichten Veranstaltung hinzufügen. +- Mit **Mitarbeiter** siehst du den Button `Bearbeiten`. +- Mit **Administrator** siehst du den Button `Löschen`. + +## Seitenelemente + +- Überschrift mit Liednummer und Titel, zum Beispiel `12 - Liedtitel`. +- Zurück-Link zur Liedliste. +- Liedtext mit Akkorden. +- Akkordschalter am Liedtext, mit dem du die Akkordanzeige umschalten kannst. +- Detailangaben, sofern du die passende Rolle hast: + - Typ + - Tonart + - Tempo + - Status + - Rechteinhaber + - CCLI-Nummer oder andere Rechteinhaber-ID + - Künstler + - Verlag + - Quelle + - Wie oft verwendet +- Attribute als Schlagworte. +- Kommentarbereich. +- Bereich `Anhänge` mit verknüpften Dateien, falls Dateien vorhanden sind. +- Button `Bearbeiten`, wenn du Mitarbeiter bist. +- Button `Zu Veranstaltung hinzufügen`, wenn du Lobpreisleiter bist und passende eigene Veranstaltungen vorhanden sind. +- Button `Löschen`, wenn du Administrator bist. + +## Schritt-für-Schritt-Aktionen + +### Lied lesen + +1. Öffne ein Lied aus der [Liedliste](lieder-liste.md). +2. Lies Titel, Liedtext und Akkorde. +3. Nutze den Akkordschalter, wenn du die Akkorde anders anzeigen möchtest. +4. Prüfe bei Bedarf Tonart, Tempo, Status und Hinweise. + +### Anhänge öffnen + +1. Scrolle zum Bereich `Anhänge`. +2. Klicke auf den gewünschten Anhang. +3. Die Datei wird geöffnet oder heruntergeladen, je nach Browser und Dateityp. + +### Lied zu einer Veranstaltung hinzufügen + +1. Stelle sicher, dass du die Berechtigung **Lobpreisleiter** hast. +2. Prüfe, ob der Button `Zu Veranstaltung hinzufügen` sichtbar ist. +3. Klicke auf den Button. +4. Wähle im Menü die passende Veranstaltung aus. +5. Die Veranstaltung wird geöffnet und das Lied ist dort hinzugefügt. + +Der Button erscheint nur, wenn es mindestens eine eigene, noch nicht veröffentlichte Veranstaltung gibt, zu der das Lied hinzugefügt werden kann. + +### Lied bearbeiten + +1. Stelle sicher, dass du die Berechtigung **Mitarbeiter** hast. +2. Klicke auf `Bearbeiten`. +3. Bearbeite das Lied auf der Bearbeitungsseite. +4. Folge der Anleitung unter [Lied bearbeiten](lied-bearbeiten.md). + +### Lied löschen + +1. Stelle sicher, dass du Administrator bist. +2. Klicke auf `Löschen`. +3. Das Lied wird entfernt und du kehrst zur Liedliste zurück. + +## Hinweise und Fehlervermeidung + +- Nutze `Löschen` nur, wenn du sicher bist. Die Aktion ist für Administratoren sichtbar und entfernt das Lied direkt aus dem Bestand. +- Wenn `Zu Veranstaltung hinzufügen` nicht sichtbar ist, hast du entweder nicht die Berechtigung **Lobpreisleiter** oder es gibt keine geeignete eigene unveröffentlichte Veranstaltung. +- Wenn `Bearbeiten` nicht sichtbar ist, fehlt dir wahrscheinlich die Berechtigung **Mitarbeiter**. +- Rechtliche Angaben wie CCLI-Nummer, Rechteinhaber und rechtlicher Status sollten vor der öffentlichen Nutzung eines Liedes geprüft werden. +- Die Anzeige `Wie oft verwendet` hilft einzuschätzen, wie häufig ein Lied in eigenen Veranstaltungen vorkam. Sie ersetzt keine rechtliche Prüfung. +- Anhänge können Zusatzmaterial enthalten, zum Beispiel Notizen, Vorlagen oder Dateien zum Lied. Prüfe vor der Nutzung, ob der Anhang zur aktuellen Liedfassung passt. + +## Verwandte Seiten + +- [Liedliste](lieder-liste.md) +- [Lied bearbeiten](lied-bearbeiten.md) +- [Lied anlegen](lied-anlegen.md) +- [Zur Benutzeranleitung](../index.md) diff --git a/man/pages/lieder-liste.md b/man/pages/lieder-liste.md new file mode 100644 index 0000000..e120434 --- /dev/null +++ b/man/pages/lieder-liste.md @@ -0,0 +1,98 @@ +# Liedliste + +[Zurück zur Übersicht](../index.md) + +## Zweck + +Die Liedliste ist der Einstieg in den Bereich Lieder. Hier findest du vorhandene Lieder, grenzt die Liste mit Filtern ein und öffnest ein Lied, um Text, Akkorde und weitere Angaben anzusehen. + +Die Liste ist besonders hilfreich, wenn du ein Lied für eine Veranstaltung suchst, eine Tonart prüfen möchtest oder sehen willst, welche Lieder noch Pflegebedarf haben. + +## Erforderliche Berechtigung + +Du musst angemeldet sein und mindestens die Berechtigung **Benutzer** haben. + +Zusätzliche sichtbare Funktionen hängen von deiner Rolle ab: + +- Mit **Mitarbeiter** siehst du Statushinweise zu Liedern und den Button `Neuen Song anlegen`. +- Rechtliche Warnhinweise werden angezeigt, wenn bei einem Lied noch Klärungsbedarf besteht. + +## Seitenelemente + +- `Lieder`: Seitenüberschrift des Bereichs. +- Filterbereich: Suche und Filter, mit denen du die angezeigten Lieder eingrenzt. +- Feld `Titel oder Text`: sucht nach Liedtiteln und Liedtext. +- Filter `Typ`: grenzt nach `Lobpreis`, `Anbetung` oder `sonstiges` ein. +- Filter `Tonart`: grenzt nach Grundton, Vorzeichen und Dur/Moll ein. +- Option `Parallele Tonart einschließen`: zeigt auch Lieder in der passenden parallelen Tonart. +- Filter `Rechtlicher Status`: unterscheidet zwischen `OK` und `Klärung erforderlich`. +- Filter `Attribute`: grenzt nach vorhandenen Schlagworten ein. +- Liedliste: zeigt pro Lied Nummer, Titel, Hinweise und Tonart. +- `Filter aktiv`: Hinweis oberhalb der Liste, wenn gerade gefiltert wird. +- `Filter zurücksetzen`: entfernt alle aktiven Filter. +- `Neuen Song anlegen`: öffnet die Seite zum Anlegen eines neuen Liedes, sofern du die Berechtigung **Mitarbeiter** hast. + +Hinweissymbole in der Liste: + +- Statussymbole zeigen Mitarbeiters, ob ein Lied noch Entwurf, offen oder final ist. +- Ein rechtlicher Warnhinweis bedeutet, dass der rechtliche Status noch `Klärung erforderlich` ist. +- Ein Stern am Titel weist auf mögliche Probleme in der Akkordschreibweise hin. + +## Schritt-für-Schritt-Aktionen + +### Ein Lied öffnen + +1. Öffne den Bereich `Lieder`. +2. Suche das Lied in der Liste oder verwende die Filter. +3. Klicke auf den Listeneintrag des Liedes. +4. Die Detailseite des Liedes wird geöffnet. + +### Nach Titel oder Text suchen + +1. Klicke in das Feld `Titel oder Text`. +2. Gib einen Teil des Titels oder eine Textstelle ein. +3. Die Liste zeigt nur noch passende Lieder. +4. Klicke bei Bedarf auf `Filter zurücksetzen`, um wieder alle Lieder zu sehen. + +### Nach Typ filtern + +1. Öffne den Filter `Typ`. +2. Wähle `Lobpreis`, `Anbetung` oder `sonstiges`. +3. Die Liste zeigt nur Lieder dieses Typs. +4. Wähle `- kein Filter -`, wenn der Typ nicht mehr eingeschränkt werden soll. + +### Nach Tonart filtern + +1. Wähle im Bereich `Tonart` den gewünschten Grundton. +2. Wähle bei Bedarf ein Vorzeichen. +3. Wähle Dur oder Moll. +4. Aktiviere `Parallele Tonart einschließen`, wenn auch die passende Dur- oder Moll-Parallele angezeigt werden soll. + +### Nach rechtlichem Status oder Attributen filtern + +1. Öffne den Filter `Rechtlicher Status` oder `Attribute`. +2. Wähle den passenden Eintrag. +3. Prüfe die Trefferliste. +4. Setze den Filter zurück, wenn du wieder ohne Einschränkung suchen möchtest. + +### Ein neues Lied anlegen + +1. Stelle sicher, dass du die Berechtigung **Mitarbeiter** hast. +2. Scrolle ans Ende der Liedliste. +3. Klicke auf `Neuen Song anlegen`. +4. Folge der Anleitung unter [Lied anlegen](lied-anlegen.md). + +## Hinweise und Fehlervermeidung + +- Wenn du ein erwartetes Lied nicht findest, setze zuerst alle Filter zurück. +- Deaktivierte Tonart-Auswahlen bedeuten, dass es aktuell keine passenden Lieder mit dieser Auswahl gibt. +- Ein rechtlicher Warnhinweis ist kein Bedienfehler. Er bedeutet, dass die Nutzungsrechte noch geprüft oder vervollständigt werden müssen. +- Ein Stern am Liedtitel sollte vor der Nutzung in einer Präsentation geprüft werden, weil Akkorde eventuell nicht wie erwartet dargestellt werden. +- Wenn der Button `Neuen Song anlegen` nicht sichtbar ist, fehlt dir wahrscheinlich die Berechtigung **Mitarbeiter**. + +## Verwandte Seiten + +- [Lieddetails](lied-details.md) +- [Lied anlegen](lied-anlegen.md) +- [Lied bearbeiten](lied-bearbeiten.md) +- [Zur Benutzeranleitung](../index.md) diff --git a/man/pages/neuer-benutzer-ohne-rollen.md b/man/pages/neuer-benutzer-ohne-rollen.md new file mode 100644 index 0000000..cfca338 --- /dev/null +++ b/man/pages/neuer-benutzer-ohne-rollen.md @@ -0,0 +1,41 @@ +# Neuer Benutzer ohne Rollen + +## Zweck + +Diese Seite erscheint nach dem Anlegen eines neuen Benutzerkontos, solange dir noch keine Berechtigungen zugeteilt wurden. Sie bestätigt, dass dein Konto vorhanden ist, macht aber auch deutlich, dass du noch nicht freigeschaltet bist. + +## Erforderliche Berechtigung + +Du brauchst ein neu angelegtes und angemeldetes Benutzerkonto ohne Rollen. + +Die Seite selbst ist öffentlich erreichbar, zeigt den persönlichen Hinweis aber nur, wenn ein angemeldeter Benutzer erkannt wird. + +## Sichtbare Elemente + +- Branding-Bereich mit Logo und Copyright +- Begrüßung `WILLKOMMEN` +- Dein Name +- Hinweis `Es wurden noch keine Berechtigungen zugeteilt, bitte wende Dich an den Administrator!` + +## Schritte + +1. Lege ein neues Benutzerkonto an. +2. Nach erfolgreicher Registrierung wirst du automatisch auf diese Seite geführt. +3. Lies den Hinweis zur fehlenden Berechtigung. +4. Wende dich an einen Administrator deiner Gemeinde oder deines Teams. +5. Bitte um die Rollen, die du für deine Aufgaben brauchst. +6. Melde dich nach der Freischaltung erneut an oder öffne dein Benutzerprofil, um deine Rollen zu prüfen. + +## Hinweise + +- Diese Seite ist kein Fehler. Sie bedeutet, dass dein Konto existiert, aber noch nicht freigeschaltet wurde. +- Ohne Rollen kannst du geschützte Bereiche nicht oder nur eingeschränkt nutzen. +- Ein Administrator vergibt Rollen über die Benutzerverwaltung im Benutzerprofil. +- Welche Rolle du brauchst, hängt von deiner Aufgabe ab. Beispiele findest du unter [Berechtigungen und Rollen](../berechtigungen.md). + +## Links + +- [Benutzer anlegen](benutzer-anlegen.md) +- [Benutzerprofil](benutzerprofil.md) +- [Anmelden](anmelden.md) +- [Berechtigungen und Rollen](../berechtigungen.md) diff --git a/man/pages/passwort-mail-gesendet.md b/man/pages/passwort-mail-gesendet.md new file mode 100644 index 0000000..f3d35f3 --- /dev/null +++ b/man/pages/passwort-mail-gesendet.md @@ -0,0 +1,35 @@ +# Passwort-Mail gesendet + +## Zweck + +Diese Seite bestätigt, dass die Anfrage zum Zurücksetzen des Passworts angenommen wurde. Sie erinnert dich daran, dein E-Mail-Postfach zu prüfen. + +## Erforderliche Berechtigung + +Keine. Die Seite ist öffentlich erreichbar. Du musst nicht angemeldet sein. + +## Sichtbare Elemente + +- Hinweistext, dass eine E-Mail mit dem neuen Passwort gesendet wurde +- Hinweis, dass die E-Mail einen Link enthält, über den das neue Passwort eingegeben werden kann + +## Schritte + +1. Lies den Hinweis auf der Seite. +2. Öffne dein E-Mail-Postfach. +3. Suche nach der E-Mail zum Zurücksetzen des Passworts. +4. Öffne den Link in dieser E-Mail. +5. Vergib ein neues Passwort. +6. Melde dich anschließend mit dem neuen Passwort an. + +## Hinweise + +- Die Seite selbst setzt kein Passwort. Sie bestätigt nur, dass die Anfrage abgeschickt wurde. +- Falls keine E-Mail ankommt, prüfe den Spam- oder Junk-Ordner. +- Wenn du weiterhin keine E-Mail findest, starte den Vorgang erneut über `Passwort zurücksetzen`. +- Der Link in der E-Mail kann zeitlich begrenzt sein. Nutze ihn möglichst direkt. + +## Links + +- [Passwort zurücksetzen](passwort-zuruecksetzen.md) +- [Anmelden](anmelden.md) diff --git a/man/pages/passwort-zuruecksetzen.md b/man/pages/passwort-zuruecksetzen.md new file mode 100644 index 0000000..a76ff32 --- /dev/null +++ b/man/pages/passwort-zuruecksetzen.md @@ -0,0 +1,40 @@ +# Passwort zurücksetzen + +## Zweck + +Auf dieser Seite forderst du eine E-Mail zum Zurücksetzen deines Passworts an. Das ist hilfreich, wenn du dein Passwort vergessen hast oder ein neues Passwort setzen möchtest. + +## Erforderliche Berechtigung + +Keine. Die Seite ist öffentlich erreichbar. Du musst nicht angemeldet sein. + +## Sichtbare Elemente + +- Karte `Passwort zurücksetzen` +- Feld `E-Mail Addresse` +- Button `neues Passwort anfordern` +- Fehlermeldung, falls die Anfrage nicht möglich ist +- Schließen-Möglichkeit zurück zum vorherigen Benutzerbereich + +## Schritte + +1. Öffne die Seite `Passwort zurücksetzen`. +2. Gib die E-Mail-Adresse deines Benutzerkontos ein. +3. Wähle `neues Passwort anfordern`. +4. Alternativ kannst du nach der Eingabe die Eingabetaste drücken. +5. Bei erfolgreicher Anfrage wirst du zur Bestätigungsseite weitergeleitet. +6. Öffne danach dein E-Mail-Postfach und folge dem Link in der E-Mail. + +## Hinweise + +- Gib die E-Mail-Adresse ein, mit der dein Konto angelegt wurde. +- Prüfe auch den Spam- oder Junk-Ordner, falls keine E-Mail ankommt. +- Der Link in der E-Mail führt dich durch das Setzen eines neuen Passworts. +- Wenn die Adresse falsch geschrieben ist oder nicht verwendet werden kann, erscheint eine Fehlermeldung. +- Nach dem Setzen des neuen Passworts meldest du dich wieder über die Anmeldeseite an. + +## Links + +- [Passwort-Mail gesendet](passwort-mail-gesendet.md) +- [Anmelden](anmelden.md) +- [Benutzer anlegen](benutzer-anlegen.md) diff --git a/man/pages/praesentation-auswaehlen.md b/man/pages/praesentation-auswaehlen.md new file mode 100644 index 0000000..9d07534 --- /dev/null +++ b/man/pages/praesentation-auswaehlen.md @@ -0,0 +1,60 @@ +# Präsentation auswählen + +## Zweck + +Auf dieser Seite legt ihr fest, welche Veranstaltung gerade live präsentiert wird. Das ist der erste Schritt vor einer Präsentation und auch der richtige Ort, wenn während des Betriebs auf eine andere Veranstaltung gewechselt werden muss. + +Nach der Auswahl öffnet sich automatisch die Präsentationssteuerung. Die Präsentation startet dabei auf der Veranstaltungsfolie, damit auf dem Monitor nicht versehentlich ein Lied, ein Liedabschnitt oder ein freier Text aus einer vorherigen Auswahl stehen bleibt. + +## Berechtigung + +Die Seite ist für angemeldete Benutzer mit der Berechtigung **Präsentator** vorgesehen. Administratoren können die Präsentation ebenfalls bedienen. + +Wenn die Seite nicht erreichbar ist oder ihr nach der Anmeldung auf eine andere Seite geleitet werdet, fehlt eurem Benutzerkonto wahrscheinlich die passende Berechtigung. Wendet euch dann an eine Person, die Benutzerrollen verwalten darf. + +## Seitenelemente + +- Überschrift `Bitte eine Veranstaltung auswählen`: zeigt an, dass eine aktuelle Veranstaltung gewählt werden muss. +- Veranstaltungsliste: jede verfügbare Veranstaltung erscheint als eigener Button. +- Veranstaltungsangaben: pro Eintrag seht ihr den Besitzer, den Veranstaltungstyp und das Datum. +- Hinweis `Es ist derzeit keine Veranstaltung vorhanden`: erscheint, wenn keine passende Veranstaltung zur Auswahl steht. + +Es werden nur Veranstaltungen angezeigt, die für die Präsentation verfügbar sind und zeitlich zum aktuellen Betrieb passen. Wenn eine erwartete Veranstaltung fehlt, prüft zuerst, ob sie korrekt angelegt und veröffentlicht wurde. + +## Schritt-für-Schritt-Aktionen + +### Aktuelle Veranstaltung auswählen + +1. Öffnet den Bereich `Präsentation`. +2. Falls direkt die Steuerung erscheint, öffnet über das Ordner-Symbol die Veranstaltungsauswahl. +3. Sucht in der Liste die Veranstaltung anhand von Besitzer, Veranstaltungstyp und Datum. +4. Klickt auf die gewünschte Veranstaltung. +5. Wartet, bis die Präsentationssteuerung erscheint. +6. Prüft oben in der Steuerung, ob Veranstaltungstyp und Datum zur gewünschten Veranstaltung passen. + +### Auf eine andere Veranstaltung wechseln + +1. Öffnet in der Präsentationssteuerung das Ordner-Symbol. +2. Wählt die neue Veranstaltung aus der Liste. +3. Kontrolliert anschließend in der Steuerung die angezeigten Veranstaltungsdaten. +4. Prüft den Monitor: Er sollte wieder mit der Veranstaltungsfolie starten. + +### Wenn keine Veranstaltung angezeigt wird + +1. Prüft, ob die Veranstaltung im Veranstaltungsbereich vorhanden ist. +2. Prüft, ob das Datum der Veranstaltung korrekt gesetzt ist. +3. Prüft, ob die Veranstaltung für die Präsentation freigegeben ist. +4. Wenn weiterhin nichts erscheint, bittet eine leitende oder administrative Person um Prüfung. + +## Tipps für den Live-Betrieb + +- Wählt die Veranstaltung rechtzeitig vor Beginn aus, bevor der Monitor für Publikum sichtbar ist. +- Kontrolliert immer Datum und Veranstaltungstyp, besonders wenn mehrere ähnliche Veranstaltungen existieren. +- Wechselt Veranstaltungen nicht nebenbei während eines Liedes, sondern möglichst in einer Pause oder auf einer leeren Folie. +- Sprecht euch im Team ab, wer die Veranstaltung auswählt. Wenn mehrere Personen gleichzeitig bedienen, kann es zu unerwarteten Wechseln kommen. +- Nach einem Wechsel ist die Veranstaltungsfolie ein guter Ausgangspunkt: Von dort könnt ihr gezielt Lied, Abschnitt, freien Text oder Leerseite auswählen. + +## Links + +- [Präsentationssteuerung](praesentation-steuerung.md) +- [Präsentationsmonitor](praesentation-monitor.md) diff --git a/man/pages/praesentation-monitor.md b/man/pages/praesentation-monitor.md new file mode 100644 index 0000000..64c6c4f --- /dev/null +++ b/man/pages/praesentation-monitor.md @@ -0,0 +1,88 @@ +# Präsentationsmonitor + +## Zweck + +Der Präsentationsmonitor ist die Ausgabe für Beamer, Bildschirm oder Livestream. Er zeigt genau den Inhalt, der in der Präsentationssteuerung ausgewählt wird: Veranstaltungsfolie, leere Folie, freien Text oder Liedabschnitte. + +Der Monitor ist nicht zum Bedienen gedacht. Die Bedienung erfolgt in der Präsentationssteuerung, während der Monitor für die sichtbare Ausgabe geöffnet bleibt. + +## Berechtigung + +Der Monitor gehört zum Präsentationsbereich und ist für angemeldete Benutzer mit der Berechtigung **Präsentator** vorgesehen. Administratoren können ihn ebenfalls öffnen. + +Im Live-Betrieb sollte der Monitor auf dem Gerät geöffnet werden, das mit Beamer, Display oder Streaming-Ausgabe verbunden ist. + +## Seitenelemente + +- Vollbildfläche: füllt die Anzeige und ist für die Ausgabe an Publikum oder Stream gedacht. +- Logo: erscheint auf Start-, Leer- oder Textzuständen, abhängig vom gewählten Hintergrund. +- Veranstaltungsfolie: zeigt Veranstaltungstyp und Datum. +- Leere Folie: zeigt keinen Liedtext und keinen freien Text. +- Freier Text: zeigt die in der Steuerung eingetragene Überschrift und den Text. +- Liedanzeige: zeigt den aktuellen Liedtitel und den ausgewählten Liedabschnitt. +- Rechtliche Hinweise: erscheinen bei Liedern, wenn entsprechende Angaben vorhanden sind. +- Hintergrund: übernimmt die in der Steuerung gewählte Hintergrundoption. +- Textgröße: übernimmt den in der Steuerung gesetzten Zoom. + +## Schritt-für-Schritt-Aktionen + +### Monitor starten + +1. Öffnet zuerst die Präsentationssteuerung. +2. Prüft, ob oben die richtige Veranstaltung angezeigt wird. +3. Klickt auf `Präsentation starten`. +4. Bringt das Monitorfenster auf den Beamer, das Ausgabedisplay oder den Stream-Bildschirm. +5. Prüft die sichtbare Ausgabe. + +Der Monitor versucht, als Vollbildausgabe zu erscheinen. Falls euer Browser oder Betriebssystem eine Bestätigung verlangt, bestätigt den Vollbildmodus. + +### Richtige Ausgabe prüfen + +1. Schaltet in der Steuerung auf `Veranstaltung`. +2. Prüft am Monitor Veranstaltungstyp und Datum. +3. Schaltet testweise auf `Leer`. +4. Schaltet auf ein Lied und einen Liedabschnitt. +5. Prüft, ob Textgröße, Hintergrund und Lesbarkeit passen. +6. Schaltet vor Beginn wieder auf die gewünschte Startfolie. + +### Folie oder Abschnitt anzeigen + +1. Lasst den Monitor geöffnet. +2. Bedient Inhalte ausschließlich über die Präsentationssteuerung. +3. Wählt dort `Veranstaltung`, `Leer`, `Freier Text`, ein Lied oder einen Abschnitt. +4. Beobachtet am Monitor, ob der Wechsel sichtbar angekommen ist. + +### Freien Text anzeigen + +1. Wählt in der Steuerung `Freier Text`. +2. Gebt Überschrift und Text ein. +3. Kontrolliert am Monitor, ob der Text gut lesbar ist. +4. Passt bei Bedarf Zeilenumbrüche oder Zoom an. + +### Hintergrund und Zoom kontrollieren + +1. Ändert Hintergrund und Zoom in der Präsentationssteuerung. +2. Prüft die Darstellung direkt am Monitor. +3. Achtet auf ausreichenden Kontrast und ruhige Zeilenumbrüche. +4. Wählt bei schlechter Lesbarkeit einen einfacheren Hintergrund oder eine andere Textgröße. + +### Monitor nach Veranstaltungswechsel prüfen + +1. Wenn in der Auswahl eine andere Veranstaltung gewählt wurde, lasst den Monitor kurz sichtbar prüfen. +2. Kontrolliert, ob Veranstaltungstyp und Datum zur neuen Veranstaltung passen. +3. Startet bei Bedarf den Monitor neu über `Präsentation starten`. + +## Tipps für den Live-Betrieb + +- Öffnet den Monitor vor Veranstaltungsbeginn und prüft ihn auf dem echten Ausgabegerät, nicht nur auf dem Bediengerät. +- Testet vor Publikum mindestens Startfolie, ein Lied, freien Text, Hintergrund und Zoom. +- Lasst den Mauszeiger und andere Fenster nicht auf der Ausgabe liegen. +- Achtet darauf, dass Browserleisten, Systemmeldungen oder Benachrichtigungen nicht sichtbar sind. +- Bei unerwarteter Anzeige hilft oft ein ruhiger Ablauf: in der Steuerung `Leer` wählen, richtige Veranstaltung prüfen, dann den gewünschten Inhalt erneut auswählen. +- Wenn der Monitor nicht auf Änderungen reagiert, prüft zuerst, ob Steuerung und Monitor dieselbe Veranstaltung zeigen. +- Für Livestreams sollte eine zweite Person die Ausgabe beobachten, weil Probleme dort oft später auffallen als am Bediengerät. + +## Links + +- [Präsentationssteuerung](praesentation-steuerung.md) +- [Präsentation auswählen](praesentation-auswaehlen.md) diff --git a/man/pages/praesentation-steuerung.md b/man/pages/praesentation-steuerung.md new file mode 100644 index 0000000..8d24acf --- /dev/null +++ b/man/pages/praesentation-steuerung.md @@ -0,0 +1,115 @@ +# Präsentationssteuerung + +## Zweck + +Die Präsentationssteuerung ist die Bedienoberfläche für den Live-Betrieb. Hier wählt ihr aus, was der Monitor zeigt: die Veranstaltungsfolie, eine leere Fläche, ein Lied, einen bestimmten Liedabschnitt oder freien Text. + +Außerdem stellt ihr hier den Hintergrund und die Textgröße ein und startet den Monitor für Beamer oder Display. + +## Berechtigung + +Die Steuerung ist für angemeldete Benutzer mit der Berechtigung **Präsentator** vorgesehen. Administratoren können die Steuerung ebenfalls öffnen. + +Die Rolle sollte nur Personen erhalten, die während einer Veranstaltung bewusst Inhalte auf den Präsentationsmonitor schalten dürfen. + +## Seitenelemente + +- Kopfbereich mit Veranstaltungstyp und Datum: zeigt, welche Veranstaltung gerade aktiv ist. +- Ordner-Symbol: öffnet die Auswahl einer anderen Veranstaltung. +- `Veranstaltung`: zeigt die Titelfolie mit Veranstaltungstyp und Datum. +- `Leer`: zeigt eine leere Präsentationsfläche. +- Liedtitel: wählt ein Lied aus. +- Liedabschnitte: schalten direkt auf einen bestimmten Abschnitt, zum Beispiel Strophe oder Refrain. In der Kachel steht zusätzlich die erste Textzeile zur Orientierung. +- `Freier Text`: zeigt eine eigene Überschrift und einen eigenen Text auf dem Monitor. +- Feld `Überschrift`: Überschrift für den freien Text. +- Feld `Text`: Inhalt für den freien Text. Zeilenumbrüche können für eine bessere Lesbarkeit genutzt werden. +- Button `Präsentation starten`: öffnet den Monitor. +- Auswahl `Hintergrund`: setzt den Hintergrund für die Monitoranzeige. +- Zoom-Regler: verändert die Textgröße auf dem Monitor. +- Lied hinzufügen: fügt während der Veranstaltung weitere Lieder zur aktuellen Veranstaltung hinzu, sofern diese Funktion eingeblendet ist. + +## Schritt-für-Schritt-Aktionen + +### Veranstaltungsfolie anzeigen + +1. Prüft oben, ob die richtige Veranstaltung angezeigt wird. +2. Klickt auf `Veranstaltung`. +3. Kontrolliert den Monitor: Er zeigt Veranstaltungstyp und Datum. + +Diese Folie eignet sich für den Start, für Pausen und als neutraler Zustand vor dem nächsten Inhalt. + +### Leere Folie anzeigen + +1. Klickt auf `Leer`. +2. Kontrolliert den Monitor: Es wird keine Lied- oder Textfolie angezeigt. + +Die leere Folie eignet sich, wenn auf der Bühne gesprochen wird, wenn Inhalte vorbereitet werden oder wenn kurz nichts projiziert werden soll. + +### Lied auswählen + +1. Sucht das gewünschte Lied in der Liste. +2. Klickt auf den Liedtitel, wenn das Lied vorbereitet werden soll. +3. Klickt auf einen konkreten Liedabschnitt, wenn dieser sofort angezeigt werden soll. +4. Nutzt die Vorschauzeile in den Abschnittskacheln, um den richtigen Einstieg zu finden. + +Bei Liedern zeigt der Monitor den Liedtext ohne Akkorde. Rechtliche Hinweise werden auf dem Monitor ergänzt, soweit sie für das Lied hinterlegt sind. + +### Abschnitt während eines Liedes wechseln + +1. Behaltet die Reihenfolge der Liedabschnitte in der Steuerung im Blick. +2. Klickt rechtzeitig vor dem gewünschten Wechsel auf die nächste Abschnittskachel. +3. Nutzt bei Wiederholungen die Abschnittsbezeichnung und die erste Textzeile, nicht nur die Position in der Liste. + +### Freien Text nutzen + +1. Klickt auf `Freier Text`. +2. Tragt im Feld `Überschrift` eine kurze Überschrift ein. +3. Tragt im Feld `Text` den eigentlichen Text ein. +4. Setzt Zeilenumbrüche dort, wo der Text auf dem Monitor gut lesbar umbrechen soll. +5. Kontrolliert den Monitor und passt Text oder Zoom bei Bedarf an. + +Freier Text eignet sich für kurze Hinweise, Bibelstellen, Gebetsanliegen, Ansagen oder ungeplante Inhalte. Haltet ihn im Live-Betrieb eher kurz, damit er aus der Entfernung lesbar bleibt. + +### Hintergrund ändern + +1. Öffnet die Auswahl `Hintergrund`. +2. Wählt eine der Optionen: + - `kein Hintergrund` + - `Sternenhimmel` + - `Blätter` + - `Leder` + - `Lobpreis` + - `Bibel` +3. Prüft am Monitor, ob Text und Hintergrund zusammen gut lesbar sind. + +Ein ruhiger Hintergrund ist oft besser für Liedtexte. Auffälligere Hintergründe eignen sich eher für Startfolie, freien Text oder Pausen. + +### Zoom einstellen + +1. Bewegt den Zoom-Regler nach rechts, um Text größer darzustellen. +2. Bewegt den Zoom-Regler nach links, um Text kleiner darzustellen. +3. Prüft den Monitor aus typischer Publikumsentfernung. +4. Achtet darauf, dass lange Zeilen und Liedabschnitte noch vollständig und ruhig wirken. + +### Monitor starten + +1. Wählt zuerst die richtige Veranstaltung aus. +2. Öffnet die Präsentationssteuerung. +3. Klickt auf `Präsentation starten`. +4. Verschiebt das Monitorfenster bei Bedarf auf den Beamer oder das Ausgabedisplay. +5. Prüft, ob die gewünschte Folie sichtbar ist. + +## Tipps für den Live-Betrieb + +- Legt vor Beginn fest, wer die Steuerung bedient und wer den Monitor beobachtet. +- Prüft vor Veranstaltungsbeginn Veranstaltung, Hintergrund, Zoom und erste Folie. +- Nutzt `Leer`, bevor ihr unsichere Inhalte vorbereitet oder ungeplante Änderungen vornehmt. +- Klickt Abschnitte bewusst und nicht mehrfach schnell hintereinander; beobachtet kurz, ob der Monitor den Wechsel übernommen hat. +- Haltet freien Text kurz und gut gegliedert. Für längere Texte sind mehrere kurze Blöcke meist besser als eine volle Folie. +- Verändert Zoom und Hintergrund möglichst vor Beginn oder in ruhigen Momenten, nicht mitten im gemeinsamen Singen. +- Wenn ein Lied fehlt, fügt es frühzeitig hinzu und prüft danach, ob es in der Liste an der erwarteten Stelle erscheint. + +## Links + +- [Präsentation auswählen](praesentation-auswaehlen.md) +- [Präsentationsmonitor](praesentation-monitor.md) diff --git a/man/pages/veranstaltung-anlegen.md b/man/pages/veranstaltung-anlegen.md new file mode 100644 index 0000000..74bef0a --- /dev/null +++ b/man/pages/veranstaltung-anlegen.md @@ -0,0 +1,72 @@ +# Veranstaltung anlegen + +## Zweck + +Auf der Seite **Neue Veranstaltung** legst du den Grundrahmen einer Veranstaltung an. Du wählst die Art der Veranstaltung und das Datum. Danach wechselst du automatisch in die Details, um Lieder hinzuzufügen und den Ablauf vorzubereiten. + +## Berechtigung + +Du brauchst die Berechtigung **Lobpreisleiter**, um eine Veranstaltung anzulegen. Benutzer mit der Berechtigung **Administrator** dürfen diese Aktion ebenfalls ausführen. + +Wenn du den Button **Neue Veranstaltung anlegen** nicht siehst oder die Seite nicht öffnen kannst, fehlt dir wahrscheinlich die passende Berechtigung. + +## Seitenelemente + +### Art der Veranstaltung + +In diesem Feld wählst du, um welche Art von Veranstaltung es geht. Die Auswahl ist in zwei Gruppen gegliedert: + +- **öffentlich** +- **privat** + +Öffentliche Arten sind zum Beispiel Gottesdienste oder andere öffentliche Veranstaltungen. Private Arten sind zum Beispiel Hauskreis, Gebetskreis, Teeniekreis, Kinderkreis oder sonstige private Veranstaltungen. + +Die Auswahl ist wichtig, weil sie später beeinflusst, ob eine Veranstaltung als öffentlich oder geschlossen angezeigt wird und ob nach der Veröffentlichung eine CCLI-Meldung relevant sein kann. + +### Datum + +Im Feld **Datum** wählst du das Veranstaltungsdatum aus. Du kannst das Datum direkt eintragen oder über den Kalender auswählen. + +### Anlegen + +Mit **Anlegen** erstellst du die Veranstaltung. Danach öffnet sich die Detailseite der neuen Veranstaltung. + +## Schritt-für-Schritt-Aktionen + +### Neue Veranstaltung starten + +1. Öffne die [Veranstaltungsliste](veranstaltungen-liste.md). +2. Klicke im Bereich **Meine Veranstaltungen** auf **Neue Veranstaltung anlegen**. +3. Die Seite **Neue Veranstaltung** wird geöffnet. + +### Veranstaltung anlegen + +1. Öffne das Feld **Art der Veranstaltung**. +2. Wähle die passende öffentliche oder private Veranstaltungsart. +3. Wähle im Feld **Datum** das Datum der Veranstaltung. +4. Klicke auf **Anlegen**. +5. Die neue Veranstaltung wird geöffnet. + +### Danach Lieder hinzufügen + +1. Bleibe auf der geöffneten Detailseite. +2. Nutze **Lied hinzufügen...**, um Lieder auszuwählen. +3. Bringe die Lieder in die gewünschte Reihenfolge. +4. Prüfe bei Bedarf Tonarten und Liedtexte. + +Die weiteren Schritte sind in den [Veranstaltungsdetails](veranstaltung-details.md) beschrieben. + +## Hinweise und Fehlervermeidung + +- **Art der Veranstaltung** und **Datum** sind Pflichtangaben. +- Wähle die Art sorgfältig aus. Öffentliche Veranstaltungen können nach der Veröffentlichung eine CCLI-Meldung auslösen, wenn CCLI-pflichtige Lieder enthalten sind. +- Die Veranstaltung ist nach dem Anlegen noch nicht veröffentlicht. Du kannst sie zuerst in Ruhe vorbereiten. +- Lieder werden nicht auf dieser Seite ausgewählt, sondern anschließend in den Veranstaltungsdetails. +- Wenn du versehentlich die falsche Art oder das falsche Datum gewählt hast, kannst du die Kopfdaten bei einer unveröffentlichten Veranstaltung über **Ändern** korrigieren. + +## Links + +- [Veranstaltungsliste](veranstaltungen-liste.md) +- [Veranstaltungsdetails](veranstaltung-details.md) +- [Veranstaltung bearbeiten](veranstaltung-bearbeiten.md) +- [Berechtigungen und Rollen](../berechtigungen.md) diff --git a/man/pages/veranstaltung-bearbeiten.md b/man/pages/veranstaltung-bearbeiten.md new file mode 100644 index 0000000..76f73d8 --- /dev/null +++ b/man/pages/veranstaltung-bearbeiten.md @@ -0,0 +1,80 @@ +# Veranstaltung bearbeiten + +## Zweck + +Auf der Seite **Veranstaltung ändern** bearbeitest du die Kopfdaten einer bestehenden Veranstaltung. Dazu gehören die Art der Veranstaltung und das Datum. + +Die Seite ist für Korrekturen am Rahmen der Veranstaltung gedacht. Lieder, Reihenfolge, Veröffentlichung, Archivierung, Teilen, CCLI-Meldung und Downloads verwaltest du auf der [Detailseite](veranstaltung-details.md). + +## Berechtigung + +Der Einstieg zur Bearbeitung ist auf der Detailseite nur sichtbar, wenn alle folgenden Punkte zutreffen: + +- Du hast die Berechtigung **Lobpreisleiter** oder **Administrator**. +- Du bist Besitzer der Veranstaltung. +- Die Veranstaltung ist noch nicht veröffentlicht. + +Wenn die Veranstaltung bereits veröffentlicht ist, erscheint die Aktion **Ändern** nicht. Ziehe bei Bedarf zuerst die Veröffentlichung zurück. + +## Seitenelemente + +### Art der Veranstaltung + +Hier änderst du die Veranstaltungsart. Die Auswahl ist in **öffentlich** und **privat** gegliedert. + +Die Art beschreibt, um was für eine Veranstaltung es sich handelt, zum Beispiel Gottesdienst, Hauskreis, Gebetskreis oder eine sonstige Veranstaltung. + +### Datum + +Hier änderst du das Veranstaltungsdatum. Du kannst das Datum direkt eintragen oder über den Kalender auswählen. + +### Speichern + +Mit **Speichern** übernimmst du die Änderungen und kehrst zur Detailseite zurück. + +### Schließen oder Zurück + +Über den Schließen- oder Zurück-Link der Karte kommst du ohne weitere Bearbeitung zurück zur Veranstaltung. + +## Schritt-für-Schritt-Aktionen + +### Bearbeitung öffnen + +1. Öffne die [Veranstaltungsdetails](veranstaltung-details.md) der eigenen unveröffentlichten Veranstaltung. +2. Klicke auf **Ändern**. +3. Die Seite **Veranstaltung ändern** wird geöffnet. + +### Art der Veranstaltung ändern + +1. Öffne das Feld **Art der Veranstaltung**. +2. Wähle die passende neue Art aus. +3. Prüfe, ob das Datum weiterhin stimmt. +4. Klicke auf **Speichern**. + +### Datum ändern + +1. Öffne das Feld **Datum** oder den Kalender. +2. Wähle das korrekte Datum. +3. Prüfe, ob die Art der Veranstaltung weiterhin stimmt. +4. Klicke auf **Speichern**. + +### Zur Veranstaltung zurückkehren + +1. Klicke nach dem Speichern automatisch zurück zur Detailseite. +2. Prüfe dort die geänderten Angaben im Kopfbereich. +3. Fahre mit Liedern, Reihenfolge oder Veröffentlichung fort. + +## Hinweise und Fehlervermeidung + +- Bearbeite Kopfdaten möglichst vor der Veröffentlichung. +- Wenn **Ändern** nicht sichtbar ist, prüfe zuerst, ob die Veranstaltung veröffentlicht ist oder ob du Besitzer der Veranstaltung bist. +- **Art der Veranstaltung** und **Datum** dürfen nicht leer bleiben. +- Änderungen an Liedern, Liedreihenfolge, Tonarten oder Liedtexten erfolgen nicht hier, sondern in den Veranstaltungsdetails. +- Wenn du eine öffentliche Veranstaltungsart wählst, denke nach dem Veröffentlichen an eine mögliche CCLI-Meldung. + +## Links + +- [Veranstaltungsdetails](veranstaltung-details.md) +- [Veranstaltungsliste](veranstaltungen-liste.md) +- [Veranstaltung anlegen](veranstaltung-anlegen.md) +- [Berechtigungen und Rollen](../berechtigungen.md) diff --git a/man/pages/veranstaltung-details.md b/man/pages/veranstaltung-details.md new file mode 100644 index 0000000..4a8a384 --- /dev/null +++ b/man/pages/veranstaltung-details.md @@ -0,0 +1,216 @@ +# Veranstaltungsdetails + +## Zweck + +Die Veranstaltungsdetails sind der zentrale Arbeitsbereich für eine einzelne Veranstaltung. Hier siehst du Datum, Art, Status, Besitzer, Liedliste und alle Aktionen, die für diese Veranstaltung möglich sind. + +Auf dieser Seite bereitest du die Liedreihenfolge vor, fügst Lieder hinzu, passt Lieder für genau diese Veranstaltung an, veröffentlichst die Veranstaltung, teilst sie, erledigst die CCLI-Meldung und lädst Dokumente herunter. + +## Berechtigung + +Die Detailseite kann von berechtigten Benutzern geöffnet werden, wenn sie Zugriff auf Veranstaltungen haben. + +Einige Aktionen sind zusätzlich eingeschränkt: + +- **Archivieren**, **Wiederherstellen**, **Veröffentlichen**, **Veröffentlichung zurückziehen**, **Teilen**, **CCLI** und **Ändern** sind nur für **Lobpreisleiter** sichtbar, die Besitzer dieser Veranstaltung sind. +- **Ändern** ist nur bei unveröffentlichten Veranstaltungen sichtbar. +- **Herunterladen** ist auf der Detailseite als allgemeine Aktion verfügbar. +- Veröffentlichte Veranstaltungen sind weitgehend geschützt: Reihenfolge, Kopfdaten und Lieder können dann nicht mehr wie in einem Entwurf bearbeitet werden. + +## Seitenelemente + +### Kopfbereich + +Oben steht die Art der Veranstaltung, das Datum und der Status, zum Beispiel **entwurf**, **veröffentlicht** oder **gemeldet**. + +Darunter siehst du: + +- ob die Veranstaltung **öffentlich** oder **geschlossen** ist +- wer die Veranstaltung erstellt hat +- bei eigenen Veranstaltungen den Veröffentlichungsstatus +- bei eigenen Veranstaltungen den CCLI-Meldestatus, falls relevant + +### Öffentliche und geschlossene Veranstaltungen + +Eine **öffentliche Veranstaltung** ist für die Veröffentlichung und gegebenenfalls für eine CCLI-Meldung relevant. Wenn in einer öffentlichen Veranstaltung CCLI-pflichtige Lieder verwendet werden, erscheint nach dem Veröffentlichen die Aufgabe **CCLI**. + +Eine **geschlossene Veranstaltung** ist nicht öffentlich. Beim Veröffentlichen wird sie als veröffentlicht markiert, aber normalerweise ist keine CCLI-Meldung notwendig. + +### Liedliste + +Die Liedliste zeigt alle Lieder der Veranstaltung in der geplanten Reihenfolge. Je nach Zustand der Veranstaltung kannst du: + +- die Reihenfolge per Ziehen ändern +- die Tonart eines Liedes für diese Veranstaltung ändern +- den Liedtext für diese Veranstaltung bearbeiten +- ein Lied aus der Veranstaltung entfernen +- Liedtexte ein- oder ausblenden + +Bei veröffentlichten Veranstaltungen ist die Liedliste nicht mehr frei bearbeitbar. + +### Text anzeigen + +Mit **Text anzeigen** blendest du die Liedtexte ein. Dann siehst du die Texte und, je nach Einstellung des Liedes, auch Akkorde. + +Solange **Text anzeigen** aktiv ist, ist die Reihenfolge nicht per Ziehen änderbar. Schalte die Textanzeige aus, wenn du die Liedreihenfolge anpassen möchtest. + +### Anzeige- und Vollbildaktionen + +Über die Symbole im Kopfbereich kannst du: + +- den Text vergrößern +- den Text verkleinern +- die Vollbildansicht öffnen oder schließen + +In der Vollbildansicht wird jedes Lied einzeln angezeigt. Zusätzlich siehst du die Uhrzeit und, wenn vorhanden, den nächsten Liedtitel. Mit den Pfeiltasten kannst du durch die Lieder wechseln. + +### Lied hinzufügen + +Bei unveröffentlichten Veranstaltungen erscheint unten **Lied hinzufügen...**. Dort kannst du ein Lied suchen und zur Veranstaltung hinzufügen. + +Das hinzugefügte Lied wird am Ende der aktuellen Reihenfolge eingefügt. + +### Aktionsleiste + +Je nach Berechtigung und Status siehst du diese Aktionen: + +- **Archivieren** +- **Wiederherstellen** +- **Veröffentlichen** +- **Veröffentlichung zurückziehen** +- **Teilen** +- **CCLI** +- **Ändern** +- **Herunterladen** + +Unter **Herunterladen** stehen zwei Varianten: + +- **Ablauf für Lobpreisgruppe** +- **Handout mit Copyright Infos** + +## Schritt-für-Schritt-Aktionen + +### Liedreihenfolge ändern + +1. Öffne eine unveröffentlichte eigene Veranstaltung. +2. Stelle sicher, dass **Text anzeigen** ausgeschaltet ist. +3. Greife ein Lied am Verschiebebereich. +4. Ziehe es an die gewünschte Position. +5. Lass es los. + +Die neue Reihenfolge wird für die Veranstaltung übernommen. + +### Lied hinzufügen + +1. Öffne eine unveröffentlichte eigene Veranstaltung. +2. Gehe zum Feld **Lied hinzufügen...**. +3. Öffne die Auswahl. +4. Suche nach dem gewünschten Lied. +5. Wähle das Lied aus. + +Das Lied erscheint anschließend in der Liedliste. + +### Tonart für ein Lied ändern + +1. Öffne eine unveröffentlichte Veranstaltung. +2. Suche das Lied in der Liste. +3. Klicke auf die angezeigte Tonart. +4. Wähle die gewünschte Tonart aus. + +Die Änderung gilt für dieses Lied in dieser Veranstaltung. + +### Liedtext für diese Veranstaltung bearbeiten + +1. Öffne eine unveröffentlichte Veranstaltung. +2. Klicke beim Lied auf **Lied für diese Veranstaltung bearbeiten**. +3. Passe den Text an. +4. Klicke auf **Speichern**. + +Mit **Verwerfen** verlässt du die Bearbeitung ohne Übernahme. Die Bearbeitung betrifft nur diese Veranstaltung, nicht den allgemeinen Liedbestand. + +### Lied aus der Veranstaltung entfernen + +1. Öffne eine unveröffentlichte Veranstaltung. +2. Suche das Lied in der Liste. +3. Klicke auf **Lied aus Veranstaltung entfernen**. + +Das Lied wird aus dieser Veranstaltung entfernt. + +### Veranstaltung veröffentlichen + +1. Prüfe Liedauswahl und Reihenfolge. +2. Klicke auf **Veröffentlichen**. +3. Die Veranstaltung wird als veröffentlicht markiert. + +Wenn es sich um eine öffentliche Veranstaltung mit CCLI-pflichtigen Liedern handelt, erscheint danach der Status **nicht gemeldet** und die Aktion **CCLI**. + +### Veröffentlichung zurückziehen + +1. Öffne eine veröffentlichte eigene Veranstaltung. +2. Klicke auf **Veröffentlichung zurückziehen**. +3. Die Veranstaltung wird wieder unveröffentlicht. + +Danach können Vorbereitungsschritte wieder bearbeitet werden. + +### Veranstaltung teilen + +1. Veröffentliche die Veranstaltung. +2. Klicke auf **Teilen**. +3. Es öffnet sich ein Dialog mit Link und QR-Code. +4. Nutze **Teilen**, um den Link weiterzugeben, oder kopiere den angezeigten Link. +5. Schließe den Dialog mit **Schließen**. + +Der Link führt zur Gastansicht der Veranstaltung. + +### CCLI-Meldung abschließen + +1. Veröffentliche eine öffentliche Veranstaltung. +2. Wenn **CCLI** erscheint, klicke auf **CCLI**. +3. Lies die Liste der CCLI-Titel und CCLI-Nummern. +4. Öffne die Meldelinks zu den Titeln. +5. Melde die Titel im CCLI-Portal. +6. Klicke danach auf **Alle CCLI-Titel wurden gemeldet**. + +Die Veranstaltung wird anschließend als gemeldet markiert. Klicke nicht auf diese Bestätigung, bevor die Meldung wirklich erfolgt ist. + +### Veranstaltung archivieren + +1. Öffne eine eigene Veranstaltung. +2. Klicke auf **Archivieren**. +3. Lies den Hinweis im Dialog. +4. Bestätige mit **Archivieren** oder brich mit **Abbrechen** ab. + +Archivierte Veranstaltungen verschwinden aus den normalen Listen. Du findest eigene archivierte Veranstaltungen wieder über den Filter **Archiviert** in der [Veranstaltungsliste](veranstaltungen-liste.md). + +### Veranstaltung wiederherstellen + +1. Aktiviere in der Veranstaltungsliste den Filter **Archiviert**. +2. Öffne die archivierte Veranstaltung. +3. Klicke auf **Wiederherstellen**. + +Die Veranstaltung erscheint danach wieder ohne Archiv-Filter. + +### Dokument herunterladen + +1. Öffne die Veranstaltung. +2. Klicke auf **Herunterladen**. +3. Wähle **Ablauf für Lobpreisgruppe**, wenn du einen Ablauf mit Liedtexten und Akkorden brauchst. +4. Wähle **Handout mit Copyright Infos**, wenn du ein Handout ohne Akkorde, aber mit Copyright-Informationen brauchst. + +## Hinweise und Fehlervermeidung + +- Veröffentliche erst, wenn Datum, Veranstaltungstyp, Liedauswahl und Reihenfolge stimmen. +- Ziehe die Veröffentlichung zurück, wenn du nachträglich größere Änderungen am Ablauf vornehmen musst. +- Die CCLI-Meldung ist nur dann abgeschlossen, wenn die Titel tatsächlich im CCLI-Portal gemeldet wurden. +- Bei öffentlichen Veranstaltungen mit CCLI-pflichtigen Liedern bleibt die Veranstaltung in **Meine Veranstaltungen** sichtbar, bis die Meldung abgeschlossen ist. +- Archiviere nur Veranstaltungen, die im normalen Alltag nicht mehr gebraucht werden. +- Prüfe vor dem Teilen, ob die Liedreihenfolge stimmt. Gäste sehen die geteilte Veranstaltung in der vorbereiteten Reihenfolge. +- Wenn du die Reihenfolge nicht ändern kannst, ist entweder die Veranstaltung veröffentlicht oder **Text anzeigen** ist eingeschaltet. + +## Links + +- [Veranstaltungsliste](veranstaltungen-liste.md) +- [Veranstaltung anlegen](veranstaltung-anlegen.md) +- [Veranstaltung bearbeiten](veranstaltung-bearbeiten.md) +- [Gastansicht](gastansicht.md) +- [Berechtigungen und Rollen](../berechtigungen.md) diff --git a/man/pages/veranstaltungen-liste.md b/man/pages/veranstaltungen-liste.md new file mode 100644 index 0000000..8cf15b9 --- /dev/null +++ b/man/pages/veranstaltungen-liste.md @@ -0,0 +1,104 @@ +# Veranstaltungsliste + +## Zweck + +Die Veranstaltungsliste ist der Einstieg in den Bereich **Veranstaltungen**. Hier findest du veröffentlichte Veranstaltungen, deine eigenen noch offenen Veranstaltungen und bei passender Berechtigung auch Filter für eine gezielte Suche. + +Die Seite hilft dir dabei, eine Veranstaltung zu öffnen, eine neue Veranstaltung anzulegen oder ältere eigene Veranstaltungen wiederzufinden. + +## Berechtigung + +Du brauchst eine Anmeldung mit der Berechtigung **Lobpreisleiter** oder **Lobpreisgruppe**, um den Bereich Veranstaltungen zu öffnen. + +- **Lobpreisleiter** können eigene Veranstaltungen anlegen und verwalten. +- **Lobpreisgruppe** können veröffentlichte Veranstaltungen ansehen. +- **Administrator** haben umfassenden Zugriff. +- Filter und Seitenmenü sind für **Lobpreisleiter** und **Administrator** sichtbar. + +## Seitenelemente + +### Meine Veranstaltungen + +Dieser Bereich zeigt deine eigenen Veranstaltungen, die noch Aufmerksamkeit brauchen: + +- unveröffentlichte Veranstaltungen +- veröffentlichte öffentliche Veranstaltungen, bei denen die CCLI-Meldung noch offen ist +- archivierte eigene Veranstaltungen, wenn der Filter **Archiviert** eingeschaltet ist + +Mögliche Hinweise an einer Veranstaltung: + +- **unveröffentlicht**: Die Veranstaltung ist noch ein Entwurf und kann weiter vorbereitet werden. +- **nicht gemeldet**: Die Veranstaltung ist veröffentlicht, aber die CCLI-Meldung ist noch nicht abgeschlossen. +- **archiviert**: Die Veranstaltung wurde aus der normalen Liste ausgeblendet und ist nur über den Archiv-Filter sichtbar. + +### Veröffentlichte Veranstaltungen + +Dieser Bereich zeigt veröffentlichte, nicht archivierte Veranstaltungen. Sie sind für berechtigte Benutzer sichtbar und können geöffnet, gelesen und heruntergeladen werden. + +### Listeneinträge + +Jede Veranstaltung wird mit diesen Angaben angezeigt: + +- Datum +- Ersteller +- Art der Veranstaltung +- optionaler Statushinweis + +Klicke auf einen Eintrag, um die [Veranstaltungsdetails](veranstaltung-details.md) zu öffnen. + +### Filter + +Wenn du die passende Berechtigung hast, steht links oder über das Menü ein Filterbereich zur Verfügung: + +- **Zeitraum**: grenzt veröffentlichte Veranstaltungen zeitlich ein. +- **Ersteller**: zeigt Veranstaltungen einer bestimmten Person oder alle Ersteller. +- **Art der Veranstaltung**: filtert nach Gottesdienst, Hauskreis, Gebetskreis und weiteren Typen. +- **Archiviert**: blendet archivierte eigene Veranstaltungen ein. + +Wenn ein Filter aktiv ist, zeigt die Liste eine Hinweiszeile mit der Anzahl der angezeigten Veranstaltungen und den Link **Filter zurücksetzen**. + +## Schritt-für-Schritt-Aktionen + +### Veranstaltung öffnen + +1. Öffne den Bereich **Veranstaltungen**. +2. Suche die Veranstaltung in **Meine Veranstaltungen** oder **Veröffentlichte Veranstaltungen**. +3. Klicke auf den Listeneintrag. +4. Die Detailseite der Veranstaltung wird geöffnet. + +### Neue Veranstaltung anlegen + +1. Öffne den Bereich **Veranstaltungen**. +2. Suche im Bereich **Meine Veranstaltungen** den Button **Neue Veranstaltung anlegen**. +3. Klicke auf den Button. +4. Fülle auf der nächsten Seite Art und Datum aus. + +Der Button ist nur sichtbar, wenn du Veranstaltungen anlegen darfst. + +### Filter anwenden + +1. Öffne den Filterbereich. +2. Wähle einen Zeitraum, Ersteller oder eine Art der Veranstaltung aus. +3. Aktiviere bei Bedarf **Archiviert**. +4. Die Liste wird passend zur Auswahl aktualisiert. + +### Filter zurücksetzen + +1. Achte auf die Hinweiszeile **Filter aktiv**. +2. Klicke auf **Filter zurücksetzen**. +3. Die Liste zeigt wieder die Standardauswahl. + +## Hinweise und Fehlervermeidung + +- Archivierte Veranstaltungen erscheinen nicht in den normalen Listen. Aktiviere **Archiviert**, wenn du eine ältere eigene Veranstaltung suchst. +- Der Bereich **Meine Veranstaltungen** ist besonders wichtig für offene Aufgaben, zum Beispiel unveröffentlichte Entwürfe oder noch nicht gemeldete CCLI-Titel. +- Veröffentlichte Veranstaltungen sind nicht automatisch bearbeitbar. Änderungen erfolgen über die Detailseite und nur mit passender Berechtigung. +- Wenn du keine Schaltfläche zum Anlegen siehst, fehlt dir vermutlich die Berechtigung **Lobpreisleiter**. +- Wenn ein Filter aktiv ist und du eine Veranstaltung nicht findest, setze den Filter zurück. + +## Links + +- [Veranstaltungsdetails](veranstaltung-details.md) +- [Veranstaltung anlegen](veranstaltung-anlegen.md) +- [Veranstaltung bearbeiten](veranstaltung-bearbeiten.md) +- [Berechtigungen und Rollen](../berechtigungen.md) diff --git a/man/tutorials/benutzer-und-berechtigungen.md b/man/tutorials/benutzer-und-berechtigungen.md new file mode 100644 index 0000000..cfcbe5a --- /dev/null +++ b/man/tutorials/benutzer-und-berechtigungen.md @@ -0,0 +1,79 @@ +# Benutzer und Berechtigungen + +## Ziel + +Du verstehst, wie Benutzer freigeschaltet werden, welche Rollen wofür gedacht sind und wie ein Administrator Rollen vergibt oder ändert. + +## Voraussetzungen und Berechtigungen + +- Registrierung und Passwort-Zurücksetzung sind ohne Rolle möglich. +- Das eigene Profil kann jeder angemeldete Benutzer öffnen. +- Benutzerverwaltung und Rollenvergabe brauchen die Berechtigung **Administrator**. + +## Neuer Benutzer + +1. Wähle auf der Anmeldung `neuen Benutzer anlegen`. +2. Trage Name, E-Mail-Adresse und Passwort ein. +3. Sende die Registrierung ab. +4. Nach der Registrierung erscheint die Willkommensseite für neue Benutzer ohne Rollen. +5. Bitte einen Administrator um Freischaltung. +6. Melde dich nach der Freischaltung erneut an oder lade die Anwendung neu. + +## Eigenes Profil pflegen + +1. Öffne dein Benutzerprofil. +2. Prüfe deinen Namen und deine Rollen. +3. Stelle deine bevorzugte Akkordanzeige ein. +4. Nutze `Abmelden`, wenn du die Sitzung beenden willst. + +## Rollen vergeben oder ändern + +1. Melde dich mit der Berechtigung **Administrator** an. +2. Öffne dein Benutzerprofil. +3. Gehe zur Liste `registrierte Benutzer`. +4. Wähle den Benutzer aus, den du freischalten oder ändern willst. +5. Prüfe den Namen. +6. Weise die passenden Rollen zu. +7. Schließe die Bearbeitung. +8. Bitte den Benutzer, die Anwendung neu zu laden oder sich neu anzumelden, falls die neuen Rechte nicht sofort sichtbar sind. + +## Rollen im Alltag + +- Benutzer: Lieder ansehen und Lieddatenbank nutzen. +- Lobpreisgruppe: Veranstaltungen ansehen, soweit der Veranstaltungsbereich freigegeben ist. +- Lobpreisleiter: Veranstaltungen anlegen, eigene Veranstaltungen bearbeiten, veröffentlichen, teilen, archivieren und CCLI-Meldungen abschließen. +- Präsentator: Präsentation auswählen, Präsentationssteuerung nutzen und Monitor starten. +- Mitarbeiter: Lieder anlegen und bearbeiten. +- Administrator: Benutzer verwalten und administrative Aufgaben durchführen. + +## Typische Rollenpakete + +- Normale Liednutzung: Benutzer +- Teammitglied mit Veranstaltungszugriff: Benutzer und Lobpreisgruppe +- Veranstaltungsleitung: Benutzer, Lobpreisgruppe und Lobpreisleiter +- Präsentationsteam: Präsentator, bei Bedarf zusätzlich Benutzer +- Liedpflege: Benutzer und Mitarbeiter +- Administration: Administrator + +## Wenn etwas nicht sichtbar ist + +1. Prüfe zuerst, ob der Benutzer angemeldet ist. +2. Prüfe im Profil die angezeigten Rollen. +3. Prüfe, ob die Aufgabe eine Besitzer-Einschränkung hat. Viele Aktionen an Veranstaltungen sind nur für die Person sichtbar, die die Veranstaltung angelegt hat. +4. Prüfe, ob der Status passt. Manche Aktionen sind nur bei unveröffentlichten Veranstaltungen sichtbar, andere erst nach der Veröffentlichung. +5. Passe die Rollen nur so weit an, wie es für die Aufgabe nötig ist. + +## Ergebnis + +Benutzer erhalten genau die Berechtigungen, die sie für ihre Aufgaben brauchen. Neue Benutzer werden kontrolliert freigeschaltet, und fehlende Buttons lassen sich meist über Rollen, Besitz oder Veranstaltungsstatus erklären. + +## Links + +- [Erste Schritte](erste-schritte.md) +- [Lied finden und nutzen](lied-finden-und-nutzen.md) +- [Neue Veranstaltung planen](neue-veranstaltung-planen.md) +- [Präsentation durchführen](praesentation-durchfuehren.md) +- [Anmelden](../pages/anmelden.md) +- [Benutzerprofil](../pages/benutzerprofil.md) +- [Benutzer anlegen](../pages/benutzer-anlegen.md) +- [Berechtigungen und Rollen](../berechtigungen.md) diff --git a/man/tutorials/ccli-meldung-und-handout.md b/man/tutorials/ccli-meldung-und-handout.md new file mode 100644 index 0000000..9fba16b --- /dev/null +++ b/man/tutorials/ccli-meldung-und-handout.md @@ -0,0 +1,59 @@ +# CCLI-Meldung und Handout + +## Ziel + +Du prüfst nach einer veröffentlichten Veranstaltung die meldepflichtigen CCLI-Lieder, meldest sie extern und lädst bei Bedarf Ablauf- oder Handout-Dokumente herunter. + +## Voraussetzungen und Berechtigungen + +- Du bist angemeldet. +- Für die CCLI-Meldung brauchst du die Berechtigung **Lobpreisleiter**. +- Die Veranstaltung gehört dir. +- Die Veranstaltung ist veröffentlicht. +- Eine CCLI-Meldung wird nur angezeigt, wenn meldepflichtige CCLI-Lieder in der Veranstaltung vorhanden sind. + +## CCLI-Meldung abschließen + +1. Öffne `Veranstaltungen`. +2. Öffne deine veröffentlichte Veranstaltung. +3. Achte auf den Melde-Status: + - `nicht gemeldet`: Es gibt noch zu meldende CCLI-Lieder. + - `gemeldet`: Die Meldung wurde in wgenerator als erledigt markiert. + - kein Meldehinweis: Für diese Veranstaltung ist keine Meldung erforderlich. +4. Wähle die CCLI-Meldung. +5. Prüfe die angezeigte Liste der CCLI-Titel. +6. Öffne die angegebenen CCLI-Links und melde die Lieder im CCLI-Reporting. +7. Wenn alle Titel extern gemeldet wurden, wähle `Alle CCLI-Titel wurden gemeldet`. +8. Prüfe, ob der Status der Veranstaltung nun `gemeldet` zeigt. + +## Dokumente herunterladen + +1. Öffne die Veranstaltung. +2. Wähle den Download für Dokumente. +3. Entscheide dich für die passende Variante: + - `Ablauf für Lobpreisgruppe`: für Band, Leitung oder Probe mit Texten und Akkorden. + - `Handout mit Copyright Infos`: für Weitergabe ohne Akkorde und mit Copyright-Hinweisen. +4. Öffne die heruntergeladene Datei und prüfe: + - Reihenfolge der Lieder + - Lesbarkeit + - Copyright-Informationen + - passende Version für den Einsatzzweck + +## Wann welches Dokument? + +- Für Probe und musikalische Vorbereitung ist der Ablauf für die Lobpreisgruppe geeignet. +- Für Teilnehmende, Gaeste oder Ablage ist das Handout mit Copyright-Informationen geeigneter. +- Für eine veröffentlichte oder geteilte Veranstaltung sollte das Dokument erst nach der letzten inhaltlichen Prüfung erstellt werden. + +## Ergebnis + +Die CCLI-pflichtigen Lieder sind extern gemeldet und die Veranstaltung ist in wgenerator als gemeldet markiert. Zusätzlich liegen die passenden Unterlagen für Band, Leitung oder Weitergabe vor. + +## Links + +- [Veranstaltung veröffentlichen und teilen](veranstaltung-veroeffentlichen-und-teilen.md) +- [Neue Veranstaltung planen](neue-veranstaltung-planen.md) +- [Präsentation durchführen](praesentation-durchfuehren.md) +- [Veranstaltungsdetails](../pages/veranstaltung-details.md) +- [Veranstaltungsliste](../pages/veranstaltungen-liste.md) +- [Lieddetails](../pages/lied-details.md) diff --git a/man/tutorials/erste-schritte.md b/man/tutorials/erste-schritte.md new file mode 100644 index 0000000..0782b8c --- /dev/null +++ b/man/tutorials/erste-schritte.md @@ -0,0 +1,48 @@ +# Erste Schritte + +## Ziel + +Du meldest dich an, prüfst deine Berechtigungen und findest den passenden Einstieg für deine nächste Aufgabe. + +## Voraussetzungen und Berechtigungen + +- Du hast einen bestehenden Benutzeraccount oder registrierst dich neu. +- Für Lieder brauchst du die Berechtigung **Benutzer**. +- Für Veranstaltungen brauchst du je nach Aufgabe die Berechtigung **Lobpreisleiter** oder **Lobpreisgruppe**. +- Für die Live-Präsentation brauchst du die Berechtigung **Präsentator**. +- Für Liedpflege brauchst du die Berechtigung **Mitarbeiter**. +- Für Benutzerverwaltung brauchst du die Berechtigung **Administrator**. + +## Schritte + +1. Öffne die Anwendung und wähle die Anmeldung. +2. Gib deine E-Mail-Adresse und dein Passwort ein. +3. Melde dich an. Wenn du dein Passwort vergessen hast, wähle `Passwort zurücksetzen`, gib deine E-Mail-Adresse ein und folge dem Link in der E-Mail. +4. Wenn du noch keinen Account hast, wähle `neuen Benutzer anlegen`, trage Name, E-Mail-Adresse und Passwort ein und sende die Registrierung ab. +5. Prüfe nach der Anmeldung dein Profil. Dort siehst du deinen Namen, deine Rollen und deine bevorzugte Akkordanzeige. +6. Stelle bei Bedarf die Akkordanzeige ein: + - keine Auswahl: Standardanzeige + - `nur den Liedtext anzeigen`: Akkorde ausblenden + - `in Strophen die Akkorde nur für die erste anzeigen`: Akkorde nur in der ersten Strophe anzeigen + - `alle anzeigen`: Akkorde anzeigen +7. Wenn du nach der Registrierung auf einer Willkommensseite ohne weitere Bereiche landest, warte auf die Freischaltung durch einen Administrator. +8. Wähle deinen Arbeitsbereich: + - Lieder suchen und ansehen: weiter mit [Lied finden und nutzen](lied-finden-und-nutzen.md) + - Veranstaltung vorbereiten: weiter mit [Neue Veranstaltung planen](neue-veranstaltung-planen.md) + - Live steuern: weiter mit [Präsentation durchführen](praesentation-durchfuehren.md) + - Benutzer freischalten: weiter mit [Benutzer und Berechtigungen](benutzer-und-berechtigungen.md) + +## Ergebnis + +Du bist angemeldet, kennst deine Rollen und weißt, welcher Bereich für deine Aufgabe zuständig ist. Wenn dir ein Bereich fehlt, kann ein Administrator deine Rollen prüfen und anpassen. + +## Links + +- [Lied finden und nutzen](lied-finden-und-nutzen.md) +- [Neue Veranstaltung planen](neue-veranstaltung-planen.md) +- [Präsentation durchführen](praesentation-durchfuehren.md) +- [Benutzer und Berechtigungen](benutzer-und-berechtigungen.md) +- [Anmelden](../pages/anmelden.md) +- [Benutzerprofil](../pages/benutzerprofil.md) +- [Benutzer anlegen](../pages/benutzer-anlegen.md) +- [Passwort zurücksetzen](../pages/passwort-zuruecksetzen.md) diff --git a/man/tutorials/index.md b/man/tutorials/index.md new file mode 100644 index 0000000..3caca8f --- /dev/null +++ b/man/tutorials/index.md @@ -0,0 +1,30 @@ +# Tutorials + +Diese Tutorials führen dich Schritt für Schritt durch typische Aufgaben in wgenerator. Sie sind nach Anwenderzielen sortiert: erst anmelden und orientieren, dann Lieder nutzen, Veranstaltungen vorbereiten, veröffentlichen, präsentieren und nachbereiten. + +## Einstieg + +- [Erste Schritte](erste-schritte.md): anmelden, Profil prüfen, Rollen verstehen und den passenden Bereich finden. +- [Lied finden und nutzen](lied-finden-und-nutzen.md): ein Lied suchen, Details prüfen und es in einer Veranstaltung verwenden. +- [Neue Veranstaltung planen](neue-veranstaltung-planen.md): Veranstaltung anlegen, Lieder hinzufügen und den Ablauf vorbereiten. + +## Durchfuehrung und Teilen + +- [Veranstaltung veröffentlichen und teilen](veranstaltung-veroeffentlichen-und-teilen.md): Ablauf freigeben, Gastlink erzeugen und bei Bedarf die Veröffentlichung zurückziehen. +- [Präsentation durchführen](praesentation-durchfuehren.md): Veranstaltung auswählen, Monitor starten und Folien live steuern. + +## Nachbereitung und Verwaltung + +- [CCLI-Meldung und Handout](ccli-meldung-und-handout.md): meldepflichtige Lieder erfassen und Unterlagen herunterladen. +- [Benutzer und Berechtigungen](benutzer-und-berechtigungen.md): Registrierung, Freischaltung, Rollenvergabe und eigene Anzeigeeinstellungen. + +## Welche Rolle brauche ich? + +- Mit Benutzer kannst du die Lieddatenbank öffnen und Lieder ansehen. +- Mit **Lobpreisleiter** kannst du Veranstaltungen anlegen, eigene Veranstaltungen bearbeiten, veröffentlichen, teilen und melden. +- Mit Präsentator kannst du die Präsentation steuern und den Monitor nutzen. +- Mit **Mitarbeiter** kannst du neue Lieder anlegen und vorhandene Lieder bearbeiten. +- Mit **Administrator** kannst du Benutzer verwalten und Rollen vergeben. + +Wenn dir ein Button oder Menüpunkt fehlt, liegt es meist an der fehlenden Rolle oder daran, dass die Veranstaltung nicht dir gehört. Lies dazu [Benutzer und Berechtigungen](benutzer-und-berechtigungen.md). + diff --git a/man/tutorials/lied-finden-und-nutzen.md b/man/tutorials/lied-finden-und-nutzen.md new file mode 100644 index 0000000..522d74c --- /dev/null +++ b/man/tutorials/lied-finden-und-nutzen.md @@ -0,0 +1,56 @@ +# Lied finden und nutzen + +## Ziel + +Du findest ein passendes Lied in der Lieddatenbank, prüfst Text und Angaben und verwendest es in einer eigenen Veranstaltung. + +## Voraussetzungen und Berechtigungen + +- Du bist angemeldet. +- Zum Öffnen der Lieddatenbank brauchst du die Berechtigung **Benutzer**. +- Zum Hinzufügen eines Liedes zu einer Veranstaltung brauchst du die Berechtigung **Lobpreisleiter**. +- Zum Bearbeiten oder Anlegen von Liedern brauchst du die Berechtigung **Mitarbeiter**. +- Du kannst ein Lied nur direkt zu einer eigenen unveröffentlichten Veranstaltung hinzufügen. + +## Schritte + +1. Öffne den Bereich `Lieder`. +2. Suche nach Titel, Textteilen, Liednummer oder passenden Begriffen. +3. Nutze bei Bedarf die Filter: + - Liedtyp, zum Beispiel Praise, Worship oder Misc + - Tonart und Dur/Moll + - parallele Tonart + - rechtlicher Status + - vorhandene Attribute +4. Wenn die Trefferliste zu eng ist, setze den Filter zurück und suche breiter. +5. Öffne das Lied, das du verwenden möchtest. +6. Prüfe die wichtigsten Angaben: + - Titel und Liednummer + - Tonart und Tempo + - Liedtext + - Akkordanzeige nach deiner Profileinstellung + - Copyright- und CCLI-Informationen + - Hinweise, Kommentare und Anhänge +7. Wenn du das Lied in einer Veranstaltung nutzen willst, wähle `Zu Veranstaltung hinzufügen`. +8. Wähle eine eigene unveröffentlichte Veranstaltung aus. +9. Öffne die Veranstaltung und prüfe dort die Position des Liedes im Ablauf. +10. Passe in der Veranstaltung bei Bedarf die Tonart oder den Liedtext für genau diese Veranstaltung an. + +## Ergebnis + +Das Lied ist gefunden, geprüft und bei Bedarf in deiner Veranstaltung eingeplant. Änderungen innerhalb der Veranstaltung betreffen nur diese Veranstaltung; die allgemeine Lieddatenbank bleibt dadurch unverändert. + +## Wenn etwas fehlt + +- Fehlt der Button zum Hinzufügen, prüfe, ob du Lobpreisleiter bist und eine eigene unveröffentlichte Veranstaltung hast. +- Fehlt der Bearbeiten-Button, brauchst du die Berechtigung **Mitarbeiter**. +- Ist ein Lied rechtlich oder inhaltlich unklar, bearbeite es nicht nebenbei in der Veranstaltung, sondern kläre die Liedpflege gezielt mit einer berechtigten Person. + +## Links + +- [Neue Veranstaltung planen](neue-veranstaltung-planen.md) +- [CCLI-Meldung und Handout](ccli-meldung-und-handout.md) +- [Benutzer und Berechtigungen](benutzer-und-berechtigungen.md) +- [Liedliste](../pages/lieder-liste.md) +- [Lieddetails](../pages/lied-details.md) +- [Veranstaltungsliste](../pages/veranstaltungen-liste.md) diff --git a/man/tutorials/neue-veranstaltung-planen.md b/man/tutorials/neue-veranstaltung-planen.md new file mode 100644 index 0000000..9a93c5b --- /dev/null +++ b/man/tutorials/neue-veranstaltung-planen.md @@ -0,0 +1,57 @@ +# Neue Veranstaltung planen + +## Ziel + +Du legst eine neue Veranstaltung an, stellst den Ablauf zusammen und bereitest ihn so vor, dass er später veröffentlicht, geteilt oder präsentiert werden kann. + +## Voraussetzungen und Berechtigungen + +- Du bist angemeldet. +- Zum Anlegen einer Veranstaltung brauchst du die Berechtigung **Lobpreisleiter**. +- Du kannst nur eigene Veranstaltungen veröffentlichen, teilen, archivieren und bearbeiten. +- Lieder kannst du nur vor der Veröffentlichung frei hinzufügen, entfernen und sortieren. + +## Schritte + +1. Öffne den Bereich `Veranstaltungen`. +2. Wähle `Neue Veranstaltung anlegen`. +3. Wähle die Art der Veranstaltung. +4. Wähle das Datum. +5. Lege die Veranstaltung an. Danach landest du in den Veranstaltungsdetails. +6. Füge Lieder hinzu: + - Suche nach dem Lied. + - Wähle das passende Lied aus. + - Wiederhole den Vorgang, bis der Ablauf vollständig ist. +7. Sortiere die Lieder in die gewünschte Reihenfolge. +8. Öffne bei Bedarf einzelne Lieder im Ablauf und passe sie für diese Veranstaltung an: + - Tonart für die Veranstaltung + - Liedtext für die Veranstaltung + - nicht benötigte Teile entfernen oder anpassen +9. Aktiviere `Text anzeigen`, um den Ablauf mit Liedtexten zu prüfen. +10. Nutze die Vollbildansicht, wenn du den Ablauf intern durchgehen oder proben möchtest. +11. Prüfe vor der Veröffentlichung: + - Stimmt die Reihenfolge? + - Sind alle benötigten Lieder enthalten? + - Sind Tonarten und Texte für die Band passend? + - Ist die Veranstaltung öffentlich oder geschlossen richtig eingeordnet? + - Sind CCLI-pflichtige Lieder erkennbar? + +## Ergebnis + +Die Veranstaltung ist als Entwurf vorbereitet. Sie kann nun veröffentlicht, als Gastansicht geteilt, für die Präsentation ausgewählt oder als Dokument heruntergeladen werden. + +## Nächste Schritte + +- Wenn der Ablauf final ist, lies [Veranstaltung veröffentlichen und teilen](veranstaltung-veroeffentlichen-und-teilen.md). +- Für Band- oder Ablaufunterlagen lies [CCLI-Meldung und Handout](ccli-meldung-und-handout.md). +- Für die Live-Ausgabe lies [Präsentation durchführen](praesentation-durchfuehren.md). + +## Links + +- [Lied finden und nutzen](lied-finden-und-nutzen.md) +- [Veranstaltung veröffentlichen und teilen](veranstaltung-veroeffentlichen-und-teilen.md) +- [Präsentation durchführen](praesentation-durchfuehren.md) +- [Veranstaltungsliste](../pages/veranstaltungen-liste.md) +- [Veranstaltung anlegen](../pages/veranstaltung-anlegen.md) +- [Veranstaltungsdetails](../pages/veranstaltung-details.md) +- [Liedliste](../pages/lieder-liste.md) diff --git a/man/tutorials/praesentation-durchfuehren.md b/man/tutorials/praesentation-durchfuehren.md new file mode 100644 index 0000000..8277904 --- /dev/null +++ b/man/tutorials/praesentation-durchfuehren.md @@ -0,0 +1,61 @@ +# Präsentation durchführen + +## Ziel + +Du wählst eine veröffentlichte Veranstaltung aus, startest die Monitor-Ausgabe und steuerst Titelfolie, Liedabschnitte, freien Text, Hintergrund und Schriftgröße live. + +## Voraussetzungen und Berechtigungen + +- Du bist angemeldet. +- Du hast die Berechtigung **Präsentator**. +- Die Veranstaltung ist veröffentlicht. +- Der Monitor läuft auf dem Gerät, das am Beamer oder Display angeschlossen ist. +- Die Präsentationssteuerung läuft auf dem Bediengerät. + +## Vorbereitung + +1. Öffne die Präsentationssteuerung im Bereich `Präsentation`. +2. Öffne die Veranstaltungsauswahl. +3. Wähle die passende Veranstaltung aus. Dadurch startet die Präsentation mit der Veranstaltungsfolie. +4. Öffne auf dem Ausgabegerät `Präsentation starten`. +5. Prüfe am Monitor: + - richtige Veranstaltung + - passende Titelfolie + - gute Lesbarkeit + - korrekter Hintergrund + +## Live-Steuerung + +1. Wähle `Veranstaltung`, um zur Titelfolie zurückzukehren. +2. Wähle `Leer`, wenn kurz nichts angezeigt werden soll. +3. Wähle einen Songtitel, wenn der Song vorbereitet werden soll, ohne direkt einen Abschnitt zu zeigen. +4. Wähle einen Liedabschnitt, um ihn auf dem Monitor anzuzeigen. +5. Wechsle während des Liedes Abschnitt für Abschnitt weiter. +6. Nutze `Freier Text`, wenn du eine spontane Einblendung brauchst: + - Überschrift eintragen + - Text eintragen + - `Freier Text` auswählen +7. Passe die Schriftgröße mit dem Zoom-Regler an die Raumgröße und den Beamer an. +8. Wähle bei Bedarf einen anderen Hintergrund. +9. Wenn während der Veranstaltung ein Lied fehlt, füge es live hinzu und wähle es anschließend in der Präsentationssteuerung aus. + +## Praktische Hinweise + +- Starte den Monitor vor Beginn und prüfe ihn aus Sicht der Teilnehmenden. +- Stelle die Schriftgröße lieber etwas größer ein, wenn der Raum tief ist. +- Nutze `Leer` für Pausen, Umbauten oder Momente ohne Projektion. +- Nutze `Freier Text` sparsam und prüfe Zeilenumbrüche sofort am Monitor. +- Wenn die falsche Veranstaltung aktiv ist, wähle sie erneut über die Veranstaltungsauswahl. + +## Ergebnis + +Die Live-Ausgabe zeigt immer den Inhalt, den du in der Präsentationssteuerung auswählst. Monitor und Remote bleiben auf derselben Veranstaltung, solange keine andere Veranstaltung ausgewählt wird. + +## Links + +- [Veranstaltung veröffentlichen und teilen](veranstaltung-veroeffentlichen-und-teilen.md) +- [Neue Veranstaltung planen](neue-veranstaltung-planen.md) +- [CCLI-Meldung und Handout](ccli-meldung-und-handout.md) +- [Präsentation steuern](../pages/praesentation-steuerung.md) +- [Präsentation auswählen](../pages/praesentation-auswaehlen.md) +- [Präsentationsmonitor](../pages/praesentation-monitor.md) diff --git a/man/tutorials/veranstaltung-veroeffentlichen-und-teilen.md b/man/tutorials/veranstaltung-veroeffentlichen-und-teilen.md new file mode 100644 index 0000000..50ed4ee --- /dev/null +++ b/man/tutorials/veranstaltung-veroeffentlichen-und-teilen.md @@ -0,0 +1,60 @@ +# Veranstaltung veröffentlichen und teilen + +## Ziel + +Du gibst eine vorbereitete Veranstaltung frei, machst sie für andere sichtbar und erzeugst bei Bedarf einen Gastlink mit QR-Code. + +## Voraussetzungen und Berechtigungen + +- Du bist angemeldet. +- Du hast die Berechtigung **Lobpreisleiter**. +- Die Veranstaltung gehört dir. +- Die Veranstaltung ist fertig vorbereitet. Wenn noch Lieder fehlen oder die Reihenfolge unsicher ist, arbeite zuerst mit [Neue Veranstaltung planen](neue-veranstaltung-planen.md). + +## Schritte + +1. Öffne `Veranstaltungen`. +2. Öffne deine unveröffentlichte Veranstaltung. +3. Prüfe den Ablauf noch einmal: + - Datum und Veranstaltungstyp + - Reihenfolge der Lieder + - Texte und Tonarten + - rechtliche Hinweise +4. Wähle `Veröffentlichen`. +5. Prüfe den neuen Status der Veranstaltung. +6. Wenn die Veranstaltung öffentlich ist und CCLI-pflichtige Lieder enthält, bleibt sie als `nicht gemeldet` markiert. Plane dann die Nachbereitung mit [CCLI-Meldung und Handout](ccli-meldung-und-handout.md). +7. Wenn du die Veranstaltung für Gaeste freigeben willst, wähle `Teilen`. +8. Nutze den angezeigten Link oder QR-Code: + - Link kopieren und versenden + - QR-Code auf Folien, Aushang oder Handout verwenden + - Teilen-Funktion des Geräts nutzen, falls angeboten +9. Öffne den Gastlink testweise, wenn du sicherstellen willst, dass die richtige Veranstaltung sichtbar ist. + +## Was sich nach der Veröffentlichung ändert + +- Die Veranstaltung erscheint bei den veröffentlichten Veranstaltungen. +- Der Ablauf ist für normale Bearbeitung weitgehend gesperrt. +- Neue Lieder werden nicht mehr wie im Entwurf hinzugefügt. +- Bearbeitung von Veranstaltungskopf und Liedern steht nicht mehr wie vorher zur Verfügung. +- Die Veranstaltung kann für die Präsentation ausgewählt werden. +- Bei öffentlichen Veranstaltungen kann eine CCLI-Meldung erforderlich sein. + +## Veröffentlichung zurückziehen + +1. Öffne die veröffentlichte Veranstaltung. +2. Wähle `Veröffentlichung zurückziehen`. +3. Bearbeite den Ablauf erneut. +4. Veröffentliche die Veranstaltung danach wieder, wenn sie fertig ist. + +## Ergebnis + +Die Veranstaltung ist freigegeben. Andere berechtigte Benutzer können sie in der Veranstaltungsliste sehen, das Präsentationsteam kann sie verwenden und Gaeste können sie über den geteilten Link öffnen. + +## Links + +- [Neue Veranstaltung planen](neue-veranstaltung-planen.md) +- [Präsentation durchführen](praesentation-durchfuehren.md) +- [CCLI-Meldung und Handout](ccli-meldung-und-handout.md) +- [Veranstaltungsliste](../pages/veranstaltungen-liste.md) +- [Veranstaltungsdetails](../pages/veranstaltung-details.md) +- [Gastansicht](../pages/gastansicht.md)