datecalc/app.py

from flask import Flask, render_template, request, redirect, url_for, session, jsonify, make_response
from flask_babel import Babel, gettext, get_locale
from datetime import datetime, timedelta
import numpy as np
from dateutil.relativedelta import relativedelta
import os
import time
import requests

app_start_time = time.time()

app = Flask(__name__)
app.secret_key = os.environ.get('SECRET_KEY', 'dev-key')

# Babel Konfiguration
app.config['BABEL_DEFAULT_LOCALE'] = 'de'
app.config['BABEL_SUPPORTED_LOCALES'] = ['de', 'en']
app.config['BABEL_TRANSLATION_DIRECTORIES'] = 'translations'

babel = Babel()

# Version der App
APP_VERSION = "1.4.13"

def add_cache_headers(response):
    """Fügt Cache-Control-Header hinzu, die den Back-Forward-Cache ermöglichen"""
    # Cache-Control für statische Inhalte und API-Endpunkte
    if request.path.startswith('/static/') or request.path.startswith('/api/'):
        response.headers['Cache-Control'] = 'public, max-age=3600, s-maxage=3600'
    else:
        # Für HTML-Seiten: kurze Cache-Zeit, aber Back-Forward-Cache erlauben
        response.headers['Cache-Control'] = 'public, max-age=60, s-maxage=300'
    
    # Wichtig: Keine Vary-Header für User-Agent oder andere dynamische Werte
    # Dies verhindert den Back-Forward-Cache
    if 'Vary' in response.headers:
        del response.headers['Vary']
    
    return response

# HTML-Template wird jetzt aus templates/index.html geladen

WOCHENTAGE = ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"]
WOCHENTAGE_EN = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]

def get_locale():
    # Prüfe URL-Parameter für Sprachauswahl (datenschutzfreundlich)
    if request.args.get('lang') in ['de', 'en']:
        return request.args.get('lang')
    # Prüfe Session für Sprachauswahl (Fallback für ältere Browser)
    if 'language' in session:
        return session['language']
    # Fallback auf Browser-Sprache
    return request.accept_languages.best_match(['de', 'en'], default='de')

# Registriere die Locale-Funktion mit Babel
babel.init_app(app, locale_selector=get_locale)

def get_wochentage():
    """Gibt die Wochentage in der aktuellen Sprache zurück"""
    locale = get_locale()
    if locale == 'en':
        return WOCHENTAGE_EN
    return WOCHENTAGE

def get_feiertage(year, bundesland):
    """Holt die Feiertage für ein Jahr und Bundesland von feiertage-api.de."""
    url = f"https://feiertage-api.de/api/?jahr={year}&nur_land={bundesland}"
    try:
        resp = requests.get(url, timeout=5)
        data = resp.json()
        # Die API gibt ein Dict mit Feiertagsnamen als Key, jeweils mit 'datum' als Wert
        return [v['datum'] for v in data.values() if 'datum' in v]
    except Exception as e:
        print(f"Fehler beim Abrufen der Feiertage: {e}")
        return []

@app.route('/set_language/<language>')
def set_language(language):
    """Setzt die Sprache über URL-Parameter (datenschutzfreundlich)"""
    if language in ['de', 'en']:
        # URL-Parameter verwenden statt Session
        referrer = request.referrer or url_for('index')
        if '?' in referrer:
            # URL hat bereits Parameter
            if 'lang=' in referrer:
                # Ersetze bestehenden lang-Parameter
                import re
                referrer = re.sub(r'[?&]lang=[^&]*', '', referrer)
            return redirect(f"{referrer}&lang={language}")
        else:
            # URL hat keine Parameter
            return redirect(f"{referrer}?lang={language}")
    return redirect(request.referrer or url_for('index'))

@app.route('/', methods=['GET', 'POST'])
def index():
    # Rudimentäres Logging für Page Impressions
    log_dir = 'log'
    os.makedirs(log_dir, exist_ok=True)
    log_path = os.path.join(log_dir, 'pageviews.log')
    # Logfile bereinigen: nur Zeilen der letzten 7 Tage behalten
    if os.path.exists(log_path):
        now = datetime.now()
        lines_new = []
        with open(log_path, encoding='utf-8') as f:
            for line in f:
                try:
                    date_str = line[:10]
                    date = datetime.strptime(date_str, '%Y-%m-%d')
                    if (now - date).days <= 7:
                        lines_new.append(line)
                except Exception:
                    # Zeile ohne Datum behalten (zur Sicherheit)
                    lines_new.append(line)
        with open(log_path, 'w', encoding='utf-8') as f:
            f.writelines(lines_new)
    with open(log_path, 'a', encoding='utf-8') as f:
        from datetime import datetime as dt
        f.write(f"{dt.now().isoformat()} PAGEVIEW\n")
    tage = wochentag = kw_berechnen = kw_datum = None
    feiertage_anzahl = wochenendtage_anzahl = None
    active_idx = 0
    plusminus_result = None
    if request.method == 'POST':
        action = request.form.get('action')
        # Funktions-Logging
        with open(log_path, 'a', encoding='utf-8') as f:
            from datetime import datetime as dt
            f.write(f"{dt.now().isoformat()} FUNC: {action}\n")
        if action == 'tage_werktage':
            active_idx = 0
            start = request.form.get('start1')
            end = request.form.get('end1')
            is_werktage = request.form.get('werktage') in ('on', 'true', '1', True)
            bundesland = request.form.get('bundesland')
            try:
                d1 = datetime.strptime(start, '%Y-%m-%d')
                d2 = datetime.strptime(end, '%Y-%m-%d')
                if d1 > d2:
                    d1, d2 = d2, d1
                # Feiertage bestimmen
                holidays = []
                if bundesland:
                    years = set([d1.year, d2.year])
                    for y in years:
                        holidays.extend(get_feiertage(y, bundesland))
                # Alle Tage im Bereich
                all_days = [(d1 + timedelta(days=i)).date() for i in range((d2 - d1).days + 1)]
                # Wochenendtage zählen
                wochenendtage_anzahl = sum(1 for d in all_days if d.weekday() >= 5)
                # Feiertage zählen (nur die, die im Bereich liegen und nicht auf Wochenende fallen)
                feiertage_im_zeitraum = [f for f in holidays if d1.date() <= datetime.strptime(f, '%Y-%m-%d').date() <= d2.date()]
                feiertage_anzahl = sum(1 for f in feiertage_im_zeitraum if datetime.strptime(f, '%Y-%m-%d').date().weekday() < 5)
                if is_werktage:
                    tage = np.busday_count(d1.date(), (d2 + timedelta(days=1)).date(), holidays=holidays)
                else:
                    tage = abs((d2 - d1).days)
            except Exception:
                tage = gettext('Ungültige Eingabe')
        elif action == 'wochentag':
            active_idx = 1
            datum = request.form.get('datum3')
            try:
                d = datetime.strptime(datum, '%Y-%m-%d')
                wochentage = get_wochentage()
                wochentag = wochentage[d.weekday()]
            except Exception:
                wochentag = gettext('Ungültige Eingabe')
        elif action == 'kw_berechnen':
            active_idx = 2
            datum = request.form.get('datum6')
            try:
                d = datetime.strptime(datum, '%Y-%m-%d')
                kw = d.isocalendar().week
                locale = get_locale()
                if locale == 'en':
                    kw_berechnen = f"Week {kw} ({d.year})"
                else:
                    kw_berechnen = f"KW {kw} ({d.year})"
            except Exception:
                kw_berechnen = gettext('Ungültige Eingabe')
        elif action == 'kw_datum':
            active_idx = 3
            jahr = request.form.get('jahr7')
            kw = request.form.get('kw7')
            try:
                jahr = int(jahr)
                kw = int(kw)
                # Montag der KW
                start = datetime.fromisocalendar(jahr, kw, 1)
                end = datetime.fromisocalendar(jahr, kw, 7)
                locale = get_locale()
                if locale == 'en':
                    kw_datum = f"{start.strftime('%m/%d/%Y')} to {end.strftime('%m/%d/%Y')}"
                else:
                    kw_datum = f"{start.strftime('%d.%m.%Y')} bis {end.strftime('%d.%m.%Y')}"
            except Exception:
                kw_datum = gettext('Ungültige Eingabe')
        elif action == 'plusminus':
            active_idx = 4
            datum = request.form.get('datum_pm')
            anzahl = request.form.get('anzahl_pm')
            einheit = request.form.get('einheit_pm')
            richtung = request.form.get('richtung_pm')
            is_werktage = request.form.get('werktage_pm') in ('on', 'true', '1', True)
            try:
                d = datetime.strptime(datum, '%Y-%m-%d')
                anzahl_int = int(anzahl)
                if richtung == 'sub':
                    anzahl_int = -anzahl_int
                locale = get_locale()
                if einheit == 'tage':
                    if is_werktage:
                        # Werktage: numpy busday_offset
                        result = np.busday_offset(d.date(), anzahl_int, roll='forward')
                        result_dt = datetime.strptime(str(result), '%Y-%m-%d')
                        if locale == 'en':
                            plusminus_result = f"Date {d.strftime('%m/%d/%Y')} {'plus' if anzahl_int>=0 else 'minus'} {abs(anzahl_int)} workdays: {result_dt.strftime('%m/%d/%Y')}"
                        else:
                            plusminus_result = f"Datum {d.strftime('%d.%m.%Y')} {'plus' if anzahl_int>=0 else 'minus'} {abs(anzahl_int)} Werktage: {result_dt.strftime('%d.%m.%Y')}"
                    else:
                        result = d + timedelta(days=anzahl_int)
                        if locale == 'en':
                            plusminus_result = f"Date {d.strftime('%m/%d/%Y')} {'plus' if anzahl_int>=0 else 'minus'} {abs(anzahl_int)} days: {result.strftime('%m/%d/%Y')}"
                        else:
                            plusminus_result = f"Datum {d.strftime('%d.%m.%Y')} {'plus' if anzahl_int>=0 else 'minus'} {abs(anzahl_int)} Tage: {result.strftime('%d.%m.%Y')}"
                elif einheit == 'wochen':
                    if is_werktage:
                        plusminus_result = gettext('Nicht unterstützt: Werktage + Wochen.')
                    else:
                        result = d + timedelta(weeks=anzahl_int)
                        if locale == 'en':
                            plusminus_result = f"Date {d.strftime('%m/%d/%Y')} {'plus' if anzahl_int>=0 else 'minus'} {abs(anzahl_int)} weeks: {result.strftime('%m/%d/%Y')}"
                        else:
                            plusminus_result = f"Datum {d.strftime('%d.%m.%Y')} {'plus' if anzahl_int>=0 else 'minus'} {abs(anzahl_int)} Wochen: {result.strftime('%d.%m.%Y')}"
                elif einheit == 'monate':
                    if is_werktage:
                        plusminus_result = gettext('Nicht unterstützt: Werktage + Monate.')
                    else:
                        result = d + relativedelta(months=anzahl_int)
                        if locale == 'en':
                            plusminus_result = f"Date {d.strftime('%m/%d/%Y')} {'plus' if anzahl_int>=0 else 'minus'} {abs(anzahl_int)} months: {result.strftime('%m/%d/%Y')}"
                        else:
                            plusminus_result = f"Datum {d.strftime('%d.%m.%Y')} {'plus' if anzahl_int>=0 else 'minus'} {abs(anzahl_int)} Monate: {result.strftime('%d.%m.%Y')}"
            except Exception:
                plusminus_result = gettext('Ungültige Eingabe')
    response = make_response(render_template('index.html', tage=tage, wochentag=wochentag, plusminus_result=plusminus_result, kw_berechnen=kw_berechnen, kw_datum=kw_datum, active_idx=active_idx
        , feiertage_anzahl=feiertage_anzahl, wochenendtage_anzahl=wochenendtage_anzahl, app_version=APP_VERSION, get_locale=get_locale
    ))
    return add_cache_headers(response)


def parse_log_stats(log_path):
    pageviews = 0
    func_counts = {}
    func_counts_hourly = {}
    impressions_per_day = {}
    impressions_per_hour = {}
    api_counts = {}
    api_counts_hourly = {}
    if os.path.exists(log_path):
        with open(log_path, encoding='utf-8') as f:
            for line in f:
                if 'PAGEVIEW' in line:
                    pageviews += 1
                    try:
                        # Parse timestamp (format: YYYY-MM-DDTHH:MM:SS)
                        timestamp = line[:19]  # First 19 chars for YYYY-MM-DDTHH:MM:SS
                        date = timestamp[:10]  # YYYY-MM-DD
                        hour = timestamp[11:13]  # HH
                        
                        if len(date) == 10 and date[4] == '-' and date[7] == '-':
                            impressions_per_day[date] = impressions_per_day.get(date, 0) + 1
                            
                        if len(hour) == 2 and hour.isdigit():
                            hour_key = f"{date} {hour}:00"
                            impressions_per_hour[hour_key] = impressions_per_hour.get(hour_key, 0) + 1
                    except Exception:
                        pass
                elif 'FUNC:' in line:
                    func = line.split('FUNC:')[1].strip()
                    func_counts[func] = func_counts.get(func, 0) + 1
                    
                    # Stündliche Funktionsaufrufe
                    try:
                        timestamp = line[:19]
                        date = timestamp[:10]
                        hour = timestamp[11:13]
                        if len(hour) == 2 and hour.isdigit():
                            hour_key = f"{date} {hour}:00"
                            if hour_key not in func_counts_hourly:
                                func_counts_hourly[hour_key] = {}
                            func_counts_hourly[hour_key][func] = func_counts_hourly[hour_key].get(func, 0) + 1
                    except Exception:
                        pass
                elif 'FUNC_API:' in line:
                    api = line.split('FUNC_API:')[1].strip()
                    api_counts[api] = api_counts.get(api, 0) + 1
                    
                    # Stündliche API-Aufrufe
                    try:
                        timestamp = line[:19]
                        date = timestamp[:10]
                        hour = timestamp[11:13]
                        if len(hour) == 2 and hour.isdigit():
                            hour_key = f"{date} {hour}:00"
                            if hour_key not in api_counts_hourly:
                                api_counts_hourly[hour_key] = {}
                            api_counts_hourly[hour_key][api] = api_counts_hourly[hour_key].get(api, 0) + 1
                    except Exception:
                        pass
    return pageviews, func_counts, func_counts_hourly, impressions_per_day, impressions_per_hour, api_counts, api_counts_hourly

@app.route('/stats', methods=['GET', 'POST'])
def stats():
    stats_password = os.environ.get('STATS_PASSWORD', 'changeme')
    if 'stats_auth' not in session:
        if request.method == 'POST':
            if request.form.get('password') == stats_password:
                session['stats_auth'] = True
                return redirect(url_for('stats'))
            else:
                        response = make_response(render_template('stats_login.html', error='Falsches Passwort!'))
        return add_cache_headers(response)
    response = make_response(render_template('stats_login.html', error=None))
    return add_cache_headers(response)
    log_path = os.path.join('log', 'pageviews.log')
    pageviews, func_counts, func_counts_hourly, impressions_per_day, impressions_per_hour, api_counts, api_counts_hourly = parse_log_stats(log_path)
    response = make_response(render_template('stats_dashboard.html', pageviews=pageviews, func_counts=func_counts, func_counts_hourly=func_counts_hourly, impressions_per_day=impressions_per_day, impressions_per_hour=impressions_per_hour, api_counts=api_counts, api_counts_hourly=api_counts_hourly))
    return add_cache_headers(response)

# --- REST API ---
def log_api_usage(api_name):
    log_dir = 'log'
    os.makedirs(log_dir, exist_ok=True)
    log_path = os.path.join(log_dir, 'pageviews.log')
    from datetime import datetime as dt
    with open(log_path, 'a', encoding='utf-8') as f:
        f.write(f"{dt.now().isoformat()} FUNC_API: {api_name}\n")

@app.route('/api/tage_werktage', methods=['POST'])
def api_tage_werktage():
    log_api_usage('tage_werktage')
    data = request.get_json()
    start = data.get('start')
    end = data.get('end')
    is_werktage = data.get('werktage', False)
    bundesland = data.get('bundesland')
    try:
        d1 = datetime.strptime(start, '%Y-%m-%d')
        d2 = datetime.strptime(end, '%Y-%m-%d')
        if is_werktage:
            if d1 > d2:
                d1, d2 = d2, d1
            holidays = []
            if bundesland:
                # Feiertage für alle Jahre im Bereich holen
                years = set([d1.year, d2.year])
                for y in years:
                    holidays.extend(get_feiertage(y, bundesland))
            tage = int(np.busday_count(d1.date(), (d2 + timedelta(days=1)).date(), holidays=holidays))
        else:
            tage = abs((d2 - d1).days)
        response = jsonify({'result': tage})
        return add_cache_headers(response)
    except Exception as e:
        return jsonify({'error': 'Ungültige Eingabe', 'details': str(e)}), 400

@app.route('/api/wochentag', methods=['POST'])
def api_wochentag():
    log_api_usage('wochentag')
    data = request.get_json()
    datum = data.get('datum')
    try:
        d = datetime.strptime(datum, '%Y-%m-%d')
        wochentage = get_wochentage()
        wochentag = wochentage[d.weekday()]
        response = jsonify({'result': wochentag})
        return add_cache_headers(response)
    except Exception as e:
        return jsonify({'error': 'Ungültige Eingabe', 'details': str(e)}), 400

@app.route('/api/kw_berechnen', methods=['POST'])
def api_kw_berechnen():
    log_api_usage('kw_berechnen')
    data = request.get_json()
    datum = data.get('datum')
    try:
        d = datetime.strptime(datum, '%Y-%m-%d')
        kw = d.isocalendar().week
        locale = get_locale()
        if locale == 'en':
            kw_berechnen = f"Week {kw} ({d.year})"
        else:
            kw_berechnen = f"KW {kw} ({d.year})"
        response = jsonify({'result': kw_berechnen, 'kw': kw, 'jahr': d.year})
        return add_cache_headers(response)
    except Exception as e:
        return jsonify({'error': 'Ungültige Eingabe', 'details': str(e)}), 400

@app.route('/api/kw_datum', methods=['POST'])
def api_kw_datum():
    log_api_usage('kw_datum')
    data = request.get_json()
    jahr = data.get('jahr')
    kw = data.get('kw')
    try:
        jahr = int(jahr)
        kw = int(kw)
        start = datetime.fromisocalendar(jahr, kw, 1)
        end = datetime.fromisocalendar(jahr, kw, 7)
        locale = get_locale()
        if locale == 'en':
            kw_datum = f"{start.strftime('%m/%d/%Y')} to {end.strftime('%m/%d/%Y')}"
        else:
            kw_datum = f"{start.strftime('%d.%m.%Y')} bis {end.strftime('%d.%m.%Y')}"
        response = jsonify({'result': kw_datum, 'start': start.strftime('%Y-%m-%d'), 'end': end.strftime('%Y-%m-%d')})
        return add_cache_headers(response)
    except Exception as e:
        return jsonify({'error': 'Ungültige Eingabe', 'details': str(e)}), 400

@app.route('/api/plusminus', methods=['POST'])
def api_plusminus():
    log_api_usage('plusminus')
    data = request.get_json()
    datum = data.get('datum')
    anzahl = data.get('anzahl')
    einheit = data.get('einheit')
    richtung = data.get('richtung', 'add')
    is_werktage = data.get('werktage', False)
    try:
        d = datetime.strptime(datum, '%Y-%m-%d')
        anzahl_int = int(anzahl)
        if richtung == 'sub':
            anzahl_int = -anzahl_int
        locale = get_locale()
        if einheit == 'tage':
            if is_werktage:
                result = np.busday_offset(d.date(), anzahl_int, roll='forward')
                result_dt = datetime.strptime(str(result), '%Y-%m-%d')
                response = jsonify({'result': result_dt.strftime('%Y-%m-%d')})
                return add_cache_headers(response)
            else:
                result = d + timedelta(days=anzahl_int)
                response = jsonify({'result': result.strftime('%Y-%m-%d')})
                return add_cache_headers(response)
        elif einheit == 'wochen':
            if is_werktage:
                return jsonify({'error': 'Nicht unterstützt: Werktage + Wochen.'}), 400
            else:
                result = d + timedelta(weeks=anzahl_int)
                response = jsonify({'result': result.strftime('%Y-%m-%d')})
                return add_cache_headers(response)
        elif einheit == 'monate':
            if is_werktage:
                return jsonify({'error': 'Nicht unterstützt: Werktage + Monate.'}), 400
            else:
                result = d + relativedelta(months=anzahl_int)
                response = jsonify({'result': result.strftime('%Y-%m-%d')})
                return add_cache_headers(response)
        else:
            return jsonify({'error': 'Ungültige Einheit'}), 400
    except Exception as e:
        return jsonify({'error': 'Ungültige Eingabe', 'details': str(e)}), 400

@app.route('/api/stats', methods=['GET'])
def api_stats():
    log_path = os.path.join('log', 'pageviews.log')
    pageviews, func_counts, func_counts_hourly, impressions_per_day, impressions_per_hour, api_counts, api_counts_hourly = parse_log_stats(log_path)
    response = jsonify({
        "pageviews": pageviews,
        "func_counts": func_counts,
        "impressions_per_day": impressions_per_day,
        "api_counts": api_counts
    })
    return add_cache_headers(response)

@app.route('/api/monitor', methods=['GET'])
def api_monitor():
    log_path = os.path.join('log', 'pageviews.log')
    pageviews = 0
    if os.path.exists(log_path):
        with open(log_path, encoding='utf-8') as f:
            for line in f:
                if 'PAGEVIEW' in line:
                    pageviews += 1
    uptime = int(time.time() - app_start_time)
    response = jsonify({
        "status": "ok",
        "message": "App running",
        "time": datetime.now().isoformat(),
        "uptime_seconds": uptime,
        "pageviews_last_7_days": pageviews
    })
    return add_cache_headers(response)

@app.route('/api-docs')
def api_docs():
    response = make_response(render_template('swagger.html'))
    return add_cache_headers(response)


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