1756 lines
50 KiB
Bash
1756 lines
50 KiB
Bash
#!/bin/bash
|
||
# MYP Installer Control Center - Vollständige Linux/Unix-Installation
|
||
# Zentrale Installationskonsole für die MYP-Plattform
|
||
# Version 4.0 - Granularer Installer mit Frontend/Backend-Trennung
|
||
|
||
# Farbdefinitionen
|
||
RED='\033[0;31m'
|
||
GREEN='\033[0;32m'
|
||
YELLOW='\033[0;33m'
|
||
BLUE='\033[0;34m'
|
||
CYAN='\033[0;36m'
|
||
WHITE='\033[1;37m'
|
||
NC='\033[0m' # No Color
|
||
|
||
# Globale Variablen
|
||
PROJECT_DIR="$(pwd)"
|
||
BACKEND_DIR="$PROJECT_DIR/backend"
|
||
FRONTEND_DIR="$PROJECT_DIR/frontend"
|
||
APP_DIR="$BACKEND_DIR/app"
|
||
VENV_DIR="$BACKEND_DIR/venv"
|
||
|
||
# Überprüfen, ob das Skript als Root ausgeführt wird
|
||
is_root=0
|
||
if [ "$EUID" -eq 0 ]; then
|
||
is_root=1
|
||
fi
|
||
|
||
# Funktionen
|
||
show_header() {
|
||
local title="$1"
|
||
clear
|
||
echo -e "${CYAN}=============================================================${NC}"
|
||
echo -e "${CYAN} MYP INSTALLER CONTROL CENTER ${NC}"
|
||
echo -e "${CYAN} Version 4.0 ${NC}"
|
||
echo -e "${CYAN} Granularer Installer mit Trennung ${NC}"
|
||
echo -e "${CYAN}=============================================================${NC}"
|
||
echo -e "${CYAN} $title${NC}"
|
||
echo -e "${CYAN}=============================================================${NC}"
|
||
|
||
if [ $is_root -eq 0 ]; then
|
||
echo -e "${YELLOW}HINWEIS: Dieses Skript läuft ohne Root-Rechte.${NC}"
|
||
echo -e "${YELLOW}Einige Funktionen sind möglicherweise eingeschränkt.${NC}"
|
||
echo -e "${CYAN}=============================================================${NC}"
|
||
fi
|
||
|
||
echo ""
|
||
}
|
||
|
||
check_command() {
|
||
command -v "$1" >/dev/null 2>&1
|
||
}
|
||
|
||
exec_command() {
|
||
local cmd="$1"
|
||
local description="$2"
|
||
local allow_fail="$3"
|
||
|
||
echo -e "${BLUE}> $description...${NC}"
|
||
|
||
eval $cmd
|
||
|
||
if [ $? -eq 0 ]; then
|
||
echo -e "${GREEN}✓ Erfolgreich abgeschlossen!${NC}"
|
||
return 0
|
||
else
|
||
if [ "$allow_fail" = "true" ]; then
|
||
echo -e "${YELLOW}⚠ Warnung: $description fehlgeschlagen, wird übersprungen.${NC}"
|
||
return 0
|
||
else
|
||
echo -e "${RED}✗ Fehler beim Ausführen des Befehls. Exit-Code: $?${NC}"
|
||
return 1
|
||
fi
|
||
fi
|
||
}
|
||
|
||
get_local_ip() {
|
||
local ip=$(hostname -I | awk '{print $1}')
|
||
if [ -z "$ip" ]; then
|
||
ip="127.0.0.1"
|
||
fi
|
||
echo "$ip"
|
||
}
|
||
|
||
# System-Abhängigkeiten installieren
|
||
install_system_dependencies() {
|
||
show_header "System-Abhängigkeiten installieren"
|
||
|
||
if [ $is_root -eq 0 ]; then
|
||
echo -e "${RED}Diese Funktion erfordert Root-Rechte.${NC}"
|
||
echo -e "${YELLOW}Bitte starten Sie das Skript mit sudo oder führen Sie folgende Befehle manuell aus:${NC}"
|
||
echo ""
|
||
echo -e "${WHITE}# Debian/Ubuntu/Raspberry Pi OS:${NC}"
|
||
echo -e "${WHITE}sudo apt update${NC}"
|
||
echo -e "${WHITE}sudo apt install -y python3 python3-pip python3-venv nodejs npm git curl wget sqlite3 openssl${NC}"
|
||
echo ""
|
||
echo -e "${WHITE}# RHEL/CentOS/Fedora:${NC}"
|
||
echo -e "${WHITE}sudo dnf install -y python3 python3-pip nodejs npm git curl wget sqlite openssl${NC}"
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
return 1
|
||
fi
|
||
|
||
echo -e "${BLUE}Erkenne Betriebssystem...${NC}"
|
||
|
||
if [ -f /etc/debian_version ]; then
|
||
echo -e "${GREEN}Debian/Ubuntu/Raspberry Pi OS erkannt${NC}"
|
||
|
||
echo -e "${BLUE}Aktualisiere Paketlisten...${NC}"
|
||
apt update
|
||
|
||
echo -e "${BLUE}Installiere System-Pakete...${NC}"
|
||
apt install -y \
|
||
python3 \
|
||
python3-pip \
|
||
python3-venv \
|
||
python3-dev \
|
||
build-essential \
|
||
libssl-dev \
|
||
libffi-dev \
|
||
libsqlite3-dev \
|
||
nodejs \
|
||
npm \
|
||
git \
|
||
curl \
|
||
wget \
|
||
sqlite3 \
|
||
openssl \
|
||
ca-certificates \
|
||
nginx \
|
||
supervisor \
|
||
ufw \
|
||
net-tools \
|
||
htop \
|
||
vim \
|
||
nano \
|
||
chromium-browser
|
||
|
||
elif [ -f /etc/redhat-release ]; then
|
||
echo -e "${GREEN}RHEL/CentOS/Fedora erkannt${NC}"
|
||
|
||
echo -e "${BLUE}Installiere System-Pakete...${NC}"
|
||
if check_command dnf; then
|
||
dnf install -y \
|
||
python3 \
|
||
python3-pip \
|
||
python3-devel \
|
||
gcc \
|
||
openssl-devel \
|
||
libffi-devel \
|
||
sqlite-devel \
|
||
nodejs \
|
||
npm \
|
||
git \
|
||
curl \
|
||
wget \
|
||
sqlite \
|
||
openssl \
|
||
ca-certificates \
|
||
nginx \
|
||
supervisor \
|
||
chromium
|
||
else
|
||
yum install -y \
|
||
python3 \
|
||
python3-pip \
|
||
python3-devel \
|
||
gcc \
|
||
openssl-devel \
|
||
libffi-devel \
|
||
sqlite-devel \
|
||
nodejs \
|
||
npm \
|
||
git \
|
||
curl \
|
||
wget \
|
||
sqlite \
|
||
openssl \
|
||
ca-certificates \
|
||
nginx \
|
||
supervisor \
|
||
chromium
|
||
fi
|
||
|
||
else
|
||
echo -e "${YELLOW}Unbekanntes Betriebssystem. Bitte installieren Sie manuell:${NC}"
|
||
echo -e "${WHITE}- Python 3.8+${NC}"
|
||
echo -e "${WHITE}- Node.js 16+${NC}"
|
||
echo -e "${WHITE}- Git, curl, wget, sqlite3, openssl${NC}"
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
return 1
|
||
fi
|
||
|
||
echo -e "${GREEN}✓ System-Abhängigkeiten erfolgreich installiert!${NC}"
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
# Python & Node.js Umgebung einrichten
|
||
setup_python_node_environment() {
|
||
show_header "Python & Node.js Umgebung einrichten"
|
||
|
||
echo -e "${BLUE}1. Python-Umgebung prüfen...${NC}"
|
||
|
||
# Python prüfen
|
||
python_cmd=""
|
||
if check_command python3; then
|
||
python_cmd="python3"
|
||
python_version=$(python3 --version 2>&1)
|
||
echo -e "${GREEN}✓ $python_version${NC}"
|
||
elif check_command python; then
|
||
python_cmd="python"
|
||
python_version=$(python --version 2>&1)
|
||
echo -e "${GREEN}✓ $python_version${NC}"
|
||
else
|
||
echo -e "${RED}✗ Python nicht gefunden${NC}"
|
||
return 1
|
||
fi
|
||
|
||
# Pip prüfen
|
||
if check_command pip3; then
|
||
echo -e "${GREEN}✓ pip3 gefunden${NC}"
|
||
elif check_command pip; then
|
||
echo -e "${GREEN}✓ pip gefunden${NC}"
|
||
else
|
||
echo -e "${RED}✗ pip nicht gefunden${NC}"
|
||
return 1
|
||
fi
|
||
|
||
echo -e "${BLUE}2. Node.js-Umgebung prüfen...${NC}"
|
||
|
||
# Node.js prüfen
|
||
if check_command node; then
|
||
node_version=$(node --version)
|
||
echo -e "${GREEN}✓ Node.js $node_version${NC}"
|
||
else
|
||
echo -e "${RED}✗ Node.js nicht gefunden${NC}"
|
||
return 1
|
||
fi
|
||
|
||
# npm prüfen
|
||
if check_command npm; then
|
||
npm_version=$(npm --version)
|
||
echo -e "${GREEN}✓ npm $npm_version${NC}"
|
||
else
|
||
echo -e "${RED}✗ npm nicht gefunden${NC}"
|
||
return 1
|
||
fi
|
||
|
||
echo -e "${BLUE}3. Globale npm-Pakete aktualisieren...${NC}"
|
||
exec_command "npm update -g" "npm global update" true
|
||
|
||
echo -e "${GREEN}✓ Python & Node.js Umgebung bereit!${NC}"
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
# Backend installieren
|
||
install_backend() {
|
||
show_header "Backend Installation"
|
||
|
||
echo -e "${BLUE}MYP Backend (Flask API) installieren${NC}"
|
||
echo ""
|
||
|
||
# Python prüfen
|
||
python_cmd=""
|
||
if check_command python3; then
|
||
python_cmd="python3"
|
||
echo -e "${GREEN}✓ Python 3 gefunden${NC}"
|
||
elif check_command python; then
|
||
python_cmd="python"
|
||
echo -e "${GREEN}✓ Python gefunden${NC}"
|
||
else
|
||
echo -e "${RED}✗ Python nicht gefunden. Bitte installieren Sie Python 3.8+${NC}"
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
return 1
|
||
fi
|
||
|
||
# Pip prüfen
|
||
pip_cmd=""
|
||
if check_command pip3; then
|
||
pip_cmd="pip3"
|
||
elif check_command pip; then
|
||
pip_cmd="pip"
|
||
else
|
||
echo -e "${RED}✗ pip nicht gefunden. Bitte installieren Sie pip${NC}"
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
return 1
|
||
fi
|
||
|
||
# Virtual Environment erstellen
|
||
echo -e "${BLUE}1. Virtual Environment erstellen...${NC}"
|
||
if [ ! -d "$VENV_DIR" ]; then
|
||
exec_command "$python_cmd -m venv $VENV_DIR" "Erstelle Virtual Environment"
|
||
else
|
||
echo -e "${YELLOW}Virtual Environment existiert bereits${NC}"
|
||
fi
|
||
|
||
# Virtual Environment aktivieren
|
||
echo -e "${BLUE}2. Virtual Environment aktivieren...${NC}"
|
||
source "$VENV_DIR/bin/activate"
|
||
|
||
# Pip upgraden
|
||
echo -e "${BLUE}3. Pip upgraden...${NC}"
|
||
exec_command "pip install --upgrade pip setuptools wheel" "Pip upgraden"
|
||
|
||
# Requirements installieren
|
||
echo -e "${BLUE}4. Backend-Abhängigkeiten installieren...${NC}"
|
||
if [ -f "$BACKEND_DIR/requirements.txt" ]; then
|
||
exec_command "pip install -r $BACKEND_DIR/requirements.txt" "Backend-Abhängigkeiten installieren"
|
||
else
|
||
echo -e "${RED}✗ requirements.txt nicht gefunden in $BACKEND_DIR${NC}"
|
||
return 1
|
||
fi
|
||
|
||
# Verzeichnisse erstellen
|
||
echo -e "${BLUE}5. Backend-Verzeichnisse erstellen...${NC}"
|
||
mkdir -p "$APP_DIR/database"
|
||
mkdir -p "$APP_DIR/logs/app"
|
||
mkdir -p "$APP_DIR/logs/auth"
|
||
mkdir -p "$APP_DIR/logs/jobs"
|
||
mkdir -p "$APP_DIR/logs/printers"
|
||
mkdir -p "$APP_DIR/logs/scheduler"
|
||
mkdir -p "$APP_DIR/logs/errors"
|
||
mkdir -p "$APP_DIR/certs"
|
||
|
||
echo -e "${GREEN}✓ Backend-Verzeichnisse erstellt${NC}"
|
||
|
||
# Datenbank initialisieren
|
||
echo -e "${BLUE}6. Datenbank initialisieren...${NC}"
|
||
cd "$APP_DIR"
|
||
if [ ! -f "database/myp.db" ]; then
|
||
exec_command "$python_cmd -c 'from models import init_database, create_initial_admin; init_database(); create_initial_admin()'" "Datenbank initialisieren"
|
||
else
|
||
echo -e "${YELLOW}Datenbank existiert bereits${NC}"
|
||
fi
|
||
|
||
# SSL-Zertifikate erstellen
|
||
echo -e "${BLUE}7. SSL-Zertifikate erstellen...${NC}"
|
||
read -p "Möchten Sie SSL-Zertifikate erstellen? (j/n, Standard: j): " create_ssl
|
||
if [ "$create_ssl" != "n" ]; then
|
||
create_ssl_certificates
|
||
fi
|
||
|
||
echo ""
|
||
echo -e "${GREEN}✓ Backend-Installation abgeschlossen!${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}Backend starten:${NC}"
|
||
echo -e "${WHITE}cd $APP_DIR && $python_cmd app.py${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}Backend-URLs:${NC}"
|
||
echo -e "${WHITE}- HTTPS: https://localhost:443${NC}"
|
||
echo -e "${WHITE}- HTTP: http://localhost:5000${NC}"
|
||
|
||
deactivate
|
||
cd "$PROJECT_DIR"
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
# Frontend installieren
|
||
install_frontend() {
|
||
show_header "Frontend Installation"
|
||
|
||
echo -e "${BLUE}MYP Frontend (Next.js React App) installieren${NC}"
|
||
echo ""
|
||
|
||
# Node.js prüfen
|
||
if ! check_command node; then
|
||
echo -e "${RED}✗ Node.js nicht gefunden. Bitte installieren Sie Node.js 16+${NC}"
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
return 1
|
||
fi
|
||
|
||
node_version=$(node --version)
|
||
echo -e "${GREEN}✓ Node.js gefunden: $node_version${NC}"
|
||
|
||
# npm prüfen
|
||
if ! check_command npm; then
|
||
echo -e "${RED}✗ npm nicht gefunden. Bitte installieren Sie npm${NC}"
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
return 1
|
||
fi
|
||
|
||
npm_version=$(npm --version)
|
||
echo -e "${GREEN}✓ npm gefunden: $npm_version${NC}"
|
||
|
||
# Frontend-Verzeichnis prüfen
|
||
if [ ! -d "$FRONTEND_DIR" ]; then
|
||
echo -e "${RED}✗ Frontend-Verzeichnis nicht gefunden: $FRONTEND_DIR${NC}"
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
return 1
|
||
fi
|
||
|
||
cd "$FRONTEND_DIR"
|
||
|
||
# Dependencies installieren
|
||
echo -e "${BLUE}1. Frontend-Abhängigkeiten installieren...${NC}"
|
||
exec_command "npm install" "Frontend-Abhängigkeiten installieren"
|
||
|
||
# SSL-Verzeichnis erstellen
|
||
echo -e "${BLUE}2. SSL-Verzeichnis erstellen...${NC}"
|
||
mkdir -p "$FRONTEND_DIR/ssl"
|
||
|
||
# .env.local konfigurieren
|
||
echo -e "${BLUE}3. Frontend-Konfiguration erstellen...${NC}"
|
||
setup_frontend_config
|
||
|
||
# Build erstellen (optional)
|
||
read -p "Möchten Sie das Frontend für Produktion builden? (j/n, Standard: n): " build_frontend
|
||
if [ "$build_frontend" = "j" ]; then
|
||
echo -e "${BLUE}4. Frontend für Produktion builden...${NC}"
|
||
exec_command "npm run build" "Frontend builden"
|
||
fi
|
||
|
||
echo ""
|
||
echo -e "${GREEN}✓ Frontend-Installation abgeschlossen!${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}Frontend starten:${NC}"
|
||
echo -e "${WHITE}cd $FRONTEND_DIR && npm run dev${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}Frontend-URLs:${NC}"
|
||
echo -e "${WHITE}- Development: http://localhost:3000${NC}"
|
||
echo -e "${WHITE}- Production: http://localhost:3000${NC}"
|
||
|
||
cd "$PROJECT_DIR"
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
# Frontend Produktions-Deployment
|
||
deploy_frontend_production() {
|
||
show_header "Frontend Produktions-Deployment"
|
||
|
||
echo -e "${BLUE}MYP Frontend für Produktion deployen (Port 80/443 mit SSL)${NC}"
|
||
echo ""
|
||
|
||
# Docker prüfen
|
||
if ! check_command docker; then
|
||
echo -e "${RED}✗ Docker nicht gefunden. Bitte installieren Sie Docker${NC}"
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
return 1
|
||
fi
|
||
|
||
if ! check_command docker-compose; then
|
||
echo -e "${RED}✗ Docker Compose nicht gefunden. Bitte installieren Sie Docker Compose${NC}"
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
return 1
|
||
fi
|
||
|
||
echo -e "${GREEN}✓ Docker gefunden${NC}"
|
||
echo -e "${GREEN}✓ Docker Compose gefunden${NC}"
|
||
|
||
# Frontend-Verzeichnis prüfen
|
||
if [ ! -d "$FRONTEND_DIR" ]; then
|
||
echo -e "${RED}✗ Frontend-Verzeichnis nicht gefunden: $FRONTEND_DIR${NC}"
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
return 1
|
||
fi
|
||
|
||
cd "$FRONTEND_DIR"
|
||
|
||
# Produktions-Konfiguration prüfen
|
||
if [ ! -f "docker-compose.production.yml" ]; then
|
||
echo -e "${RED}✗ Produktions-Konfiguration nicht gefunden: docker-compose.production.yml${NC}"
|
||
echo -e "${YELLOW}Bitte stellen Sie sicher, dass die Produktions-Konfiguration vorhanden ist.${NC}"
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
return 1
|
||
fi
|
||
|
||
echo -e "${GREEN}✓ Produktions-Konfiguration gefunden${NC}"
|
||
|
||
# SSL-Zertifikate-Verzeichnis erstellen
|
||
echo -e "${BLUE}1. SSL-Zertifikate-Verzeichnis erstellen...${NC}"
|
||
mkdir -p "./certs"
|
||
echo -e "${GREEN}✓ Zertifikate-Verzeichnis erstellt${NC}"
|
||
|
||
# Alte Container stoppen
|
||
echo -e "${BLUE}2. Alte Container stoppen...${NC}"
|
||
exec_command "docker-compose -f docker-compose.production.yml down" "Alte Container stoppen" "true"
|
||
|
||
# Backend-URL konfigurieren
|
||
echo -e "${BLUE}3. Backend-URL konfigurieren...${NC}"
|
||
echo -e "${WHITE}Aktuelle Backend-URLs:${NC}"
|
||
echo -e "${WHITE}1. Raspberry Pi (raspberrypi:443) [Standard]${NC}"
|
||
echo -e "${WHITE}2. Lokales Backend (localhost:443)${NC}"
|
||
echo -e "${WHITE}3. Benutzerdefinierte URL${NC}"
|
||
|
||
read -p "Wählen Sie eine Option (1-3, Standard: 1): " backend_choice
|
||
|
||
backend_url="https://raspberrypi:443"
|
||
|
||
case $backend_choice in
|
||
2)
|
||
backend_url="https://localhost:443"
|
||
;;
|
||
3)
|
||
read -p "Geben Sie die Backend-URL ein (z.B. https://192.168.1.100:443): " custom_url
|
||
if [ -n "$custom_url" ]; then
|
||
backend_url="$custom_url"
|
||
fi
|
||
;;
|
||
*)
|
||
backend_url="https://raspberrypi:443"
|
||
;;
|
||
esac
|
||
|
||
echo -e "${GREEN}✓ Backend-URL konfiguriert: $backend_url${NC}"
|
||
|
||
# Container bauen und starten
|
||
echo -e "${BLUE}4. Frontend-Container bauen und starten...${NC}"
|
||
echo -e "${YELLOW}Dies kann einige Minuten dauern...${NC}"
|
||
|
||
# Environment-Variablen für Backend-URL setzen
|
||
export NEXT_PUBLIC_API_URL="$backend_url"
|
||
export NEXT_PUBLIC_BACKEND_HOST="${backend_url#https://}"
|
||
|
||
exec_command "docker-compose -f docker-compose.production.yml up --build -d" "Frontend-Container starten"
|
||
|
||
if [ $? -eq 0 ]; then
|
||
# Kurz warten und Status prüfen
|
||
echo -e "${BLUE}5. Container-Status prüfen...${NC}"
|
||
sleep 5
|
||
|
||
container_status=$(docker-compose -f docker-compose.production.yml ps --services --filter "status=running")
|
||
|
||
if [ -n "$container_status" ]; then
|
||
echo -e "${GREEN}✓ Container erfolgreich gestartet!${NC}"
|
||
|
||
# Container-Details anzeigen
|
||
echo ""
|
||
echo -e "${BLUE}Container Status:${NC}"
|
||
docker-compose -f docker-compose.production.yml ps
|
||
|
||
echo ""
|
||
echo -e "${GREEN}✅ Frontend Produktions-Deployment erfolgreich abgeschlossen!${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}🌐 Frontend ist verfügbar unter:${NC}"
|
||
echo -e "${WHITE} - HTTP: http://localhost:80${NC}"
|
||
echo -e "${WHITE} - HTTPS: https://localhost:443${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}🔧 Backend-Verbindung:${NC}"
|
||
echo -e "${WHITE} - Backend: $backend_url${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}📋 Nützliche Befehle:${NC}"
|
||
echo -e "${WHITE} - Logs anzeigen: docker-compose -f docker-compose.production.yml logs -f${NC}"
|
||
echo -e "${WHITE} - Container stoppen: docker-compose -f docker-compose.production.yml down${NC}"
|
||
echo -e "${WHITE} - Container neustarten: docker-compose -f docker-compose.production.yml restart${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}🔒 SSL-Hinweise:${NC}"
|
||
echo -e "${WHITE} - Caddy generiert automatisch selbstsignierte Zertifikate${NC}"
|
||
echo -e "${WHITE} - Zertifikate werden in ./certs/ gespeichert${NC}"
|
||
echo -e "${WHITE} - Für Produktion: Browser-Warnung bei selbstsignierten Zertifikaten acceptieren${NC}"
|
||
|
||
else
|
||
echo -e "${RED}✗ Container konnten nicht gestartet werden${NC}"
|
||
echo -e "${YELLOW}Logs anzeigen:${NC}"
|
||
docker-compose -f docker-compose.production.yml logs
|
||
return 1
|
||
fi
|
||
else
|
||
echo -e "${RED}✗ Fehler beim Starten der Container${NC}"
|
||
return 1
|
||
fi
|
||
|
||
cd "$PROJECT_DIR"
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
# Kiosk-Modus installieren
|
||
install_kiosk_mode() {
|
||
show_header "Kiosk-Modus Installation"
|
||
|
||
echo -e "${BLUE}MYP Kiosk-Modus (Backend Web Interface) installieren${NC}"
|
||
echo ""
|
||
echo -e "${YELLOW}Der Kiosk-Modus nutzt das Backend Flask Web Interface${NC}"
|
||
echo -e "${YELLOW}als Ersatz für das separate Frontend.${NC}"
|
||
echo ""
|
||
|
||
# Backend muss installiert sein
|
||
if [ ! -d "$VENV_DIR" ]; then
|
||
echo -e "${RED}✗ Backend ist nicht installiert. Bitte installieren Sie zuerst das Backend.${NC}"
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
return 1
|
||
fi
|
||
|
||
# Kiosk-spezifische Konfiguration
|
||
echo -e "${BLUE}1. Kiosk-Konfiguration erstellen...${NC}"
|
||
|
||
# Virtual Environment aktivieren
|
||
source "$VENV_DIR/bin/activate"
|
||
|
||
cd "$APP_DIR"
|
||
|
||
# Kiosk-Konfiguration in settings.py setzen
|
||
if [ -f "config/settings.py" ]; then
|
||
# Backup erstellen
|
||
cp "config/settings.py" "config/settings.py.backup"
|
||
|
||
# Kiosk-Modus aktivieren
|
||
cat >> "config/settings.py" << 'EOF'
|
||
|
||
# Kiosk-Modus Konfiguration
|
||
KIOSK_MODE = True
|
||
KIOSK_AUTO_LOGIN = True
|
||
KIOSK_FULLSCREEN = True
|
||
KIOSK_HIDE_NAVIGATION = False
|
||
KIOSK_DEFAULT_USER = "kiosk@mercedes-benz.com"
|
||
EOF
|
||
|
||
echo -e "${GREEN}✓ Kiosk-Konfiguration hinzugefügt${NC}"
|
||
fi
|
||
|
||
# Systemd Service für Kiosk erstellen (falls Root)
|
||
if [ $is_root -eq 1 ]; then
|
||
echo -e "${BLUE}2. Kiosk-Service erstellen...${NC}"
|
||
|
||
cat > "/etc/systemd/system/myp-kiosk.service" << EOF
|
||
[Unit]
|
||
Description=MYP Kiosk Mode - 3D Printer Management Kiosk
|
||
After=network.target graphical-session.target
|
||
|
||
[Service]
|
||
Type=simple
|
||
User=$USER
|
||
Group=$USER
|
||
WorkingDirectory=$APP_DIR
|
||
Environment=PATH=$VENV_DIR/bin
|
||
Environment=DISPLAY=:0
|
||
ExecStart=$VENV_DIR/bin/python app.py --kiosk
|
||
Restart=always
|
||
RestartSec=10
|
||
|
||
[Install]
|
||
WantedBy=graphical-session.target
|
||
EOF
|
||
|
||
systemctl daemon-reload
|
||
systemctl enable myp-kiosk.service
|
||
|
||
echo -e "${GREEN}✓ Kiosk-Service erstellt und aktiviert${NC}"
|
||
fi
|
||
|
||
# Browser-Autostart für Kiosk (Raspberry Pi)
|
||
echo -e "${BLUE}3. Browser-Autostart konfigurieren...${NC}"
|
||
|
||
autostart_dir="$HOME/.config/autostart"
|
||
mkdir -p "$autostart_dir"
|
||
|
||
cat > "$autostart_dir/myp-kiosk.desktop" << EOF
|
||
[Desktop Entry]
|
||
Type=Application
|
||
Name=MYP Kiosk
|
||
Comment=MYP 3D Printer Management Kiosk
|
||
Exec=chromium-browser --kiosk --disable-infobars --disable-session-crashed-bubble --disable-translate --no-first-run https://localhost:443
|
||
X-GNOME-Autostart-enabled=true
|
||
Hidden=false
|
||
NoDisplay=false
|
||
EOF
|
||
|
||
echo -e "${GREEN}✓ Browser-Autostart konfiguriert${NC}"
|
||
|
||
deactivate
|
||
cd "$PROJECT_DIR"
|
||
|
||
echo ""
|
||
echo -e "${GREEN}✓ Kiosk-Modus Installation abgeschlossen!${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}Kiosk-Modus starten:${NC}"
|
||
echo -e "${WHITE}sudo systemctl start myp-kiosk${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}Kiosk-URLs:${NC}"
|
||
echo -e "${WHITE}- Vollbild: https://localhost:443${NC}"
|
||
echo -e "${WHITE}- Normal: https://localhost:443${NC}"
|
||
echo ""
|
||
echo -e "${YELLOW}Hinweise:${NC}"
|
||
echo -e "${WHITE}- Der Kiosk-Modus startet automatisch beim Boot${NC}"
|
||
echo -e "${WHITE}- Browser öffnet im Vollbildmodus${NC}"
|
||
echo -e "${WHITE}- Nutzt das Backend Web Interface${NC}"
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
# Frontend-Konfiguration erstellen
|
||
setup_frontend_config() {
|
||
echo -e "${BLUE}Backend-URL für Frontend konfigurieren:${NC}"
|
||
echo -e "${WHITE}1. Lokale Entwicklung (https://localhost:443)${NC}"
|
||
echo -e "${WHITE}2. Raspberry Pi (https://raspberrypi:443)${NC}"
|
||
echo -e "${WHITE}3. Benutzerdefinierte URL${NC}"
|
||
|
||
read -p "Wählen Sie eine Option (1-3, Standard: 1): " choice
|
||
|
||
backend_url="https://localhost:443"
|
||
|
||
case $choice in
|
||
2)
|
||
backend_url="https://raspberrypi:443"
|
||
;;
|
||
3)
|
||
read -p "Backend-URL eingeben: " backend_url
|
||
;;
|
||
*)
|
||
backend_url="https://localhost:443"
|
||
;;
|
||
esac
|
||
|
||
# .env.local erstellen
|
||
cat > "$FRONTEND_DIR/.env.local" << EOF
|
||
# Backend API Konfiguration
|
||
NEXT_PUBLIC_API_URL=$backend_url
|
||
|
||
# Frontend-URL
|
||
NEXT_PUBLIC_FRONTEND_URL=http://localhost:3000
|
||
|
||
# OAuth Konfiguration
|
||
NEXT_PUBLIC_OAUTH_CALLBACK_URL=http://localhost:3000/auth/login/callback
|
||
|
||
# GitHub OAuth
|
||
GITHUB_CLIENT_ID=7c5d8bef1a5519ec1fdc
|
||
GITHUB_CLIENT_SECRET=5f1e586204358fbd53cf5fb7d418b3f06ccab8fd
|
||
|
||
# Entwicklungsumgebung
|
||
NODE_ENV=development
|
||
DEBUG=true
|
||
NEXT_DEBUG=true
|
||
|
||
# Backend Host
|
||
NEXT_PUBLIC_BACKEND_HOST=$(echo "$backend_url" | sed -E 's|https?://([^:/]+).*|\1|')
|
||
NEXT_PUBLIC_BACKEND_PROTOCOL=$(echo "$backend_url" | sed -E 's|^(https?)://.*|\1|')
|
||
EOF
|
||
|
||
echo -e "${GREEN}✓ Frontend-Konfiguration erstellt: $backend_url${NC}"
|
||
}
|
||
|
||
# Vollinstallationen
|
||
install_everything() {
|
||
show_header "Vollständige Installation (Backend + Frontend)"
|
||
|
||
echo -e "${BLUE}Installiere komplette MYP-Platform...${NC}"
|
||
echo ""
|
||
|
||
# System-Abhängigkeiten (falls Root)
|
||
if [ $is_root -eq 1 ]; then
|
||
install_system_dependencies
|
||
else
|
||
echo -e "${YELLOW}System-Abhängigkeiten übersprungen (keine Root-Rechte)${NC}"
|
||
fi
|
||
|
||
# Backend installieren
|
||
install_backend
|
||
|
||
# Frontend installieren
|
||
install_frontend
|
||
|
||
echo ""
|
||
echo -e "${GREEN}✓ Vollständige Installation abgeschlossen!${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}Nächste Schritte:${NC}"
|
||
echo -e "${WHITE}1. Backend starten: cd $APP_DIR && python app.py${NC}"
|
||
echo -e "${WHITE}2. Frontend starten: cd $FRONTEND_DIR && npm run dev${NC}"
|
||
echo -e "${WHITE}3. Anwendung öffnen: https://localhost:443 (Backend) + http://localhost:3000 (Frontend)${NC}"
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
install_production_setup() {
|
||
show_header "Produktions-Setup (Backend + Kiosk)"
|
||
|
||
echo -e "${BLUE}Installiere Produktions-Setup für Raspberry Pi...${NC}"
|
||
echo ""
|
||
|
||
# System-Abhängigkeiten (falls Root)
|
||
if [ $is_root -eq 1 ]; then
|
||
install_system_dependencies
|
||
else
|
||
echo -e "${YELLOW}System-Abhängigkeiten übersprungen (keine Root-Rechte)${NC}"
|
||
fi
|
||
|
||
# Backend installieren
|
||
install_backend
|
||
|
||
# Kiosk-Modus installieren
|
||
install_kiosk_mode
|
||
|
||
echo ""
|
||
echo -e "${GREEN}✓ Produktions-Setup abgeschlossen!${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}System für Produktion konfiguriert:${NC}"
|
||
echo -e "${WHITE}- Backend läuft als Service${NC}"
|
||
echo -e "${WHITE}- Kiosk-Modus aktiviert${NC}"
|
||
echo -e "${WHITE}- Browser startet automatisch${NC}"
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
install_development_setup() {
|
||
show_header "Entwicklungs-Setup (Backend + Frontend + Tools)"
|
||
|
||
echo -e "${BLUE}Installiere Entwicklungs-Setup...${NC}"
|
||
echo ""
|
||
|
||
# System-Abhängigkeiten (falls Root)
|
||
if [ $is_root -eq 1 ]; then
|
||
install_system_dependencies
|
||
else
|
||
echo -e "${YELLOW}System-Abhängigkeiten übersprungen (keine Root-Rechte)${NC}"
|
||
fi
|
||
|
||
# Backend installieren
|
||
install_backend
|
||
|
||
# Frontend installieren
|
||
install_frontend
|
||
|
||
# Entwicklungstools konfigurieren
|
||
echo -e "${BLUE}Entwicklungstools konfigurieren...${NC}"
|
||
|
||
# Git Hooks (optional)
|
||
if [ -d ".git" ]; then
|
||
echo -e "${BLUE}Git-Repository erkannt${NC}"
|
||
# Hier könnten Git-Hooks konfiguriert werden
|
||
fi
|
||
|
||
echo ""
|
||
echo -e "${GREEN}✓ Entwicklungs-Setup abgeschlossen!${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}Entwicklungsumgebung bereit:${NC}"
|
||
echo -e "${WHITE}- Backend mit Debug-Modus${NC}"
|
||
echo -e "${WHITE}- Frontend mit Hot-Reload${NC}"
|
||
echo -e "${WHITE}- SSL-Zertifikate für HTTPS${NC}"
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
test_dependencies() {
|
||
show_header "Systemvoraussetzungen prüfen"
|
||
|
||
echo -e "${BLUE}Prüfe Abhängigkeiten...${NC}"
|
||
|
||
local all_installed=1
|
||
|
||
# Python
|
||
if check_command python3; then
|
||
echo -e "${GREEN}✓ Python 3 gefunden${NC}"
|
||
python_version=$(python3 --version 2>&1)
|
||
echo -e "${WHITE} Version: $python_version${NC}"
|
||
elif check_command python; then
|
||
echo -e "${GREEN}✓ Python gefunden${NC}"
|
||
python_version=$(python --version 2>&1)
|
||
echo -e "${WHITE} Version: $python_version${NC}"
|
||
else
|
||
echo -e "${RED}✗ Python nicht gefunden${NC}"
|
||
all_installed=0
|
||
fi
|
||
|
||
# Pip
|
||
if check_command pip3; then
|
||
echo -e "${GREEN}✓ Python Package Manager (pip3) gefunden${NC}"
|
||
elif check_command pip; then
|
||
echo -e "${GREEN}✓ Python Package Manager (pip) gefunden${NC}"
|
||
else
|
||
echo -e "${RED}✗ Python Package Manager (pip) nicht gefunden${NC}"
|
||
all_installed=0
|
||
fi
|
||
|
||
# Node.js
|
||
if check_command node; then
|
||
echo -e "${GREEN}✓ Node.js gefunden${NC}"
|
||
node_version=$(node --version 2>&1)
|
||
echo -e "${WHITE} Version: $node_version${NC}"
|
||
else
|
||
echo -e "${RED}✗ Node.js nicht gefunden${NC}"
|
||
all_installed=0
|
||
fi
|
||
|
||
# npm
|
||
if check_command npm; then
|
||
echo -e "${GREEN}✓ Node Package Manager (npm) gefunden${NC}"
|
||
else
|
||
echo -e "${RED}✗ Node Package Manager (npm) nicht gefunden${NC}"
|
||
all_installed=0
|
||
fi
|
||
|
||
# Git
|
||
if check_command git; then
|
||
echo -e "${GREEN}✓ Git gefunden${NC}"
|
||
else
|
||
echo -e "${RED}✗ Git nicht gefunden${NC}"
|
||
all_installed=0
|
||
fi
|
||
|
||
# OpenSSL
|
||
if check_command openssl; then
|
||
echo -e "${GREEN}✓ OpenSSL gefunden${NC}"
|
||
else
|
||
echo -e "${RED}✗ OpenSSL nicht gefunden${NC}"
|
||
all_installed=0
|
||
fi
|
||
|
||
# SQLite
|
||
if check_command sqlite3; then
|
||
echo -e "${GREEN}✓ SQLite3 gefunden${NC}"
|
||
else
|
||
echo -e "${RED}✗ SQLite3 nicht gefunden${NC}"
|
||
all_installed=0
|
||
fi
|
||
|
||
echo ""
|
||
if [ $all_installed -eq 1 ]; then
|
||
echo -e "${GREEN}✓ Alle Abhängigkeiten sind installiert!${NC}"
|
||
else
|
||
echo -e "${YELLOW}⚠ Einige Abhängigkeiten fehlen. Nutzen Sie 'System-Abhängigkeiten installieren'.${NC}"
|
||
fi
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
setup_hosts() {
|
||
show_header "Host-Konfiguration"
|
||
|
||
if [ $is_root -eq 0 ]; then
|
||
echo -e "${RED}Diese Funktion erfordert Root-Rechte.${NC}"
|
||
echo -e "${YELLOW}Bitte starten Sie das Skript mit sudo oder als Root neu.${NC}"
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
return 1
|
||
fi
|
||
|
||
local_ip=$(get_local_ip)
|
||
echo -e "${GREEN}Lokale IP-Adresse: $local_ip${NC}"
|
||
|
||
hosts_file="/etc/hosts"
|
||
echo -e "${BLUE}Hosts-Datei: $hosts_file${NC}"
|
||
|
||
# Prüfen, ob die Einträge bereits existieren
|
||
frontend_entry=$(grep "m040tbaraspi001.de040.corpintra.net" $hosts_file)
|
||
backend_entry=$(grep "raspberrypi" $hosts_file)
|
||
|
||
# Einträge in die Hosts-Datei schreiben
|
||
echo -e "${BLUE}Aktualisiere Hosts-Datei...${NC}"
|
||
|
||
if [ -z "$frontend_entry" ]; then
|
||
echo "" >> $hosts_file
|
||
echo "# MYP Frontend Host" >> $hosts_file
|
||
echo "$local_ip m040tbaraspi001.de040.corpintra.net m040tbaraspi001" >> $hosts_file
|
||
echo -e "${GREEN}Frontend-Hostname hinzugefügt${NC}"
|
||
else
|
||
echo -e "${YELLOW}Frontend-Hostname ist bereits konfiguriert${NC}"
|
||
fi
|
||
|
||
if [ -z "$backend_entry" ]; then
|
||
echo "" >> $hosts_file
|
||
echo "# MYP Backend Host" >> $hosts_file
|
||
echo "$local_ip raspberrypi" >> $hosts_file
|
||
echo -e "${GREEN}Backend-Hostname hinzugefügt${NC}"
|
||
else
|
||
echo -e "${YELLOW}Backend-Hostname ist bereits konfiguriert${NC}"
|
||
fi
|
||
|
||
echo -e "${GREEN}Konfiguration abgeschlossen!${NC}"
|
||
|
||
echo ""
|
||
echo -e "${BLUE}Folgende Hostnamen sind jetzt konfiguriert:${NC}"
|
||
echo -e "${WHITE} - Frontend: m040tbaraspi001.de040.corpintra.net${NC}"
|
||
echo -e "${WHITE} - Backend: raspberrypi${NC}"
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
test_backend_connection() {
|
||
show_header "Backend-Verbindung prüfen"
|
||
|
||
echo -e "${BLUE}Welches Backend möchten Sie testen?${NC}"
|
||
echo -e "${WHITE}1. Lokales Backend (localhost:443)${NC}"
|
||
echo -e "${WHITE}2. Raspberry Pi Backend (raspberrypi:443)${NC}"
|
||
echo -e "${WHITE}3. Benutzerdefinierte URL${NC}"
|
||
|
||
read -p "Wählen Sie eine Option (1-3, Standard: 1): " choice
|
||
|
||
backend_url="https://localhost:443"
|
||
backend_host="localhost"
|
||
|
||
case $choice in
|
||
2)
|
||
backend_url="https://raspberrypi:443"
|
||
backend_host="raspberrypi"
|
||
;;
|
||
3)
|
||
read -p "Backend-URL eingeben (z.B. https://raspberrypi:443): " backend_url
|
||
backend_host=$(echo "$backend_url" | sed -E 's|https?://([^:/]+).*|\1|')
|
||
;;
|
||
*)
|
||
backend_url="https://localhost:443"
|
||
backend_host="localhost"
|
||
;;
|
||
esac
|
||
|
||
echo ""
|
||
echo -e "${BLUE}Teste Backend: $backend_url${NC}"
|
||
echo ""
|
||
|
||
# 1. Netzwerk-Konnektivität prüfen
|
||
echo -e "${BLUE}1. Prüfe Netzwerk-Konnektivität zu $backend_host...${NC}"
|
||
if ping -c 1 -W 3 "$backend_host" >/dev/null 2>&1; then
|
||
echo -e "${GREEN}✓ Ping zu $backend_host erfolgreich${NC}"
|
||
else
|
||
echo -e "${RED}✗ Ping zu $backend_host fehlgeschlagen${NC}"
|
||
fi
|
||
|
||
# 2. Backend-Service prüfen
|
||
echo -e "${BLUE}2. Prüfe Backend-Service...${NC}"
|
||
health_url="$backend_url/health"
|
||
if curl -f --connect-timeout 5 "$health_url" >/dev/null 2>&1; then
|
||
echo -e "${GREEN}✓ Backend-Health-Check erfolgreich${NC}"
|
||
elif curl -f --connect-timeout 5 "$backend_url" >/dev/null 2>&1; then
|
||
echo -e "${YELLOW}⚠ Backend erreichbar, aber kein Health-Endpoint${NC}"
|
||
else
|
||
echo -e "${RED}✗ Backend-Service nicht erreichbar${NC}"
|
||
fi
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
setup_backend_url() {
|
||
local backend_url="$1"
|
||
|
||
show_header "Backend-URL konfigurieren"
|
||
|
||
if [ -z "$backend_url" ]; then
|
||
echo -e "${BLUE}Verfügbare Backend-Konfigurationen:${NC}"
|
||
echo -e "${WHITE}1. Lokale Entwicklung (https://localhost:443)${NC}"
|
||
echo -e "${WHITE}2. Raspberry Pi (https://raspberrypi:443)${NC}"
|
||
echo -e "${WHITE}3. Benutzerdefinierte URL${NC}"
|
||
|
||
read -p "Wählen Sie eine Option (1-3, Standard: 1): " choice
|
||
|
||
case $choice in
|
||
2)
|
||
backend_url="https://raspberrypi:443"
|
||
;;
|
||
3)
|
||
read -p "Backend-URL eingeben (z.B. https://raspberrypi:443): " backend_url
|
||
;;
|
||
*)
|
||
backend_url="https://localhost:443"
|
||
;;
|
||
esac
|
||
fi
|
||
|
||
echo -e "${BLUE}Konfiguriere Frontend für Backend: $backend_url${NC}"
|
||
|
||
# .env.local erstellen/aktualisieren
|
||
env_local_path="frontend/.env.local"
|
||
backend_host=$(echo "$backend_url" | sed -E 's|https?://([^:/]+).*|\1|')
|
||
backend_protocol=$(echo "$backend_url" | sed -E 's|^(https?)://.*|\1|')
|
||
|
||
cat > "$env_local_path" << EOF
|
||
# Backend API Konfiguration
|
||
NEXT_PUBLIC_API_URL=$backend_url
|
||
|
||
# Frontend-URL für OAuth Callback
|
||
NEXT_PUBLIC_FRONTEND_URL=http://localhost:3000
|
||
|
||
# OAuth Konfiguration
|
||
NEXT_PUBLIC_OAUTH_CALLBACK_URL=http://localhost:3000/auth/login/callback
|
||
|
||
# GitHub OAuth (hardcodiert)
|
||
GITHUB_CLIENT_ID=7c5d8bef1a5519ec1fdc
|
||
GITHUB_CLIENT_SECRET=5f1e586204358fbd53cf5fb7d418b3f06ccab8fd
|
||
|
||
# Entwicklungsumgebung
|
||
NODE_ENV=development
|
||
DEBUG=true
|
||
NEXT_DEBUG=true
|
||
|
||
# Backend Host
|
||
NEXT_PUBLIC_BACKEND_HOST=$backend_host
|
||
NEXT_PUBLIC_BACKEND_PROTOCOL=$backend_protocol
|
||
EOF
|
||
|
||
if [ $? -eq 0 ]; then
|
||
echo -e "${GREEN}✓ .env.local erfolgreich erstellt/aktualisiert${NC}"
|
||
else
|
||
echo -e "${RED}✗ Fehler beim Erstellen der .env.local${NC}"
|
||
fi
|
||
|
||
echo ""
|
||
echo -e "${GREEN}Frontend-Konfiguration abgeschlossen!${NC}"
|
||
echo -e "${WHITE}Backend: $backend_url${NC}"
|
||
echo -e "${WHITE}Frontend: http://localhost:3000${NC}"
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
start_application() {
|
||
show_header "Anwendung starten"
|
||
|
||
echo -e "${BLUE}Welche Komponente möchten Sie starten?${NC}"
|
||
echo -e "${WHITE}1. Backend-Server starten (Flask API)${NC}"
|
||
echo -e "${WHITE}2. Frontend-Server starten (Next.js)${NC}"
|
||
echo -e "${WHITE}3. Kiosk-Modus starten (Backend Web Interface)${NC}"
|
||
echo -e "${WHITE}4. Beide Server starten (Backend + Frontend)${NC}"
|
||
echo -e "${WHITE}5. Frontend Produktions-Deployment (Port 80/443 mit SSL)${NC}"
|
||
echo -e "${WHITE}6. Debug-Server starten${NC}"
|
||
echo -e "${WHITE}7. Zurück zum Hauptmenü${NC}"
|
||
|
||
read -p "Wählen Sie eine Option (1-7): " choice
|
||
|
||
case $choice in
|
||
1)
|
||
echo -e "${BLUE}Starte Backend-Server...${NC}"
|
||
if [ -d "$VENV_DIR" ]; then
|
||
cd "$APP_DIR"
|
||
source "$VENV_DIR/bin/activate"
|
||
python app.py &
|
||
echo -e "${GREEN}Backend-Server gestartet: https://localhost:443${NC}"
|
||
deactivate
|
||
cd "$PROJECT_DIR"
|
||
else
|
||
echo -e "${RED}Backend nicht installiert. Bitte installieren Sie zuerst das Backend.${NC}"
|
||
fi
|
||
;;
|
||
2)
|
||
echo -e "${BLUE}Starte Frontend-Server...${NC}"
|
||
if [ -d "$FRONTEND_DIR/node_modules" ]; then
|
||
cd "$FRONTEND_DIR"
|
||
npm run dev &
|
||
echo -e "${GREEN}Frontend-Server gestartet: http://localhost:3000${NC}"
|
||
cd "$PROJECT_DIR"
|
||
else
|
||
echo -e "${RED}Frontend nicht installiert. Bitte installieren Sie zuerst das Frontend.${NC}"
|
||
fi
|
||
;;
|
||
3)
|
||
echo -e "${BLUE}Starte Kiosk-Modus...${NC}"
|
||
if [ $is_root -eq 1 ]; then
|
||
systemctl start myp-kiosk
|
||
echo -e "${GREEN}Kiosk-Modus gestartet${NC}"
|
||
else
|
||
echo -e "${RED}Root-Rechte erforderlich für Kiosk-Service${NC}"
|
||
fi
|
||
;;
|
||
4)
|
||
echo -e "${BLUE}Starte Backend und Frontend...${NC}"
|
||
# Backend starten
|
||
if [ -d "$VENV_DIR" ]; then
|
||
cd "$APP_DIR"
|
||
source "$VENV_DIR/bin/activate"
|
||
python app.py &
|
||
echo -e "${GREEN}Backend gestartet: https://localhost:443${NC}"
|
||
deactivate
|
||
cd "$PROJECT_DIR"
|
||
fi
|
||
# Frontend starten
|
||
if [ -d "$FRONTEND_DIR/node_modules" ]; then
|
||
cd "$FRONTEND_DIR"
|
||
npm run dev &
|
||
echo -e "${GREEN}Frontend gestartet: http://localhost:3000${NC}"
|
||
cd "$PROJECT_DIR"
|
||
fi
|
||
;;
|
||
5)
|
||
deploy_frontend_production
|
||
;;
|
||
6)
|
||
start_debug_server
|
||
;;
|
||
7)
|
||
return
|
||
;;
|
||
*)
|
||
echo -e "${RED}Ungültige Option.${NC}"
|
||
;;
|
||
esac
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
start_debug_server() {
|
||
show_header "Debug-Server starten"
|
||
|
||
echo -e "${BLUE}Welchen Debug-Server möchten Sie starten?${NC}"
|
||
echo -e "${WHITE}1. Frontend Debug-Server (Next.js Development)${NC}"
|
||
echo -e "${WHITE}2. Backend Debug-Server (Flask Debug Mode)${NC}"
|
||
echo -e "${WHITE}3. Einfacher HTTP-Server (Debug-Server Verzeichnis)${NC}"
|
||
|
||
read -p "Wählen Sie eine Option (1-3): " choice
|
||
|
||
case $choice in
|
||
1)
|
||
if [ -d "$FRONTEND_DIR" ]; then
|
||
cd "$FRONTEND_DIR"
|
||
npm run dev
|
||
cd "$PROJECT_DIR"
|
||
else
|
||
echo -e "${RED}Frontend-Verzeichnis nicht gefunden${NC}"
|
||
fi
|
||
;;
|
||
2)
|
||
if [ -d "$VENV_DIR" ]; then
|
||
cd "$APP_DIR"
|
||
source "$VENV_DIR/bin/activate"
|
||
python app.py --debug
|
||
deactivate
|
||
cd "$PROJECT_DIR"
|
||
else
|
||
echo -e "${RED}Backend nicht installiert${NC}"
|
||
fi
|
||
;;
|
||
3)
|
||
debug_dir="$FRONTEND_DIR/debug-server"
|
||
if [ -d "$debug_dir" ]; then
|
||
cd "$debug_dir"
|
||
if check_command node; then
|
||
node src/app.js
|
||
else
|
||
echo -e "${RED}Node.js nicht gefunden${NC}"
|
||
fi
|
||
cd "$PROJECT_DIR"
|
||
else
|
||
echo -e "${RED}Debug-Server-Verzeichnis nicht gefunden${NC}"
|
||
fi
|
||
;;
|
||
*)
|
||
echo -e "${RED}Ungültige Option${NC}"
|
||
;;
|
||
esac
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
show_ssl_status() {
|
||
show_header "SSL-Zertifikat-Status"
|
||
|
||
cert_paths=(
|
||
"backend/app/certs/myp.crt"
|
||
"backend/app/certs/myp.key"
|
||
"frontend/ssl/myp.crt"
|
||
"frontend/ssl/myp.key"
|
||
)
|
||
|
||
echo -e "${BLUE}Prüfe SSL-Zertifikate...${NC}"
|
||
echo ""
|
||
|
||
for cert_path in "${cert_paths[@]}"; do
|
||
if [ -f "$cert_path" ]; then
|
||
echo -e "${GREEN}✓ Gefunden: $cert_path${NC}"
|
||
|
||
# Zertifikatsinformationen anzeigen (falls OpenSSL verfügbar)
|
||
if check_command openssl && [[ "$cert_path" == *.crt ]]; then
|
||
cert_info=$(openssl x509 -in "$cert_path" -noout -subject -dates 2>/dev/null)
|
||
if [ -n "$cert_info" ]; then
|
||
echo -e "${WHITE} $cert_info${NC}"
|
||
fi
|
||
fi
|
||
else
|
||
echo -e "${RED}✗ Fehlt: $cert_path${NC}"
|
||
fi
|
||
done
|
||
|
||
echo ""
|
||
echo -e "${BLUE}SSL-Konfiguration in settings.py:${NC}"
|
||
settings_path="backend/app/config/settings.py"
|
||
if [ -f "$settings_path" ]; then
|
||
if grep -q "SSL_ENABLED.*=.*True" "$settings_path"; then
|
||
echo -e "${GREEN}✓ SSL ist aktiviert${NC}"
|
||
else
|
||
echo -e "${YELLOW}⚠ SSL ist deaktiviert${NC}"
|
||
fi
|
||
else
|
||
echo -e "${RED}✗ settings.py nicht gefunden${NC}"
|
||
fi
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
create_ssl_certificates() {
|
||
show_header "SSL-Zertifikat-Generator"
|
||
|
||
# Parameter definieren
|
||
cert_dir="./backend/app/certs"
|
||
backend_cert_file="$cert_dir/myp.crt"
|
||
backend_key_file="$cert_dir/myp.key"
|
||
frontend_cert_file="$cert_dir/frontend.crt"
|
||
frontend_key_file="$cert_dir/frontend.key"
|
||
|
||
echo -e "${BLUE}Zertifikate werden für folgende Hostnamen erstellt:${NC}"
|
||
|
||
# Hostname-Auswahl
|
||
echo -e "${WHITE}1. Für lokale Entwicklung (localhost)${NC}"
|
||
echo -e "${WHITE}2. Für Raspberry Pi Deployment (raspberrypi)${NC}"
|
||
echo -e "${WHITE}3. Für Unternehmens-Setup (m040tbaraspi001.de040.corpintra.net)${NC}"
|
||
|
||
read -p "Wählen Sie eine Option (1-3, Standard: 1): " choice
|
||
|
||
backend_hostname="localhost"
|
||
frontend_hostname="localhost"
|
||
|
||
case $choice in
|
||
2)
|
||
backend_hostname="raspberrypi"
|
||
frontend_hostname="raspberrypi"
|
||
;;
|
||
3)
|
||
backend_hostname="raspberrypi"
|
||
frontend_hostname="m040tbaraspi001.de040.corpintra.net"
|
||
;;
|
||
*)
|
||
backend_hostname="localhost"
|
||
frontend_hostname="localhost"
|
||
;;
|
||
esac
|
||
|
||
echo -e "${BLUE}Backend-Hostname: $backend_hostname${NC}"
|
||
echo -e "${BLUE}Frontend-Hostname: $frontend_hostname${NC}"
|
||
echo ""
|
||
|
||
# Verzeichnis erstellen, falls es nicht existiert
|
||
if [ ! -d "$cert_dir" ]; then
|
||
echo -e "${BLUE}Erstelle Verzeichnis $cert_dir...${NC}"
|
||
mkdir -p "$cert_dir"
|
||
fi
|
||
|
||
# SSL-Zertifikate mit Python und cryptography erstellen
|
||
echo -e "${BLUE}Erstelle SSL-Zertifikate mit Python...${NC}"
|
||
|
||
# Überprüfen, ob Python verfügbar ist
|
||
python_cmd=""
|
||
if check_command python3; then
|
||
python_cmd="python3"
|
||
elif check_command python; then
|
||
python_cmd="python"
|
||
else
|
||
echo -e "${RED}Python nicht gefunden. SSL-Zertifikate können nicht erstellt werden.${NC}"
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
return 1
|
||
fi
|
||
|
||
# Python-Skript zur Zertifikatserstellung erstellen
|
||
cat > temp_cert_script.py << EOL
|
||
#!/usr/bin/env python3
|
||
import os
|
||
import datetime
|
||
import sys
|
||
|
||
try:
|
||
from cryptography import x509
|
||
from cryptography.x509.oid import NameOID
|
||
from cryptography.hazmat.primitives import hashes
|
||
from cryptography.hazmat.primitives.asymmetric import rsa
|
||
from cryptography.hazmat.primitives.serialization import Encoding, PrivateFormat, NoEncryption
|
||
import ipaddress
|
||
except ImportError as e:
|
||
print(f"Fehler: Paket nicht gefunden: {e}")
|
||
print("Bitte installieren Sie es mit: pip install cryptography")
|
||
sys.exit(1)
|
||
|
||
def create_self_signed_cert(cert_path, key_path, hostname="localhost"):
|
||
# Verzeichnis erstellen, falls es nicht existiert
|
||
cert_dir = os.path.dirname(cert_path)
|
||
if cert_dir and not os.path.exists(cert_dir):
|
||
os.makedirs(cert_dir, exist_ok=True)
|
||
|
||
# Privaten Schlüssel generieren
|
||
private_key = rsa.generate_private_key(
|
||
public_exponent=65537,
|
||
key_size=4096,
|
||
)
|
||
|
||
# Schlüsseldatei schreiben
|
||
with open(key_path, "wb") as key_file:
|
||
key_file.write(private_key.private_bytes(
|
||
encoding=Encoding.PEM,
|
||
format=PrivateFormat.TraditionalOpenSSL,
|
||
encryption_algorithm=NoEncryption()
|
||
))
|
||
|
||
# Aktuelles Datum und Ablaufdatum berechnen
|
||
now = datetime.datetime.now()
|
||
valid_until = now + datetime.timedelta(days=3650) # 10 Jahre gültig
|
||
|
||
# Name für das Zertifikat erstellen
|
||
subject = issuer = x509.Name([
|
||
x509.NameAttribute(NameOID.COMMON_NAME, hostname),
|
||
x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Mercedes-Benz AG"),
|
||
x509.NameAttribute(NameOID.ORGANIZATIONAL_UNIT_NAME, "Werk 040 Berlin"),
|
||
x509.NameAttribute(NameOID.COUNTRY_NAME, "DE"),
|
||
x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, "Berlin"),
|
||
x509.NameAttribute(NameOID.LOCALITY_NAME, "Berlin")
|
||
])
|
||
|
||
# Zertifikat erstellen
|
||
cert = x509.CertificateBuilder().subject_name(
|
||
subject
|
||
).issuer_name(
|
||
issuer
|
||
).public_key(
|
||
private_key.public_key()
|
||
).serial_number(
|
||
x509.random_serial_number()
|
||
).not_valid_before(
|
||
now
|
||
).not_valid_after(
|
||
valid_until
|
||
).add_extension(
|
||
x509.SubjectAlternativeName([
|
||
x509.DNSName(hostname),
|
||
x509.DNSName("localhost"),
|
||
x509.IPAddress(ipaddress.IPv4Address("127.0.0.1"))
|
||
]),
|
||
critical=False,
|
||
).add_extension(
|
||
x509.BasicConstraints(ca=True, path_length=None), critical=True
|
||
).add_extension(
|
||
x509.KeyUsage(
|
||
digital_signature=True,
|
||
content_commitment=False,
|
||
key_encipherment=True,
|
||
data_encipherment=False,
|
||
key_agreement=False,
|
||
key_cert_sign=True,
|
||
crl_sign=True,
|
||
encipher_only=False,
|
||
decipher_only=False
|
||
), critical=True
|
||
).add_extension(
|
||
x509.ExtendedKeyUsage([
|
||
x509.oid.ExtendedKeyUsageOID.SERVER_AUTH,
|
||
x509.oid.ExtendedKeyUsageOID.CLIENT_AUTH
|
||
]), critical=False
|
||
).sign(private_key, hashes.SHA256())
|
||
|
||
# Zertifikatsdatei schreiben
|
||
with open(cert_path, "wb") as cert_file:
|
||
cert_file.write(cert.public_bytes(Encoding.PEM))
|
||
|
||
print(f"SSL-Zertifikat für '{hostname}' erstellt:")
|
||
print(f"Zertifikat: {cert_path}")
|
||
print(f"Schlüssel: {key_path}")
|
||
|
||
# Backend-Zertifikat erstellen
|
||
create_self_signed_cert('$backend_cert_file', '$backend_key_file', '$backend_hostname')
|
||
|
||
# Frontend SSL-Verzeichnis
|
||
frontend_ssl_dir = './frontend/ssl'
|
||
os.makedirs(frontend_ssl_dir, exist_ok=True)
|
||
|
||
# Frontend-Zertifikat erstellen (Kopie des Backend-Zertifikats)
|
||
import shutil
|
||
shutil.copy('$backend_cert_file', './frontend/ssl/myp.crt')
|
||
shutil.copy('$backend_key_file', './frontend/ssl/myp.key')
|
||
|
||
print("SSL-Zertifikate erfolgreich erstellt!")
|
||
EOL
|
||
|
||
# Python-Skript ausführen
|
||
if $python_cmd temp_cert_script.py; then
|
||
echo -e "${GREEN}SSL-Zertifikate erfolgreich erstellt!${NC}"
|
||
else
|
||
echo -e "${RED}Fehler beim Erstellen der SSL-Zertifikate.${NC}"
|
||
fi
|
||
|
||
# Temporäres Skript löschen
|
||
rm -f temp_cert_script.py
|
||
|
||
echo ""
|
||
echo -e "${BLUE}SSL-Zertifikate wurden erstellt:${NC}"
|
||
echo -e "${WHITE}- Backend: $backend_cert_file${NC}"
|
||
echo -e "${WHITE}- Frontend: frontend/ssl/myp.crt${NC}"
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
show_project_info() {
|
||
show_header "Projekt-Informationen"
|
||
|
||
echo -e "${CYAN}MYP (Mercedes-Benz Yard Printing) Platform${NC}"
|
||
echo -e "${BLUE}Version 4.0${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}Beschreibung:${NC}"
|
||
echo -e "${WHITE}Eine vollständige 3D-Drucker-Management-Plattform für Mercedes-Benz Werk 040 Berlin.${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}Komponenten:${NC}"
|
||
echo -e "${WHITE}- Backend: Flask-basierte REST API${NC}"
|
||
echo -e "${WHITE}- Frontend: Next.js React-Anwendung${NC}"
|
||
echo -e "${WHITE}- Kiosk-Modus: Backend Web Interface${NC}"
|
||
echo -e "${WHITE}- Datenbank: SQLite${NC}"
|
||
echo -e "${WHITE}- Authentifizierung: GitHub OAuth + lokale Benutzer${NC}"
|
||
echo -e "${WHITE}- SSL/TLS: Selbstsignierte Zertifikate${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}Standard-Zugangsdaten:${NC}"
|
||
echo -e "${WHITE}- Admin E-Mail: admin@mercedes-benz.com${NC}"
|
||
echo -e "${WHITE}- Admin Passwort: 744563017196A${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}URLs:${NC}"
|
||
echo -e "${WHITE}- Backend API: https://localhost:443${NC}"
|
||
echo -e "${WHITE}- Frontend: http://localhost:3000${NC}"
|
||
echo -e "${WHITE}- Kiosk-Modus: https://localhost:443 (Vollbild)${NC}"
|
||
echo ""
|
||
echo -e "${BLUE}Deployment-Modi:${NC}"
|
||
echo -e "${WHITE}- Entwicklung: Backend + Frontend getrennt${NC}"
|
||
echo -e "${WHITE}- Produktion: Backend + Kiosk-Modus${NC}"
|
||
echo -e "${WHITE}- Vollständig: Alle Komponenten${NC}"
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
clean_old_files() {
|
||
show_header "Alte Dateien bereinigen"
|
||
|
||
read -p "Möchten Sie alte Skriptdateien und temporäre Dateien löschen? (j/n): " clean_files
|
||
|
||
if [ "$clean_files" = "j" ]; then
|
||
files_to_delete=(
|
||
"setup_hosts.sh"
|
||
"setup_ssl.sh"
|
||
"generate_ssl_certs.sh"
|
||
"temp_cert_script.py"
|
||
"frontend/cleanup.sh"
|
||
"frontend/install.sh"
|
||
"frontend/https-setup.sh"
|
||
"frontend/start-debug-server.sh"
|
||
"frontend/start-frontend-server.sh"
|
||
"frontend/check-backend-connection.sh"
|
||
"frontend/setup-backend-url.sh"
|
||
"frontend/start-debug-server.bat"
|
||
"backend/setup_myp.sh"
|
||
"backend/install/create_ssl_cert.sh"
|
||
"backend/install/ssl_check.sh"
|
||
)
|
||
|
||
for file in "${files_to_delete[@]}"; do
|
||
if [ -f "$file" ]; then
|
||
rm -f "$file"
|
||
echo -e "${GREEN}✓ Gelöscht: $file${NC}"
|
||
fi
|
||
done
|
||
|
||
echo -e "${GREEN}Bereinigung abgeschlossen!${NC}"
|
||
else
|
||
echo -e "${BLUE}Bereinigung übersprungen.${NC}"
|
||
fi
|
||
|
||
echo ""
|
||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||
}
|
||
|
||
# Installationsmenü anzeigen
|
||
show_installation_menu() {
|
||
show_header "Installations-Menü"
|
||
|
||
echo -e "${WHITE}📦 SYSTEM-KOMPONENTEN:${NC}"
|
||
echo -e "${WHITE}1. System-Abhängigkeiten installieren${NC}"
|
||
echo -e "${WHITE}2. Python & Node.js Umgebung einrichten${NC}"
|
||
echo ""
|
||
echo -e "${WHITE}🔧 HAUPT-KOMPONENTEN:${NC}"
|
||
echo -e "${WHITE}3. Backend installieren (Flask API)${NC}"
|
||
echo -e "${WHITE}4. Frontend installieren (Next.js React)${NC}"
|
||
echo -e "${WHITE}5. Kiosk-Modus installieren (Backend Web Interface)${NC}"
|
||
echo -e "${WHITE}6. Frontend Produktions-Deployment (Port 80/443 mit SSL)${NC}"
|
||
echo ""
|
||
echo -e "${WHITE}🎯 VOLLINSTALLATIONEN:${NC}"
|
||
echo -e "${WHITE}7. Alles installieren (Backend + Frontend)${NC}"
|
||
echo -e "${WHITE}8. Produktions-Setup (Backend + Kiosk)${NC}"
|
||
echo -e "${WHITE}9. Entwicklungs-Setup (Backend + Frontend + Tools)${NC}"
|
||
echo ""
|
||
echo -e "${WHITE}⚙️ KONFIGURATION:${NC}"
|
||
echo -e "${WHITE}10. SSL-Zertifikate erstellen${NC}"
|
||
echo -e "${WHITE}11. Host-Konfiguration einrichten${NC}"
|
||
echo -e "${WHITE}12. Backend-URL konfigurieren${NC}"
|
||
echo ""
|
||
echo -e "${WHITE}🔍 SYSTEM & TESTS:${NC}"
|
||
echo -e "${WHITE}13. Systemvoraussetzungen prüfen${NC}"
|
||
echo -e "${WHITE}14. Backend-Verbindung testen${NC}"
|
||
echo -e "${WHITE}15. SSL-Status anzeigen${NC}"
|
||
echo ""
|
||
echo -e "${WHITE}🚀 ANWENDUNG STARTEN:${NC}"
|
||
echo -e "${WHITE}16. Server starten (Backend/Frontend/Kiosk)${NC}"
|
||
echo ""
|
||
echo -e "${WHITE}ℹ️ SONSTIGES:${NC}"
|
||
echo -e "${WHITE}17. Projekt-Informationen${NC}"
|
||
echo -e "${WHITE}18. Alte Dateien bereinigen${NC}"
|
||
echo -e "${WHITE}19. Zurück zum Hauptmenü${NC}"
|
||
echo -e "${WHITE}0. Beenden${NC}"
|
||
echo ""
|
||
|
||
read -p "Wählen Sie eine Option (0-19): " choice
|
||
|
||
case $choice in
|
||
1)
|
||
install_system_dependencies
|
||
show_installation_menu
|
||
;;
|
||
2)
|
||
setup_python_node_environment
|
||
show_installation_menu
|
||
;;
|
||
3)
|
||
install_backend
|
||
show_installation_menu
|
||
;;
|
||
4)
|
||
install_frontend
|
||
show_installation_menu
|
||
;;
|
||
5)
|
||
install_kiosk_mode
|
||
show_installation_menu
|
||
;;
|
||
6)
|
||
deploy_frontend_production
|
||
show_installation_menu
|
||
;;
|
||
7)
|
||
install_everything
|
||
show_installation_menu
|
||
;;
|
||
8)
|
||
install_production_setup
|
||
show_installation_menu
|
||
;;
|
||
9)
|
||
install_development_setup
|
||
show_installation_menu
|
||
;;
|
||
10)
|
||
install_development_setup
|
||
show_installation_menu
|
||
;;
|
||
11)
|
||
setup_hosts
|
||
show_installation_menu
|
||
;;
|
||
12)
|
||
setup_backend_url
|
||
show_installation_menu
|
||
;;
|
||
13)
|
||
test_dependencies
|
||
show_installation_menu
|
||
;;
|
||
14)
|
||
test_backend_connection
|
||
show_installation_menu
|
||
;;
|
||
15)
|
||
show_ssl_status
|
||
show_installation_menu
|
||
;;
|
||
16)
|
||
start_application
|
||
;;
|
||
17)
|
||
show_project_info
|
||
show_installation_menu
|
||
;;
|
||
18)
|
||
clean_old_files
|
||
show_installation_menu
|
||
;;
|
||
19)
|
||
show_main_menu
|
||
;;
|
||
0)
|
||
echo -e "${GREEN}Auf Wiedersehen!${NC}"
|
||
exit 0
|
||
;;
|
||
*)
|
||
echo -e "${RED}Ungültige Option. Bitte versuchen Sie es erneut.${NC}"
|
||
sleep 2
|
||
show_installation_menu
|
||
;;
|
||
esac
|
||
}
|
||
|
||
# Hauptmenü anzeigen
|
||
show_main_menu() {
|
||
show_header "Hauptmenü"
|
||
|
||
echo -e "${WHITE}🚀 SCHNELLSTART:${NC}"
|
||
echo -e "${WHITE}1. Vollständige Installation (Alle Komponenten)${NC}"
|
||
echo -e "${WHITE}2. Backend-Only Installation (Kiosk-ready)${NC}"
|
||
echo -e "${WHITE}3. Entwicklungs-Setup (Backend + Frontend)${NC}"
|
||
echo ""
|
||
echo -e "${WHITE}⚙️ GRANULARE INSTALLATION:${NC}"
|
||
echo -e "${WHITE}4. Granulare Installation & Konfiguration${NC}"
|
||
echo ""
|
||
echo -e "${WHITE}🔧 SYSTEM & WARTUNG:${NC}"
|
||
echo -e "${WHITE}5. Systemvoraussetzungen prüfen${NC}"
|
||
echo -e "${WHITE}6. Anwendung starten${NC}"
|
||
echo -e "${WHITE}7. Projekt-Informationen${NC}"
|
||
echo ""
|
||
echo -e "${WHITE}0. Beenden${NC}"
|
||
echo ""
|
||
|
||
read -p "Wählen Sie eine Option (0-7): " choice
|
||
|
||
case $choice in
|
||
1)
|
||
install_everything
|
||
show_main_menu
|
||
;;
|
||
2)
|
||
install_production_setup
|
||
show_main_menu
|
||
;;
|
||
3)
|
||
install_development_setup
|
||
show_main_menu
|
||
;;
|
||
4)
|
||
show_installation_menu
|
||
;;
|
||
5)
|
||
test_dependencies
|
||
show_main_menu
|
||
;;
|
||
6)
|
||
start_application
|
||
show_main_menu
|
||
;;
|
||
7)
|
||
show_project_info
|
||
show_main_menu
|
||
;;
|
||
0)
|
||
echo -e "${GREEN}Auf Wiedersehen!${NC}"
|
||
exit 0
|
||
;;
|
||
*)
|
||
echo -e "${RED}Ungültige Option. Bitte versuchen Sie es erneut.${NC}"
|
||
sleep 2
|
||
show_main_menu
|
||
;;
|
||
esac
|
||
}
|
||
|
||
# Skript starten
|
||
show_main_menu |