Installation

Hinweis: Für eine schnelle Inbetriebnahme folgen Sie dem Schnellstart.

Automatische Datenbankerstellung: Die Anwendungsdatenbank (MesoWorkerDb) wird beim ersten Start automatisch erstellt. Eine manuelle Erstellung ist nicht erforderlich. Der SQL-Benutzer in den ConnectionStrings muss die Berechtigung CREATE DATABASE besitzen. Nach der Erstellung reichen normale Lese-/Schreibrechte. Der automatische Prozess prüft beim Start, ob die Datenbank existiert, legt sie bei Bedarf an, erstellt alle benötigten Tabellen und richtet Standard-Benutzer und -Rollen ein.

Der MesoWorkerService kann auf zwei Arten betrieben werden:

Option 1: Windows-Dienst

Der Service wird als Windows-Dienst auf einem Server installiert und läuft permanent im Hintergrund.

Hinweis: Die Setup-Dateien für die Windows-Installation werden Ihnen von Ihrem Mesonic-Händler bereitgestellt.

Voraussetzungen:

Windows Server 2016 oder neuer
.NET 10 Runtime installiert
Netzwerkzugriff zur WinLine-Datenbank
SQL-Benutzer mit CREATE DATABASE-Rechten (die Anwendungsdatenbank wird beim ersten Start automatisch erstellt)

Installationsschritte:

Entpacken der Anwendung
- Entpacken Sie das von Ihrem Händler bereitgestellte MesoWorkerService-Archiv in ein Verzeichnis (z.B. C:\MesoWorkerService)
Konfigurationsdatei anpassen

WICHTIG: Konfigurieren Sie die appsettings.json VOR der Dienst-Installation!

Öffnen Sie die Datei appsettings.json im Installationsverzeichnis und passen Sie die Einstellungen an:
- ConnectionStrings: Datenbankverbindungen (SQL-Benutzer benötigt CREATE DATABASE-Rechte)
- License: Ihre Lizenzinformationen
Siehe Windows-Dienst Konfiguration für Details.

Installation als Windows-Dienst

Der Service kann als Windows-Dienst installiert werden. Öffnen Sie eine PowerShell-Konsole mit Administratorrechten und navigieren Sie zum Installationsverzeichnis.

Option A: Installation mit PowerShell (empfohlen)

# Service erstellen und konfigurieren
New-Service -Name "MESO-WorkerService" `
            -BinaryPathName "C:\MesoWorkerService\MesoWorkerService.exe" `
            -DisplayName "MESO Worker Service" `
            -Description "Automatisierungsdienst für Mesonic WinLine - E-Mail-Versand, Workflow-Erzeugung, Terminsynchronisation, OP-Versand und Überwachung" `
            -StartupType Automatic

# Service starten
Start-Service -Name "MESO-WorkerService"

# Service-Status prüfen
Get-Service -Name "MESO-WorkerService"

Option B: Installation mit sc.exe

REM Service erstellen
sc.exe create "MESO-WorkerService" binPath= "C:\MesoWorkerService\MesoWorkerService.exe" DisplayName= "MESO Worker Service" start= auto

REM Service-Beschreibung setzen
sc.exe description "MESO-WorkerService" "Automatisierungsdienst für Mesonic WinLine - E-Mail-Versand, Workflow-Erzeugung, Terminsynchronisation, OP-Versand und Überwachung"

REM Service starten
sc.exe start "MESO-WorkerService"

REM Service-Status prüfen
sc.exe query "MESO-WorkerService"

Service deinstallieren (falls erforderlich):

# Service stoppen und entfernen (PowerShell)
Stop-Service -Name "MESO-WorkerService"
Remove-Service -Name "MESO-WorkerService"

REM Service stoppen und entfernen (sc.exe)
sc.exe stop "MESO-WorkerService"
sc.exe delete "MESO-WorkerService"

Wichtig:

Passen Sie den Pfad C:\MesoWorkerService\MesoWorkerService.exe an Ihr Installationsverzeichnis an
Bei sc.exe ist das Leerzeichen nach binPath=, DisplayName= und start= erforderlich
Für weitere Unterstützung kontaktieren Sie den Support: [email protected]

Dienst starten

Starten Sie den Windows-Dienst über die Dienste-Verwaltung oder mit PowerShell:
```
Start-Service -Name "MESO-WorkerService"
```
Web-UI als Windows-Dienst (optional)

Neben dem Hintergrunddienst kann auch die Web-UI (MesoWorker.Blazor.Server.exe) als Windows-Dienst betrieben werden. Die Installation erfolgt analog, nur mit anderer EXE und anderem Dienstnamen:
```
New-Service -Name "MESO-WorkerService-WebUI" `
            -BinaryPathName "C:\MesoWorkerBlazor\MesoWorker.Blazor.Server.exe" `
            -DisplayName "MESO Worker Service Web-UI" `
            -Description "Web-Oberfläche des MESO WorkerService" `
            -StartupType Automatic

Start-Service -Name "MESO-WorkerService-WebUI"
```
Zu beachten:
- Der Port wird nicht über die Kommandozeile gesetzt, sondern in der appsettings.json der Web-UI unter Kestrel:Endpoints:Http:Url (Standard: http://*:5001). Die aus Visual Studio bekannte launchSettings.json gilt nur für Entwicklungsstarts und wird vom Dienst ignoriert.
- Der Port muss in der Windows-Firewall freigegeben sein.
- Läuft der Dienst unter einem eigenen Dienstkonto statt unter LocalSystem, benötigt dieses Konto eine URL-Reservierung für die Bindung an alle Adressen:
```
netsh http add urlacl url=http://*:5001/ user="DOMAIN\DienstKonto"
```
- Startmeldungen und Startfehler der Web-UI landen im Windows-Ereignisprotokoll unter der Quelle MESO-WorkerService-WebUI (Anwendungsprotokoll). Die Standard-Protokollstufe lässt sich über Logging:EventLog:LogLevel:Default in der appsettings.json anpassen.
- Web-UI und Hintergrunddienst sind getrennte Dienste und können unabhängig gestartet und gestoppt werden.

Vorteile der Windows-Dienst-Installation:

Direkter Zugriff auf lokale WinLine-Installation
Optimale Performance bei lokaler Datenbank
Vollständige Kontrolle über das System
Einfache Integration in bestehende Windows-Infrastruktur

Nachteile der Windows-Dienst-Installation:

Erfordert Windows Server-Umgebung
Manuelle Installation und Wartung
.NET 10 Runtime muss installiert werden

Option 2: Container-Deployment

Der Service wird als Container betrieben und kann auf verschiedenen Plattformen ausgeführt werden.

Hinweis: Für die Container-basierte Installation benötigen Sie Zugangsdaten für eine der unterstützten Container-Registries (GHCR oder ACR).

Verfügbare Container Images:

Die Images werden parallel in zwei Registries veröffentlicht. Sie können je nach Infrastruktur und Netzwerkanbindung die passende Quelle wählen – die Inhalte sind identisch.

Variante	Service Image	Blazor UI Image	Authentifizierung
GitHub Container Registry (GHCR) – Standard	`ghcr.io/css-edv-support/mesoworkerservice-service:latest`	`ghcr.io/css-edv-support/mesoworkerservice-blazor:latest`	GitHub-Benutzername + Personal Access Token (`ghp_...`)
Azure Container Registry (ACR) – Alternative	`csscontainers.azurecr.io/mesoworkerservice-service:latest`	`csscontainers.azurecr.io/mesoworkerservice-blazor:latest`	ACR-Benutzername + ACR-Passwort/Token

Welche Quelle wählen? GHCR ist der Standardweg und für die meisten Installationen ausreichend. ACR (csscontainers.azurecr.io) ist die Alternative für Kunden mit Azure-Infrastruktur, restriktiven Firewall-Regeln gegenüber ghcr.io oder bestehenden ACR-Pull-Workflows. Die Zugangsdaten für beide Registries erhalten Sie auf Anfrage vom CSS Support ([email protected]).

Voraussetzungen:

Container-Runtime (Docker oder Podman)
Netzwerkzugriff zum SQL Server und zur WinLine-Datenbank
SQL-Benutzer mit CREATE DATABASE-Rechten (die Anwendungsdatenbank wird beim ersten Start automatisch erstellt)
Zugangsdaten zu einer der Container-Registries (GHCR oder ACR – siehe Tabelle oben)

Deployment-Optionen:

Portainer Stacks (empfohlen, siehe Schritt-für-Schritt-Anleitung: Installation mit Portainer)
Docker Compose
Kubernetes / Docker Swarm

Installationsschritte (Docker Compose):

Stack-Datei erstellen

Erstellen Sie eine docker-compose.yml Datei (siehe Schritt-für-Schritt-Anleitung: Installation mit Portainer für ein vollständiges Beispiel).
Umgebungsvariablen konfigurieren

Passen Sie die Datenbankverbindungen, Lizenz und WinLine-Einstellungen an Ihre Umgebung an.
Container starten
```
docker-compose up -d
```

Für eine ausführliche Anleitung mit Portainer siehe Schritt-für-Schritt-Anleitung: Installation mit Portainer.

Vorteile des Container-Deployments:

Plattformunabhängig (Linux, Windows, macOS)
Einfache Skalierung und Deployment
Isolierte Umgebung mit definierten Abhängigkeiten
Keine lokale .NET-Installation erforderlich
Einfache Updates über Image-Tags
Geeignet für moderne DevOps-Umgebungen

Nachteile des Container-Deployments:

Erfordert Container-Runtime (Docker, Podman)
Zusätzliche Netzwerk-Konfiguration für Datenbankzugriff
Container-Orchestrierung kann komplex sein

Ressourcenempfehlungen:

Für detaillierte Empfehlungen zur Dimensionierung der Container-Ressourcen (CPU, RAM, Disk) auf Linux-Systemen siehe:

Ressourcenempfehlung für Docker Container - Umfassende Anleitung zur Ressourcenzuteilung für verschiedene Einsatzszenarien

Schritt-für-Schritt-Anleitung: Installation mit Portainer

Diese Anleitung beschreibt die Einrichtung des MesoWorkerService über die Portainer-Weboberfläche. Portainer ist eine grafische Verwaltungsoberfläche für Docker-Container.

Was Sie vorab benötigen

Bevor Sie beginnen, halten Sie folgende Informationen bereit:

Information	Beispiel	Woher?
SQL Server Adresse	`192.168.1.100` oder `sql-server.firma.local`	IT-Abteilung
SQL-Benutzername	`sa` oder `mesoworker`	IT-Abteilung
SQL-Passwort		IT-Abteilung
WinLine Systemdatenbank	`CWLSYSTEM`	WinLine-Administration
Kundennummer (Lizenz)	`12345`	Ihr Mesonic-Partner
Lizenznummer	`XXXX-XXXX-XXXX`	Ihr Mesonic-Partner
WinLine Server URL	`http://winline-server:8080`	IT-Abteilung
WinLine Pfad (Netzwerkfreigabe)	`\\winline-server\WinLine`	IT-Abteilung
Registry-Zugangsdaten	GHCR: GitHub-Token (`ghp_...`) oder ACR: Benutzername + Passwort	CSS Support

Hinweis zum SQL-Benutzer: Der SQL-Benutzer muss beim ersten Start die Berechtigung haben, eine neue Datenbank anzulegen (CREATE DATABASE-Recht). Die Datenbank MesoWorkerDb wird dann automatisch erstellt. Falls Ihr SQL-Benutzer dieses Recht nicht hat, bitten Sie Ihre IT-Abteilung, eine leere Datenbank mit dem Namen MesoWorkerDb vorab anzulegen.

Schritt 1: In Portainer einloggen

Öffnen Sie Ihren Webbrowser
Navigieren Sie zur Portainer-Adresse (z.B. https://portainer.firma.local:9443)
Melden Sie sich mit Ihrem Portainer-Benutzernamen und Passwort an

Schritt 2: Container-Registry einrichten

Damit Portainer die MesoWorkerService-Images herunterladen kann, muss die Container-Registry einmalig hinterlegt werden. Sie können wahlweise die GitHub Container Registry (GHCR) oder die Azure Container Registry (ACR) verwenden – die Images sind in beiden Registries identisch.

Variante A: GitHub Container Registry (Standard)

Klicken Sie in der linken Seitenleiste auf Registries
Klicken Sie auf Add registry
Wählen Sie Custom registry
Füllen Sie die Felder aus:
- Name: GitHub CSS
- Registry URL: ghcr.io
- Authentication: aktivieren
- Username: Ihr GitHub-Benutzername
- Password: Ihr GitHub-Token (beginnt mit ghp_)
Klicken Sie auf Add registry

Variante B: Azure Container Registry (Alternative)

Klicken Sie in der linken Seitenleiste auf Registries
Klicken Sie auf Add registry
Wählen Sie Azure (oder alternativ Custom registry)
Füllen Sie die Felder aus:
- Name: CSS Azure
- Registry URL: csscontainers.azurecr.io
- Authentication: aktivieren
- Username: Ihr ACR-Benutzername
- Password: Ihr ACR-Passwort/-Token
Klicken Sie auf Add registry

Diesen Schritt müssen Sie nur einmalig durchführen. Die Zugangsdaten (GitHub-Token oder ACR-Benutzer) erhalten Sie vom CSS Support ([email protected]).

Wichtig: Wenn Sie ACR verwenden, müssen Sie in den Stack-Definitionen weiter unten die Image-Pfade von ghcr.io/css-edv-support/... auf csscontainers.azurecr.io/... umstellen (siehe Hinweis in Schritt 4).

Schritt 3: Neuen Stack anlegen

Klicken Sie in der linken Seitenleiste auf Stacks
Klicken Sie auf Add stack
Vergeben Sie einen Namen, z.B. mesoworkerservice
Wählen Sie Web editor als Methode

Schritt 4: Stack-Definition einfügen

Kopieren Sie die folgende Stack-Definition in den Web-Editor. Ersetzen Sie anschließend die Platzhalter (alle Werte in GROSSBUCHSTABEN) mit Ihren tatsächlichen Daten:

Hinweis zur Image-Quelle: Das folgende Beispiel verwendet GHCR. Wenn Sie stattdessen ACR nutzen möchten, ersetzen Sie die beiden image:-Zeilen wie folgt:

ghcr.io/css-edv-support/mesoworkerservice-blazor:latest → csscontainers.azurecr.io/mesoworkerservice-blazor:latest

ghcr.io/css-edv-support/mesoworkerservice-service:latest → csscontainers.azurecr.io/mesoworkerservice-service:latest

Die in Schritt 2 hinterlegte Registry muss zur gewählten Image-Quelle passen.

version: '3.8'

services:
  mesoworkerservice-ui:
    image: ghcr.io/css-edv-support/mesoworkerservice-blazor:latest
    container_name: mesoworkerservice-ui
    restart: unless-stopped
    ports:
      - "8012:5000"
    volumes:
      # DataProtection-Schlüssel persistieren, damit Anmeldungen einen
      # Container-Neustart/-Update überstehen (sonst werden alle Benutzer abgemeldet).
      - mesoworker-keys:/app/keys
    environment:
      - ASPNETCORE_ENVIRONMENT=Production
      - ASPNETCORE_URLS=http://+:5000
      - TZ=Europe/Berlin
      - ConnectionStrings__ConnectionString=Data Source=IHR-SQL-SERVER;Initial Catalog=MesoWorkerDb;User ID=IHR-SQL-USER;Password=IHR-SQL-PASSWORT;TrustServerCertificate=true
      - ConnectionStrings__WinLineSystemDBConnectionString=Data Source=IHR-SQL-SERVER;Initial Catalog=CWLSYSTEM;User ID=IHR-SQL-USER;Password=IHR-SQL-PASSWORT;TrustServerCertificate=true
    # Docker-Log begrenzen (3 x 10 MB). Ohne diesen Block rotiert Docker NICHT
    # und der Datenträger des Hosts läuft mit der Zeit voll.
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"
        compress: "true"

  mesoworkerservice:
    image: ghcr.io/css-edv-support/mesoworkerservice-service:latest
    container_name: mesoworkerservice
    restart: unless-stopped
    ports:
      - "8013:5000"
    volumes:
      - type: bind
        source: //IHR-WINLINE-SERVER/WinLine
        target: /app/winline
        read_only: true
      # Protokolldateien des Workers (Rotation: 14 Dateien x max. 50 MB)
      - mesoworker-logs:/app/logs
    environment:
      - ASPNETCORE_ENVIRONMENT=Production
      - DOTNET_RUNNING_IN_CONTAINER=true
      - ASPNETCORE_URLS=http://+:5000
      - TZ=Europe/Berlin
      - LANG=de_DE.UTF-8
      - LICENSE_CUSTOMER_NR=IHRE-KUNDENNUMMER
      - LICENSE_LICENSE_NR=IHRE-LIZENZNUMMER
      - ConnectionStrings__ConnectionString=Data Source=IHR-SQL-SERVER;Initial Catalog=MesoWorkerDb;User ID=IHR-SQL-USER;Password=IHR-SQL-PASSWORT;TrustServerCertificate=true
      - ConnectionStrings__WinLineSystemDBConnectionString=Data Source=IHR-SQL-SERVER;Initial Catalog=CWLSYSTEM;User ID=IHR-SQL-USER;Password=IHR-SQL-PASSWORT;TrustServerCertificate=true
      - WinLineSettings__WinLinePath=/app/winline/
      - WinLineSettings__MesospoolServiceUrl=http://IHR-WINLINE-SERVER:42024
      - WinLineSettings__TemplateForWorkflowImport=101
      - WinLineServer__Url=http://IHR-WINLINE-SERVER:8080
      - SessionSettings__MinimumSessions=1
      - SessionSettings__DefaultUser=IHR-WINLINE-USER
      - SessionSettings__DefaultPassword=IHR-WINLINE-PASSWORT
      - SessionSettings__ValidationInterval=01:00:00
      - Quartz__MailWorkerJob__scheduler=* * * * * ?
      - Quartz__MailWorkerJob__enabled=true
      - Quartz__MailWorkerJob__startnow=true
      - Quartz__NoRuleWarningJob__scheduler=0 0 8 * * ?
      - Quartz__NoRuleWarningJob__enabled=true
      - Quartz__NoRuleWarningJob__startnow=false
      - Quartz__OrderLineWorkerJob__scheduler=0 */5 * * * ?
      - Quartz__OrderLineWorkerJob__enabled=true
      - Quartz__OrderLineWorkerJob__startnow=true
      - Quartz__AppointmentWorkerJob__scheduler=0 */10 * * * ?
      - Quartz__AppointmentWorkerJob__enabled=true
      - Quartz__AppointmentWorkerJob__startnow=false
      - Quartz__OpenItemWorkerJob__scheduler=0 0 7 * * ?
      - Quartz__OpenItemWorkerJob__enabled=true
      - Quartz__OpenItemWorkerJob__startnow=false
      - Quartz__NextCloudCalendarSyncJob__scheduler=0 */10 * * * ?
      - Quartz__NextCloudCalendarSyncJob__enabled=true
      - Quartz__NextCloudCalendarSyncJob__startnow=false
      # Open Banking und Berichtswesen sind im Standard AUS – bei lizenziertem Modul auf true setzen
      - Quartz__BankingWorkerJob__scheduler=0 0 6 * * ?
      - Quartz__BankingWorkerJob__enabled=false
      - Quartz__BankingWorkerJob__startnow=false
      - Quartz__ReportWorkerJob__scheduler=0 */5 * * * ?
      - Quartz__ReportWorkerJob__enabled=false
      - Quartz__ReportWorkerJob__startnow=false
      # API-Schlüssel für die HTTP-Endpunkte (siehe Abschnitt "HTTP-Schnittstelle und API-Schlüssel").
      # Ohne diesen Wert sind die Endpunkte UNGESCHÜTZT erreichbar.
      - ApiAuth__Key=IHR-API-SCHLUESSEL
      # Protokolldateien begrenzen – Pfad muss zum Volume /app/logs passen
      - Serilog__WriteTo__1__Args__path=/app/logs/MESOWorkerService-.txt
      - Serilog__WriteTo__1__Args__rollOnFileSizeLimit=true
      - Serilog__WriteTo__1__Args__fileSizeLimitBytes=52428800
      - Serilog__WriteTo__1__Args__retainedFileCountLimit=14
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:5000/health"]
      interval: 3600s
      timeout: 10s
      retries: 3
      start_period: 60s
    deploy:
      resources:
        limits:
          memory: 1G
          cpus: '1.0'
        reservations:
          memory: 512M
          cpus: '0.5'
    # Docker-Log begrenzen (3 x 10 MB), siehe Hinweis beim UI-Dienst
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"
        compress: "true"

volumes:
  # Persistente Ablage der DataProtection-Schlüssel der Admin-Oberfläche
  mesoworker-keys:
  # Protokolldateien des Workers
  mesoworker-logs:

Wichtig – Protokolle begrenzen: Lassen Sie die logging:-Blöcke und die Serilog-Grenzen im Stack nicht weg. Ohne sie rotiert Docker die Konsolenausgabe nicht, und die Protokolldateien des Workers wachsen unbegrenzt. In der Praxis ist dadurch bereits ein Datenträger vollgelaufen. Einzelheiten und die Obergrenzen finden Sie unter Protokollierung.

Welche Platzhalter müssen ersetzt werden?

Platzhalter	Ersetzen durch	Beispiel
`IHR-SQL-SERVER`	Adresse Ihres SQL Servers	`192.168.1.100`
`IHR-SQL-USER`	SQL-Benutzername	`sa`
`IHR-SQL-PASSWORT`	SQL-Passwort
`IHR-API-SCHLUESSEL`	Frei gewählter, langer Zufallswert zum Schutz der HTTP-Endpunkte	`openssl rand -hex 32`
`CWLSYSTEM`	Name der WinLine-Systemdatenbank (meist `CWLSYSTEM`)	`CWLSYSTEM`
`IHRE-KUNDENNUMMER`	Lizenz-Kundennummer	`12345`
`IHRE-LIZENZNUMMER`	Lizenznummer	`XXXX-XXXX-XXXX`
`IHR-WINLINE-SERVER`	WinLine-Server Adresse	`192.168.1.50`
`IHR-WINLINE-USER`	WinLine-Benutzername	`ADMIN`
`IHR-WINLINE-PASSWORT`	WinLine-Passwort

Tipp: Die Platzhalter kommen teilweise mehrfach vor (z.B. IHR-SQL-SERVER in beiden Services). Nutzen Sie die Suchen-und-Ersetzen-Funktion Ihres Browsers (Strg+H), um alle Vorkommen auf einmal zu ersetzen.

Schritt 5: Stack deployen

Prüfen Sie, ob alle Platzhalter ersetzt wurden
Klicken Sie auf Deploy the stack
Warten Sie, bis beide Container gestartet sind (Status: running)

Beim ersten Start wird die Datenbank MesoWorkerDb automatisch auf Ihrem SQL Server angelegt. Das kann einige Sekunden dauern.

Schritt 6: Admin-Oberfläche öffnen

Öffnen Sie im Browser: http://IHR-SERVER:8012 (Port aus der Stack-Definition)
Melden Sie sich an:
- Benutzername: Admin
- Passwort: (leer lassen, beim ersten Login wird ein Passwort vergeben)
Richten Sie über die Oberfläche die gewünschten Module ein (SMTP-Konten, Workflow-Einstellungen, Mail-Einstellungen etc.)

Fehlerbehebung

Problem	Lösung
Container startet nicht	Prüfen Sie die Logs in Portainer (Klick auf Container-Name, dann Logs)
Datenbank-Verbindungsfehler	SQL Server erreichbar? Firewall-Port 1433 offen? Zugangsdaten korrekt?
`Access denied` beim Image-Download	Registry-Zugangsdaten prüfen (GHCR: GitHub-Token / ACR: Benutzer + Passwort) und sicherstellen, dass die im Stack referenzierte Image-Quelle zur hinterlegten Registry passt
Admin-Oberfläche nicht erreichbar	Port 8012 in der Firewall freigegeben? Container läuft?
Lizenzfehler beim Start	Kundennummer und Lizenznummer prüfen, ggf. Mesonic-Partner kontaktieren
Datenträger oder Volume voll, Container startet nicht mehr oder friert ein	Der Stack enthält keine `logging:`-Blöcke bzw. keine Serilog-Grenzen. Stack wie oben ergänzen und neu deployen, danach alte Dateien im Log-Volume löschen (`docker exec mesoworkerservice sh -c "rm /app/logs/*.txt"`). Das Docker-Log eines Containers wird erst beim Neuerstellen des Containers gekürzt. Siehe Protokollierung

Nach der Installation

Benutzeranmeldung

Nach dem ersten Start können Sie sich an den Administrationsoberflächen anmelden.

Standard-Administrator:

Benutzername: Admin
Passwort: (leer - muss bei erster Anmeldung gesetzt werden)
Rolle: Administrators (volle Berechtigungen)

Automatisch erstellte Rollen:

Administrators: Vollzugriff auf alle Funktionen
Default: Standardrolle für normale Benutzer mit eingeschränkten Rechten

Wichtig: Setzen Sie bei der ersten Anmeldung ein sicheres Passwort für den Admin-Benutzer.

Administrationsoberflächen

Für die Verwaltung und Konfiguration stehen zwei Oberflächen zur Verfügung:

Option A: Blazor Web-Interface

URL: http://localhost:5000 (oder konfigurierter Port)
Zugriff: Über jeden modernen Webbrowser
Vorteile:
- Plattformunabhängiger Zugriff
- Ideal für Remote-Administration
- Moderne Web-Oberfläche
- Mehrere Administratoren können gleichzeitig arbeiten

Verwendung:

Öffnen Sie einen Webbrowser
Navigieren Sie zu http://localhost:5000 (oder IP-Adresse des Servers)
Melden Sie sich mit Benutzername Admin und gesetztem Passwort an

Option B: Windows Desktop-Client (nur bei Windows-Dienst)

Start: MesoWorker.Win.exe
Hinweis: Die Setup-Dateien werden von Ihrem Mesonic-Händler bereitgestellt
Zugriff: Direkter Zugriff auf dem Server
Vorteile:
- Erweiterte Desktop-Funktionalität
- Optimiert für umfangreiche Konfigurationsarbeiten
- Zusätzliche Administrationsfunktionen

Verwendung:

Starten Sie MesoWorker.Win.exe im Installationsverzeichnis
Melden Sie sich mit Benutzername Admin und gesetztem Passwort an

Erste Schritte nach der Anmeldung

Nach der erfolgreichen Anmeldung sollten Sie folgende Schritte durchführen:

Passwort ändern
- Ändern Sie das Admin-Passwort über die Benutzerverwaltung
- Empfehlung: Starkes Passwort mit mindestens 12 Zeichen
Lizenz prüfen
- Überprüfen Sie, ob die Lizenz korrekt hinterlegt ist
- Der Service zeigt einen Fehler, falls die Lizenz ungültig ist
Datenbankverbindungen testen
- Stellen Sie sicher, dass beide Datenbanken erreichbar sind
- WinLine-Daten sollten sichtbar sein
SMTP-Konten einrichten (siehe SMTP-Konten einrichten)
- Mindestens ein SMTP-Konto für E-Mail-Versand konfigurieren
- Kennzeichnen Sie ein Konto als Standard-Konto
Mandanten aktivieren
- Prüfen Sie, welche Mandanten in der Liste angezeigt werden
- Aktivieren Sie die Mandanten, für die der Service arbeiten soll

Die XAF-Administrationsoberfläche ist nach den Hauptkomponenten des Systems gegliedert. Jede Komponente hat einen eigenen Navigationsbereich mit ihren Einstellungen und Protokollen:

Dashboard

Übersicht: Kennzahlen des Systems auf einen Blick

Stammdaten

Mandant: Welche WinLine-Mandanten der Dienst bearbeitet
Workflow: Workflow-Vorlagen und -Definitionen

SMTP Einstellungen

Smtp Account: Postausgangsserver für den Mailversand

Filter

Filter: Wiederverwendbare Filterkriterien, die in den Einstellungen der Komponenten referenziert werden
Eigenschaftswert: Feste Werte, die Workflows beim Anlegen mitbekommen

Mail-Dienst

Postausgang: Warteschlange der noch nicht versendeten E-Mails
Workflow-Einstellungen: Regeln je Workflow – wann eine Mail entsteht und wie sie aussieht
E-Mail-Einstellungen: Grundeinstellungen des Mail-Dienstes je Mandant
Empfänger-Regeln: Empfängerregeln, Regelvorlagen und die Warnungseinstellung des Überwachungsdienstes
Mail-Anhang: Anhangsdefinitionen für die Vorlagen
Protokolle: Mail-Journal, Warnungsjournal und übersprungene Mails

Bestelldatei-Workflows

Bestellzeilen-Workflow-Einstellungen: Regeln für die Workflow-Erzeugung aus Bestelldateizeilen
Bestellzeilen-Workflow-Journal: Protokoll der verarbeiteten Zeilen

Offene Posten

OP-Einstellungen: Selektion, Vorlage, Empfänger und Anhänge des automatischen OP-Versands
OP-Versandprotokoll: Protokoll aller versendeten OP-Übersichten

Banking (Modul MESO-WSBANKK)

Banking Dashboard: Zustand der Konten und der letzten Läufe
Banking-Konten: Zugangsdaten und Verhalten je Bankkonto
Transaktions-Journal: Abgerufene Umsätze mit ihrer Zuordnung und Buchung
Kreditor-OP-Einstellungen: Steuerung des Abgleichs gegen offene Kreditoren-Posten
Buchungsregeln: Regeln, nach denen Ausgänge auf Sachkonten gebucht werden
KI-Aufrufprotokoll: Protokoll der LLM-Aufrufe für Rechnungsauslesung und Sachkonto-Klassifikation

Termin-Synchronisation

Termin-Einstellungen: Steuerung der Synchronisation je Mandant
Termin-Journal: Protokoll der synchronisierten Termine
Graph API Zugangsdaten: Zugang zu Microsoft 365
NextCloud-Server und Kalender-Sync-Paar: Zugang und Kalenderzuordnung der NextCloud-Synchronisation (Modul MESO-WSNEXTCLOUD)

Berichte (Modul MESO-WSREPORT)

Berichtsauftrag: Zeitgesteuerte Läufe mit Mandanten, Benutzern, Ausgabezielen und Journal
Berichts-Datenquelle: Abfragen und Master-Detail-Beziehungen, aus denen Berichte ihre Daten beziehen
Bericht: Die Berichte selbst, mit Layout und Ausführungskontext

User Management

Benutzer: Anmeldungen der Web-Verwaltung und ihre Rollen
Model-Unterschiede: Benutzerbezogene Anpassungen an Ansichten

Hinweis: Benutzer mit einer eingeschränkten Rolle – Buchhalter, Mail-Sachbearbeiter, OP-Sachbearbeiter, Bestellwesen oder Terminplaner – sehen ausschließlich den Navigationsbereich ihrer Rolle und landen nach der Anmeldung direkt in dessen Startansicht. Die vollständige Navigation sieht nur, wer keine dieser Rollen hat, also insbesondere der Administrator.