# Medi-WOL - Wake-on-LAN Manager

Ein moderner Wake-on-LAN Manager, entwickelt mit Go und einer schönen Web-Oberfläche.

## Features

- **PC-Verwaltung**: Hinzufügen, Anzeigen, Bearbeiten und Löschen von PC-Einträgen
- **Wake-on-LAN**: Ein-Klick-Aufwecken von Computern über MAC-Adressen
- **IP-Adressverwaltung**: Pro Gerät wird eine IP-Adresse gespeichert
- **Online-Status (Ping)**: Geräte können per Ping geprüft und im UI als Online/Offline angezeigt werden
- **Moderne Web-Oberfläche**: Responsive Design mit Bootstrap und FontAwesome
- **SQLite-Datenbank**: Einfache lokale Datenspeicherung
- **Cross-Platform**: Läuft auf Windows und Linux
- **Konfigurierbarer Port**: Über Umgebungsvariablen oder Kommandozeilenparameter

## Voraussetzungen

- Go 1.21 oder höher
- Git

## Installation

1. **Repository klonen:**
   ```bash
   git clone https://gitea.medisoftware.org/Markus/medi-wol.git
   cd medi-wol
   ```

2. **Abhängigkeiten installieren:**
   ```bash
   go mod tidy
   ```

3. **Anwendung starten:**
   ```bash
   # Standard-Port 8080
   go run cmd/server/main.go
   
   # Benutzerdefinierter Port
   go run cmd/server/main.go -port 9090
   
   # Mit Umgebungsvariable
   set PORT=9090  # Windows
   export PORT=9090  # Linux
   go run cmd/server/main.go
   ```

4. **Im Browser öffnen:**
   ```
   http://localhost:8080  # Standard
   http://localhost:9090  # Benutzerdefiniert
   ```

## Konfiguration

### Port-Konfiguration

Der Server-Port kann auf verschiedene Weise konfiguriert werden:

#### 1. Kommandozeilenparameter
```bash
# Port 9090 verwenden
./medi-wol.exe -port 9090

# Hilfe anzeigen
./medi-wol.exe -help
```

#### 2. Umgebungsvariable
```bash
# Windows
set PORT=9090
medi-wol.exe

# Linux/macOS
export PORT=9090
./medi-wol

# Oder direkt
PORT=9090 ./medi-wol
```

#### 3. Standard-Port
Falls weder Kommandozeilenparameter noch Umgebungsvariable gesetzt sind, wird Port 8080 verwendet.

### Prioritätsreihenfolge
1. **Kommandozeilenparameter** (`-port`) - Höchste Priorität
2. **Umgebungsvariable** (`PORT`) - Mittlere Priorität  
3. **Standard-Port** (8080) - Niedrigste Priorität

## Verwendung

### PC hinzufügen
1. Geben Sie den Namen des PCs ein
2. Geben Sie die MAC-Adresse im Format `XX:XX:XX:XX:XX:XX` ein
3. Geben Sie die IP-Adresse des PCs ein (z. B. `192.168.0.10`)
4. Klicken Sie auf "PC hinzufügen"

### PC bearbeiten
1. Klicken Sie auf den "Bearbeiten"-Button neben dem gewünschten PC
2. Ändern Sie Name, MAC-Adresse und/oder IP-Adresse
3. Klicken Sie auf "Speichern"

### PC aufwecken
- Klicken Sie auf den "Aufwecken"-Button neben dem gewünschten PC
- Das System sendet automatisch ein Wake-on-LAN Paket

### Online-Status prüfen (Ping)
- Beim Laden der Seite wird automatisch der Status abgefragt
- Alle 30 Sekunden wird der Status automatisch aktualisiert
- Zusätzlich können Sie manuell über den Button "Status aktualisieren" aktualisieren

### PC löschen
- Klicken Sie auf den "Löschen"-Button neben dem gewünschten PC
- Bestätigen Sie die Löschung

## Windows Installer

### Features
Der Windows Installer (`medi-wol-setup.exe`) bietet:
- **Automatische Service-Installation** mit NSSM
- **Port-Konfiguration** während der Installation (Standard: 9000)
- **Windows Firewall-Regeln** werden automatisch erstellt:
  - Eingehende Verbindungen zur Anwendung
  - Ausgehende Verbindungen (für Wake-on-LAN)
  - Port-spezifische TCP-Regeln
- **Service-Start-Option** (Checkbox für automatischen Start)
- **Saubere Deinstallation** mit Entfernung aller Firewall-Regeln

### Voraussetzungen für den Build
```bash
# NSSM in das Installer-Verzeichnis kopieren
copy "I:\MARKUS\beszel\nssm.exe" installer\nssm.exe

# Oder von der offiziellen Quelle herunterladen
# https://nssm.cc/download
```

### Build des Installers
```bash
# Mit build.bat (automatisch)
.\build.bat

# Oder manuell mit Inno Setup Compiler
ISCC.exe installer\medi-wol-setup.iss
```

## Build-Anweisungen

### Windows Build

#### Lokaler Build (Windows)
```bash
# Einfacher Build
go build -o medi-wol.exe cmd/server/main.go

# Build mit Optimierungen
go build -ldflags="-s -w" -o medi-wol.exe cmd/server/main.go

# Build für Release
go build -ldflags="-s -w -X main.version=1.0.0" -o medi-wol.exe cmd/server/main.go
```

#### Cross-Compilation von Windows für Linux
```bash
# Für Linux AMD64
set GOOS=linux
set GOARCH=amd64
go build -o medi-wol-linux-amd64 cmd/server/main.go

# Für Linux ARM64 (Raspberry Pi, etc.)
set GOOS=linux
set GOARCH=arm64
go build -o medi-wol-linux-arm64 cmd/server/main.go

# Zurücksetzen auf Windows
set GOOS=windows
set GOARCH=amd64
```

### Linux Build

#### Lokaler Build (Linux)
```bash
# Einfacher Build
go build -o medi-wol cmd/server/main.go

# Build mit Optimierungen
go build -ldflags="-s -w" -o medi-wol cmd/server/main.go

# Build für Release
go build -ldflags="-s -w -X main.version=1.0.0" -o medi-wol cmd/server/main.go
```

#### Cross-Compilation von Linux für Windows
```bash
# Für Windows AMD64
GOOS=windows GOARCH=amd64 go build -o medi-wol-windows-amd64.exe cmd/server/main.go

# Für Windows ARM64
GOOS=windows GOARCH=arm64 go build -o medi-wol-windows-arm64.exe cmd/server/main.go
```

### Build-Flags Erklärung

- `-ldflags="-s -w"`: Reduziert die Binary-Größe durch Entfernung von Debug-Informationen
- `-X main.version=1.0.0`: Setzt eine Version-Variable zur Laufzeit
- `-o filename`: Bestimmt den Ausgabedateinamen

### Build-Skripte

#### Windows Build-Skript (`build.bat`)
```batch
@echo off
echo Building Medi-WOL for multiple platforms...

REM Erstelle dist-Verzeichnis
if not exist dist mkdir dist

echo Building for Windows AMD64...
go build -ldflags="-s -w" -o dist/medi-wol-windows-amd64.exe cmd/server/main.go

echo Building for Linux AMD64...
set GOOS=linux
set GOARCH=amd64
go build -ldflags="-s -w" -o dist/medi-wol-linux-amd64 cmd/server/main.go

echo Building for Linux ARM64...
set GOOS=linux
set GOARCH=arm64
go build -ldflags="-s -w" -o dist/medi-wol-linux-arm64 cmd/server/main.go

echo Building for Windows ARM64...
set GOOS=windows
set GOARCH=arm64
go build -ldflags="-s -w" -o dist/medi-wol-windows-arm64.exe cmd/server/main.go

REM Zurücksetzen auf Windows AMD64
set GOOS=windows
set GOARCH=amd64

echo.
echo Build complete! Binaries created in dist/ folder:
dir dist
echo.
pause
```

#### Linux Build-Skript (`build.sh`)
```bash
#!/bin/bash

echo "Building Medi-WOL for multiple platforms..."

# Erstelle dist-Verzeichnis
mkdir -p dist

echo "Building for Linux AMD64..."
go build -ldflags="-s -w" -o dist/medi-wol-linux-amd64 cmd/server/main.go

echo "Building for Linux ARM64..."
GOOS=linux GOARCH=arm64 go build -ldflags="-s -w" -o dist/medi-wol-linux-arm64 cmd/server/main.go

echo "Building for Windows AMD64..."
GOOS=windows GOARCH=amd64 go build -ldflags="-s -w" -o dist/medi-wol-windows-amd64.exe cmd/server/main.go

echo "Building for Windows ARM64..."
GOOS=windows GOARCH=arm64 go build -ldflags="-s -w" -o dist/medi-wol-windows-arm64.exe cmd/server/main.go

echo ""
echo "Build complete! Binaries created in dist/ folder:"
ls -la dist/
echo ""
```

## Projektstruktur

```
medi-wol/
├── cmd/server/          # Hauptanwendung
├── internal/            # Interne Pakete
│   ├── database/        # Datenbanklogik
│   ├── handlers/        # HTTP-Handler
│   ├── models/          # Datenmodelle
│   └── wol/            # Wake-on-LAN Service
├── web/                 # Web-Oberfläche
│   ├── static/         # CSS, JavaScript
│   └── templates/      # HTML-Templates
├── installer/           # Windows Installer
│   ├── medi-wol-setup.iss  # Inno Setup Script
│   └── nssm.exe        # NSSM für Service-Management
├── go.mod              # Go-Module
├── build.bat           # Windows Build-Skript (inkl. Installer)
├── build.sh            # Linux Build-Skript
└── README.md           # Diese Datei
```

### Installer-Verzeichnis
Das `installer/` Verzeichnis enthält alle Dateien für den Windows Installer:
- **`medi-wol-setup.iss`** - Inno Setup Konfigurationsdatei
- **`nssm.exe`** - NSSM (Non-Sucking Service Manager) für Windows Services

## API-Endpunkte

- `GET /` - Hauptseite
- `GET /api/pcs` - Alle PCs abrufen
- `POST /api/pcs` - Neuen PC erstellen
- `PUT /api/pcs/:id` - PC aktualisieren
- `DELETE /api/pcs/:id` - PC löschen
- `POST /api/pcs/:id/wake` - PC aufwecken
- `GET /api/pcs/status` - Online-Status aller PCs abrufen (Ping)

## Datenbank

Die Anwendung verwendet SQLite als lokale Datenbank. Die Datenbankdatei `medi-wol.db` wird automatisch im Projektverzeichnis erstellt.

### Tabellenstruktur `pcs`
| Spalte      | Typ      | Hinweis                |
|-------------|----------|------------------------|
| id          | INTEGER  | Primärschlüssel        |
| name        | TEXT     | Pflichtfeld            |
| mac         | TEXT     | Pflichtfeld, eindeutig |
| ip          | TEXT     | Pflichtfeld            |
| created_at  | DATETIME | Automatisch            |
| updated_at  | DATETIME | Automatisch            |

## Wake-on-LAN

Das System sendet Magic Packets an die gespeicherten MAC-Adressen. Stellen Sie sicher, dass:

1. Die Zielcomputer Wake-on-LAN unterstützen
2. Die Netzwerkkarte für Wake-on-LAN konfiguriert ist
3. Die Computer im gleichen Netzwerksegment sind

## Entwicklung

### Lokale Entwicklung
```bash
# Standard-Port 8080
go run cmd/server/main.go

# Benutzerdefinierter Port
go run cmd/server/main.go -port 9090
```

#### Hinweise zum Ping
- Der Ping wird aktuell über den Button "Status aktualisieren" ausgelöst (`GET /api/pcs/status`).
- Unter Windows wird der Systembefehl `ping -n 1 -w 1000 <IP>` verwendet, unter Linux/macOS `ping -c 1 -W 1 <IP>`.
- Falls ICMP blockiert ist, wird als Fallback eine kurze TCP-Portprobe versucht (80, sonst 22).
- Optional kann ein automatisches Intervall im Frontend ergänzt werden (z. B. alle 30s).

### Build für Produktion
```bash
# Windows
go build -ldflags="-s -w" -o medi-wol.exe cmd/server/main.go

# Linux
go build -ldflags="-s -w" -o medi-wol cmd/server/main.go
```

### Tests ausführen
```bash
go test ./...
```

### Code-Qualität prüfen
```bash
# Code formatieren
go fmt ./...

# Linting (falls golint installiert ist)
golint ./...

# Vet prüfen
go vet ./...
```

## Deployment

### Windows Service

#### Mit NSSM (Non-Sucking Service Manager)
```bash
# Service installieren
nssm install Medi-WOL "C:\path\to\medi-wol.exe"
nssm set Medi-WOL AppDirectory "C:\path\to\medi-wol"
nssm set Medi-WOL AppParameters "-port 9090"  # Optional: Port setzen
nssm start Medi-WOL
```

#### Windows Installer (Empfohlen)
Der Windows Installer konfiguriert den Service automatisch mit NSSM:
- **Automatische Service-Installation** mit NSSM
- **Windows Firewall-Regeln** werden automatisch erstellt
- **Port-Konfiguration** während der Installation
- **Service-Start-Option** (Checkbox für automatischen Start)

**Wichtig:** Für den Windows Installer muss `nssm.exe` im `installer/` Verzeichnis verfügbar sein:
```bash
# NSSM in das Installer-Verzeichnis kopieren
copy "I:\MARKUS\beszel\nssm.exe" installer\nssm.exe

# Oder von der offiziellen Quelle herunterladen
# https://nssm.cc/download
```

### Linux Systemd Service
```ini
# /etc/systemd/system/medi-wol.service
[Unit]
Description=Medi-WOL Wake-on-LAN Manager
After=network.target

[Service]
Type=simple
User=medi-wol
WorkingDirectory=/opt/medi-wol
ExecStart=/opt/medi-wol/medi-wol -port 9090
Environment="PORT=9090"
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target
```

### Docker (Optional)
```dockerfile
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY . .
RUN go build -ldflags="-s -w" -o medi-wol cmd/server/main.go

FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/medi-wol .
EXPOSE 8080
CMD ["./medi-wol", "-port", "8080"]
```

```bash
# Docker Container starten
docker run -d -p 9090:9090 -e PORT=9090 medi-wol:latest
```

## Lizenz

Dieses Projekt ist für den internen Gebrauch bestimmt.

## Support

Bei Fragen oder Problemen wenden Sie sich an das Entwicklungsteam.

Hier sind drei einfache Wege – nimm Variante A (empfohlen) für die neueste Version.

- A) Offizielles Tarball (empfohlen)
  1) Alte Installation entfernen (falls vorhanden):
  ```bash
  sudo rm -rf /usr/local/go
  ```
  2) Tarball laden und installieren (ersetze 1.22.6 und Arch bei Bedarf: amd64/arm64):
  ```bash
  wget https://go.dev/dl/go1.22.6.linux-amd64.tar.gz
  sudo tar -C /usr/local -xzf go1.22.6.linux-amd64.tar.gz
  ```
  3) PATH setzen (dauerhaft):
  ```bash
  echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.profile
  source ~/.profile
  ```
  4) Prüfen:
  ```bash
  go version
  ```

- B) Snap (schnell, meist aktuell)
  ```bash
  sudo snap install go --classic
  go version
  ```

- C) Ubuntu-Paket (einfach, aber oft älter)
  ```bash
  sudo apt update
  sudo apt install -y golang-go
  go version
  ```

Hinweise:
- Standard-GOPATH ist ~/go. Optional:
  ```bash
  echo 'export GOPATH=$HOME/go' >> ~/.profile
  echo 'export PATH=$PATH:$GOPATH/bin' >> ~/.profile
  source ~/.profile
  ```
