server.py

from flask import Flask, jsonify, request, send_from_directory
import requests
from apscheduler.schedulers.background import BackgroundScheduler
from datetime import datetime
from bs4 import BeautifulSoup, Tag
import sqlite3
import os

app = Flask(__name__)

URL = "https://www.stw.berlin/mensen/einrichtungen/technische-universit%C3%A4t-berlin/mensa-tu-marchstra%C3%9Fe.html"

last_run = None
last_status = None
main_dishes_data = None


# Database initialization
def init_db():
    conn = sqlite3.connect("ratings.db")
    cursor = conn.cursor()
    cursor.execute(
        """
        CREATE TABLE IF NOT EXISTS ratings (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            dish_name TEXT NOT NULL,
            rating INTEGER NOT NULL CHECK (rating >= 1 AND rating <= 5),
            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
        )
    """
    )
    conn.commit()
    conn.close()


# Initialize database on startup
init_db()


def fetch_mensa_page():
    global last_run, last_status, main_dishes_data
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
    }
    try:
        html = requests.get(URL, headers=headers, timeout=20).text
        soup = BeautifulSoup(html, "html.parser")
        speiseplan = soup.find(id="speiseplan")
        if not speiseplan:
            last_status = "Speiseplan not found"
            return

        # Find all splGroupWrapper containers
        group_wrappers = speiseplan.find_all("div", class_="splGroupWrapper")

        descriptions = []
        for wrapper in group_wrappers:
            # Check if this wrapper contains the "Essen" group
            group_div = wrapper.find("div", class_="splGroup")
            if group_div and group_div.get_text(strip=True) == "Essen":
                # Find all splMeal divs that follow this group
                meal_divs = wrapper.find_all("div", class_="splMeal")
                for meal in meal_divs:
                    desc_tag = meal.find("span", class_="bold")
                    if desc_tag:
                        desc = desc_tag.get_text(strip=True)
                        descriptions.append(desc)
                break  # Found Essen group, no need to continue

        main_dishes_data = descriptions[:3]
        last_status = "Success"

        # Save HTML to file for analysis
        with open("last_mensa.html", "w", encoding="utf-8") as f:
            f.write(html)
    except Exception as e:
        last_status = str(e)
    last_run = datetime.now().strftime("%Y-%m-%d %H:%M:%S")


scheduler = BackgroundScheduler()
scheduler.add_job(fetch_mensa_page, "cron", hour=8, minute=0)
scheduler.start()


@app.route("/status")
def status():
    return jsonify(
        {
            "last_run": last_run,
            "last_status": last_status,
            "main_dishes": main_dishes_data,
        }
    )


@app.route("/fetch-now")
def fetch_now():
    fetch_mensa_page()
    return jsonify(
        {"message": "Fetch triggered", "last_run": last_run, "last_status": last_status}
    )


@app.route("/main-dishes")
def main_dishes():
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
    }
    try:
        html = requests.get(URL, headers=headers, timeout=20).text
        soup = BeautifulSoup(html, "html.parser")
        speiseplan = soup.find(id="speiseplan")
        if not speiseplan:
            return jsonify({"error": "Speiseplan not found"}), 404

        # Find all splGroupWrapper containers
        group_wrappers = speiseplan.find_all("div", class_="splGroupWrapper")

        descriptions = []
        for wrapper in group_wrappers:
            # Check if this wrapper contains the "Essen" group
            group_div = wrapper.find("div", class_="splGroup")
            if group_div and group_div.get_text(strip=True) == "Essen":
                # Find all splMeal divs that follow this group
                meal_divs = wrapper.find_all("div", class_="splMeal")
                for meal in meal_divs:
                    desc_tag = meal.find("span", class_="bold")
                    if desc_tag:
                        desc = desc_tag.get_text(strip=True)
                        descriptions.append(desc)
                break  # Found Essen group, no need to continue

        return jsonify({"main_dishes": descriptions[:3]})
    except Exception as e:
        return jsonify({"error": str(e)}), 500


@app.route("/submit-rating", methods=["POST"])
def submit_rating():
    try:
        data = request.get_json()
        dish_name = data.get("dish_name")
        rating = data.get("rating")

        if not dish_name or not rating:
            return jsonify({"error": "Missing dish_name or rating"}), 400

        if not isinstance(rating, int) or rating < 1 or rating > 5:
            return jsonify({"error": "Rating must be an integer between 1 and 5"}), 400

        conn = sqlite3.connect("ratings.db")
        cursor = conn.cursor()
        cursor.execute(
            "INSERT INTO ratings (dish_name, rating) VALUES (?, ?)", (dish_name, rating)
        )
        conn.commit()
        conn.close()

        return jsonify({"message": "Rating submitted successfully"}), 200
    except Exception as e:
        return jsonify({"error": str(e)}), 500


@app.route("/ratings")
def get_ratings():
    try:
        conn = sqlite3.connect("ratings.db")
        cursor = conn.cursor()
        cursor.execute(
            """
            SELECT dish_name, 
                   COUNT(*) as count, 
                   AVG(rating) as avg_rating,
                   MIN(rating) as min_rating,
                   MAX(rating) as max_rating
            FROM ratings 
            GROUP BY dish_name
            ORDER BY avg_rating DESC
        """
        )
        results = cursor.fetchall()
        conn.close()

        ratings_data = []
        for row in results:
            ratings_data.append(
                {
                    "dish_name": row[0],
                    "count": row[1],
                    "avg_rating": round(row[2], 2) if row[2] else 0,
                    "min_rating": row[3],
                    "max_rating": row[4],
                }
            )

        return jsonify({"ratings": ratings_data})
    except Exception as e:
        return jsonify({"error": str(e)}), 500


@app.route("/all-reviews")
def get_all_reviews():
    try:
        conn = sqlite3.connect("ratings.db")
        cursor = conn.cursor()
        cursor.execute(
            """
            SELECT id, dish_name, rating, timestamp
            FROM ratings 
            ORDER BY timestamp DESC
        """
        )
        results = cursor.fetchall()
        conn.close()

        reviews_data = []
        for row in results:
            reviews_data.append(
                {
                    "id": row[0],
                    "dish_name": row[1],
                    "rating": row[2],
                    "timestamp": row[3],
                }
            )

        return jsonify({"reviews": reviews_data, "total_count": len(reviews_data)})
    except Exception as e:
        return jsonify({"error": str(e)}), 500


@app.route("/")
def index():
    return send_from_directory(".", "index.html")


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

# Next step: Open 'last_mensa.html' and inspect the structure of the divs to refine the BeautifulSoup parsing logic for the main dishes.