infoscreen/server/wsgi.py

# server/wsgi.py
from models import Client, ClientGroup
from flask import request, jsonify
import glob
import os
from flask import Flask, jsonify, send_from_directory, request
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine, and_
from models import Client, Base, Event, ClientGroup

DB_USER = os.getenv("DB_USER")
DB_PASSWORD = os.getenv("DB_PASSWORD")
DB_HOST = os.getenv("DB_HOST")
DB_NAME = os.getenv("DB_NAME")

# Datenbank-Engine und Session anlegen (passe ggf. die DB-URL an)
DB_URL = f"mysql+pymysql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}/{DB_NAME}"
engine = create_engine(DB_URL, echo=False)
Session = sessionmaker(bind=engine)

app = Flask(__name__)


@app.route("/health")
def health():
    return jsonify(status="ok")

# Optional: Test-Route


@app.route("/")
def index():
    return "Hello from Infoscreen‐API!"

# (Weitere Endpunkte, Blueprints, Datenbank-Initialisierung usw. kommen hierher)


@app.route("/screenshots/<uuid>")
def get_screenshot(uuid):
    """Liefert den aktuellen Screenshot für die angegebene UUID zurück."""
    print(f"Anfrage für Screenshot mit UUID: {uuid}")
    pattern = os.path.join("screenshots", f"{uuid}*.jpg")
    files = glob.glob(pattern)
    if not files:
        return jsonify({"error": "Screenshot not found"}), 404
    # Es gibt nur eine Datei pro UUID
    filename = os.path.basename(files[0])
    print(filename)
    print("Arbeitsverzeichnis:", os.getcwd())
    print("Suchmuster:", pattern)
    print("Gefundene Dateien:", files)
    return send_from_directory("screenshots", filename)


@app.route("/api/clients")
def get_clients():
    # from models import Client  # Import lokal, da im selben Container
    print("Abrufen der Clients aus der Datenbank...")
    session = Session()
    clients = session.query(Client).all()
    result = [
        {
            "uuid": c.uuid,
            "location": c.location,
            "hardware_hash": c.hardware_hash,
            "ip_address": c.ip_address,
            "last_alive": c.last_alive.isoformat() if c.last_alive else None,
            "group_id": c.group_id,
        }
        for c in clients
    ]
    session.close()
    return jsonify(result)


@app.route("/api/events")
def get_events():
    session = Session()
    start = request.args.get("start")
    end = request.args.get("end")
    client_uuid = request.args.get("client_uuid")
    query = session.query(Event).filter(Event.is_active == True)
    if start and end:
        query = query.filter(and_(Event.start < end, Event.end > start))
    if client_uuid:
        query = query.filter(Event.client_uuid == client_uuid)
    events = query.all()
    result = []
    for e in events:
        result.append({
            "Id": str(e.id),
            "Subject": e.title,
            "StartTime": e.start.isoformat() if e.start else None,
            "EndTime": e.end.isoformat() if e.end else None,
            "IsAllDay": False,
            # Optional: weitere Felder wie "Description", "Location", etc.
        })
    session.close()
    return jsonify(result)


@app.route("/api/groups", methods=["POST"])
def create_group():
    data = request.get_json()
    name = data.get("name")
    if not name or not name.strip():
        return jsonify({"error": "Gruppenname erforderlich"}), 400

    session = Session()
    # Prüfen, ob der Name schon existiert
    if session.query(ClientGroup).filter_by(name=name).first():
        session.close()
        return jsonify({"error": "Gruppe existiert bereits"}), 409

    group = ClientGroup(name=name, is_active=True)
    session.add(group)
    session.commit()
    result = {
        "id": group.id,
        "name": group.name,
        "created_at": group.created_at.isoformat() if group.created_at else None,
        "is_active": group.is_active,
    }
    session.close()
    return jsonify(result), 201


@app.route("/api/groups", methods=["GET"])
def get_groups():
    """Liefert alle Raumgruppen als Liste zurück."""
    session = Session()
    groups = session.query(ClientGroup).all()
    result = [
        {
            "id": g.id,
            "name": g.name,
            "created_at": g.created_at.isoformat() if g.created_at else None,
            "is_active": g.is_active,
        }
        for g in groups
    ]
    session.close()
    return jsonify(result)


@app.route("/api/groups/<int:group_id>", methods=["PUT"])
def update_group(group_id):
    """Ändert den Namen oder Status einer Raumgruppe."""
    data = request.get_json()
    session = Session()
    group = session.query(ClientGroup).filter_by(id=group_id).first()
    if not group:
        session.close()
        return jsonify({"error": "Gruppe nicht gefunden"}), 404
    if "name" in data:
        group.name = data["name"]
    if "is_active" in data:
        group.is_active = bool(data["is_active"])
    session.commit()
    result = {
        "id": group.id,
        "name": group.name,
        "created_at": group.created_at.isoformat() if group.created_at else None,
        "is_active": group.is_active,
    }
    session.close()
    return jsonify(result)


@app.route("/api/groups/<int:group_id>", methods=["DELETE"])
def delete_group(group_id):
    """Löscht eine Raumgruppe."""
    session = Session()
    group = session.query(ClientGroup).filter_by(id=group_id).first()
    if not group:
        session.close()
        return jsonify({"error": "Gruppe nicht gefunden"}), 404
    session.delete(group)
    session.commit()
    session.close()
    return jsonify({"success": True})


@app.route("/api/clients/group", methods=["PUT"])
def update_clients_group():
    data = request.get_json()
    client_ids = data.get("client_ids", [])
    group_name = data.get("group_name")
    print(f"Update Clients Group: {group_name}, IDs: {client_ids}")
    session = Session()
    group = session.query(ClientGroup).filter_by(name=group_name).first()
    if not group:
        session.close()
        return jsonify({"error": "Gruppe nicht gefunden"}), 404
    session.query(Client).filter(Client.uuid.in_(client_ids)).update(
        {Client.group_id: group.id}, synchronize_session=False
    )
    session.commit()
    session.close()
    return jsonify({"success": True})


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000, debug=True)