infoscreen/server/routes/events.py

from flask import Blueprint, request, jsonify
from database import Session
from models.models import Event, EventMedia, MediaType
from datetime import datetime, timezone
from sqlalchemy import and_
import sys
sys.path.append('/workspace')

events_bp = Blueprint("events", __name__, url_prefix="/api/events")


@events_bp.route("", methods=["GET"])
def get_events():
    session = Session()
    start = request.args.get("start")
    end = request.args.get("end")
    group_id = request.args.get("group_id")
    show_inactive = request.args.get(
        "show_inactive", "0") == "1"  # Checkbox-Logik

    now = datetime.now(timezone.utc)
    events_query = session.query(Event)
    if group_id:
        events_query = events_query.filter(Event.group_id == int(group_id))
    events = events_query.all()

    result = []
    for e in events:
        # Zeitzonen-Korrektur für e.end
        if e.end and e.end.tzinfo is None:
            end_dt = e.end.replace(tzinfo=timezone.utc)
        else:
            end_dt = e.end

        # Setze is_active auf False, wenn Termin vorbei ist
        if end_dt and end_dt < now and e.is_active:
            e.is_active = False
            session.commit()
        if show_inactive or e.is_active:
            result.append({
                "Id": str(e.id),
                "GroupId": e.group_id,
                "Subject": e.title,
                "StartTime": e.start.isoformat() if e.start else None,
                "EndTime": e.end.isoformat() if e.end else None,
                "IsAllDay": False,
                "MediaId": e.event_media_id,
            })
    session.close()
    return jsonify(result)


@events_bp.route("/<event_id>", methods=["DELETE"])
def delete_event(event_id):
    session = Session()
    event = session.query(Event).filter_by(id=event_id).first()
    if not event:
        session.close()
        return jsonify({"error": "Termin nicht gefunden"}), 404
    session.delete(event)
    session.commit()
    session.close()
    return jsonify({"success": True})


@events_bp.route("", methods=["POST"])
def create_event():
    data = request.json
    session = Session()

    # Pflichtfelder prüfen
    required = ["group_id", "title", "description",
                "start", "end", "event_type", "created_by"]
    for field in required:
        if field not in data:
            return jsonify({"error": f"Missing field: {field}"}), 400

    event_type = data["event_type"]
    event_media_id = None
    slideshow_interval = None

    # Präsentation: event_media_id und slideshow_interval übernehmen
    if event_type == "presentation":
        event_media_id = data.get("event_media_id")
        slideshow_interval = data.get("slideshow_interval")
        if not event_media_id:
            return jsonify({"error": "event_media_id required for presentation"}), 400

    # Website: Webseite als EventMedia anlegen und ID übernehmen
    if event_type == "website":
        website_url = data.get("website_url")
        if not website_url:
            return jsonify({"error": "website_url required for website"}), 400
        # EventMedia für Webseite anlegen
        media = EventMedia(
            media_type=MediaType.website,
            url=website_url,
            file_path=website_url
        )
        session.add(media)
        session.commit()
        event_media_id = media.id

    # created_by aus den Daten holen, Default: None
    created_by = data.get("created_by")

    # Start- und Endzeit in UTC umwandeln, falls kein Zulu-Zeitstempel
    start = datetime.fromisoformat(data["start"])
    end = datetime.fromisoformat(data["end"])
    if start.tzinfo is None:
        start = start.astimezone(timezone.utc)
    if end.tzinfo is None:
        end = end.astimezone(timezone.utc)

    # Event anlegen
    event = Event(
        group_id=data["group_id"],
        title=data["title"],
        description=data["description"],
        start=start,
        end=end,
        event_type=event_type,
        is_active=True,
        event_media_id=event_media_id,
        slideshow_interval=slideshow_interval,
        created_by=created_by  # <--- HIER hinzugefügt
    )
    session.add(event)
    session.commit()
    return jsonify({"success": True, "event_id": event.id})


@events_bp.route("/<event_id>", methods=["PUT"])
def update_event(event_id):
    data = request.json
    session = Session()
    event = session.query(Event).filter_by(id=event_id).first()
    if not event:
        session.close()
        return jsonify({"error": "Termin nicht gefunden"}), 404

    event.title = data.get("title", event.title)
    event.description = data.get("description", event.description)
    event.start = datetime.fromisoformat(
        data["start"]) if "start" in data else event.start
    event.end = datetime.fromisoformat(
        data["end"]) if "end" in data else event.end
    event.event_type = data.get("event_type", event.event_type)
    event.event_media_id = data.get("event_media_id", event.event_media_id)
    event.slideshow_interval = data.get(
        "slideshow_interval", event.slideshow_interval)
    event.created_by = data.get("created_by", event.created_by)
    session.commit()
    event_id_return = event.id  # <-- ID vor session.close() speichern!
    session.close()
    return jsonify({"success": True, "event_id": event_id_return})