CODE SOURCE

  1# ==============================================================================
  2#  SMARTLOCKER -- POINT D'ENTREE DE L'APPLICATION FLASK
  3# ------------------------------------------------------------------------------
  4#  Ce fichier est volontairement court : il se contente de
  5#    1) creer l'application Flask et configurer la session / les cookies ;
  6#    2) enregistrer les "blueprints" (un par domaine fonctionnel) ;
  7#    3) declarer les gestionnaires d'erreurs globaux.
  8#
  9#  Tout le code metier a ete decoupe dans des modules dedies pour faciliter la
 10#  lecture et la maintenance :
 11#
 12#    extensions.py     -> connexions partagees (Firebase, Stripe) + alias config
 13#    helpers.py        -> fonctions utilitaires + decorateurs require_login/admin
 14#    routes_main.py    -> PWA, dashboard, scan, settings, photo de profil
 15#    routes_auth.py    -> login, signup, logout, connexion Google
 16#    routes_pairing.py -> appairage / dissociation des casiers, toggle Premium
 17#    routes_sport.py   -> casier Sport (reserve Premium)
 18#    routes_school.py  -> casier Ecole (reservation payante Stripe + webhook)
 19#    routes_api.py     -> API JSON, notifications, historique + export CSV, FCM
 20#    routes_admin.py   -> console d'administration
 21#
 22#  IMPORTANT (PythonAnywhere) : le fichier WSGI importe `app` depuis ce
 23#  module (`from flask_app import app`). On garde donc bien la variable
 24#  `app` exposee ici -- ne pas la renommer.
 25# ==============================================================================
 26
 27import os
 28from datetime import timedelta
 29
 30from flask import Flask
 31
 32import config
 33
 34# Les blueprints (un module = un domaine fonctionnel)
 35from routes_main    import main_bp
 36from routes_auth    import auth_bp
 37from routes_pairing import pairing_bp
 38from routes_sport   import sport_bp
 39from routes_school  import school_bp
 40from routes_api     import api_bp
 41from routes_admin   import admin_bp
 42
 43
 44# ==============================================================================
 45#  CREATION & CONFIGURATION DE L'APPLICATION
 46# ==============================================================================
 47
 48app = Flask(__name__)
 49app.secret_key = config.SECRET_KEY
 50
 51# Securite cookies de session
 52# SESSION_COOKIE_SECURE=True en production HTTPS (PythonAnywhere)
 53# Desactive automatiquement en debug (localhost http) via FLASK_ENV
 54_is_prod = os.environ.get('FLASK_ENV', 'production') != 'development'
 55app.config.update(
 56    SESSION_COOKIE_HTTPONLY=True,
 57    SESSION_COOKIE_SAMESITE='Lax',
 58    SESSION_COOKIE_SECURE=_is_prod,
 59    PERMANENT_SESSION_LIFETIME=timedelta(days=7),
 60    MAX_CONTENT_LENGTH=8 * 1024 * 1024,  # 8MB max upload (photos profil)
 61)
 62
 63
 64# ==============================================================================
 65#  ENREGISTREMENT DES BLUEPRINTS
 66# ==============================================================================
 67
 68app.register_blueprint(main_bp)
 69app.register_blueprint(auth_bp)
 70app.register_blueprint(pairing_bp)
 71app.register_blueprint(sport_bp)
 72app.register_blueprint(school_bp)
 73app.register_blueprint(api_bp)
 74app.register_blueprint(admin_bp)
 75
 76
 77# ==============================================================================
 78#  GESTIONNAIRES D'ERREURS
 79# ==============================================================================
 80
 81@app.errorhandler(403)
 82def forbidden(e):
 83    return ("<h1>403 -- Acces refuse</h1>"
 84            "<p>Vous n'avez pas les permissions pour acceder a cette page.</p>"
 85            "<a href='/'>Retour a l'accueil</a>"), 403
 86
 87
 88@app.errorhandler(404)
 89def not_found(e):
 90    return ("<h1>404 -- Page introuvable</h1>"
 91            "<p>La page demandee n'existe pas.</p>"
 92            "<a href='/'>Retour a l'accueil</a>"), 404
 93
 94
 95@app.errorhandler(500)
 96def server_error(e):
 97    print("[500] {}".format(e))
 98    return ("<h1>500 -- Erreur serveur</h1>"
 99            "<p>Une erreur interne est survenue. Reessayez plus tard.</p>"
100            "<a href='/'>Retour a l'accueil</a>"), 500

 1# ══════════════════════════════════════════════════════════════════════════════
 2#  EXTENSIONS — Initialisation des services partagés (Firebase, Stripe)
 3# ──────────────────────────────────────────────────────────────────────────────
 4#  Ce module centralise la connexion aux services externes pour qu'ils soient
 5#  importés une seule fois et réutilisés partout (helpers + blueprints), sans
 6#  dépendance circulaire avec flask_app.py.
 7#
 8#  Usage dans les autres fichiers :
 9#      from extensions import db, auth, storage, admin_db, stripe
10#      from extensions import LOCKERS, LOCKER_CODES, SCHOOL_HOURS, PRICE_PER_HOUR
11# ══════════════════════════════════════════════════════════════════════════════
12
13import os
14import pyrebase
15import stripe
16
17import config
18
19
20# ── Stripe ────────────────────────────────────────────────────────────────────
21stripe.api_key = config.STRIPE_SECRET_KEY
22
23
24# ── Firebase ──────────────────────────────────────────────────────────────────
25firebase = pyrebase.initialize_app(config.FIREBASE_CONFIG)
26auth     = firebase.auth()
27db       = firebase.database()
28storage  = firebase.storage()
29
30
31# ── Firebase Admin SDK (optionnel, pour le webhook Stripe) ────────────────────
32# Si la clé service-account est présente, on l'utilise pour écrire dans
33# Firebase depuis le webhook Stripe (qui n'a pas de session utilisateur).
34# Sinon on retombe sur pyrebase (nécessite des règles permissives).
35admin_db = None
36try:
37    import firebase_admin
38    from firebase_admin import credentials as _fa_creds, db as _fa_db
39    _cred_path = os.path.join(os.path.dirname(__file__), 'cle-firebase.json')
40    if os.path.exists(_cred_path):
41        _cred = _fa_creds.Certificate(_cred_path)
42        if not firebase_admin._apps:
43            firebase_admin.initialize_app(_cred, {
44                'databaseURL': config.FIREBASE_CONFIG['databaseURL']
45            })
46        admin_db = _fa_db
47        print("[firebase-admin] OK — webhook Stripe utilisera firebase-admin")
48    else:
49        print("[firebase-admin] cle-firebase.json introuvable — webhook utilisera pyrebase")
50except ImportError:
51    print("[firebase-admin] module non installé — webhook utilisera pyrebase")
52
53
54# ── Alias de config pour éviter les longs config.xxx partout ──────────────────
55LOCKERS         = config.LOCKERS
56LOCKER_CODES    = config.LOCKER_CODES
57SCHOOL_HOURS    = config.SCHOOL_HOURS
58PRICE_PER_HOUR  = config.PRICE_PER_HOUR
59STRIPE_PUB_KEY  = config.STRIPE_PUBLISHABLE_KEY

  1# ══════════════════════════════════════════════════════════════════════════════
  2#  HELPERS — Fonctions utilitaires & décorateurs partagés
  3# ──────────────────────────────────────────────────────────────────────────────
  4#  Logique métier réutilisée par plusieurs routes : contexte utilisateur, état
  5#  des casiers (Firebase), journalisation, index des propriétaires, détection
  6#  en-ligne (heartbeat Pi) et décorateurs d'accès require_login / require_admin.
  7#  Aucune route Flask ici : seulement des fonctions importées par les blueprints.
  8# ══════════════════════════════════════════════════════════════════════════════
  9
 10import os
 11import time
 12import tempfile
 13from datetime import datetime
 14from functools import wraps
 15
 16from flask import session, redirect, url_for, abort
 17
 18import config
 19from extensions import db, auth, storage, LOCKERS
 20
 21OFFLINE_THRESHOLD_SEC = 90   # > 3 heartbeats manqués (1/30s) ⇒ casier hors-ligne
 22
 23
 24# ── Petits utilitaires partagés ───────────────────────────────────────────────
 25
 26def is_admin(email):
 27    """True si l'email fait partie des administrateurs (config.ADMIN_EMAILS)."""
 28    return (email or "").lower() in [e.lower() for e in config.ADMIN_EMAILS]
 29
 30
 31def lockdown_message():
 32    """Message utilisateur standard affiché quand un casier est en lockdown."""
 33    admin = config.ADMIN_EMAILS[0] if config.ADMIN_EMAILS else ""
 34    msg = "Intrusion detectee : un administrateur a ete alerte et intervient. Veuillez patienter."
 35    if admin:
 36        msg += " En cas d'urgence, contactez l'administrateur a l'adresse {}.".format(admin)
 37    return msg
 38
 39
 40def store_profile_image(data_bytes, local_id, token):
 41    """Écrit les octets image dans Storage (profile_images/{uid}.jpg) et retourne
 42    l'URL publique. Gère le fichier temporaire (création + nettoyage garanti)."""
 43    tmp_path = None
 44    try:
 45        with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as tmp:
 46            tmp.write(data_bytes)
 47            tmp_path = tmp.name
 48        path = "profile_images/{}.jpg".format(local_id)
 49        storage.child(path).put(tmp_path)
 50        return storage.child(path).get_url(token)
 51    finally:
 52        if tmp_path and os.path.exists(tmp_path):
 53            try:
 54                os.remove(tmp_path)
 55            except Exception:
 56                pass
 57
 58
 59def _normalize_paired(user_data):
 60    """Lit la clé 'paired' (fallback legacy 'paired_lockers') ⇒ toujours un dict."""
 61    paired = user_data.get("paired", user_data.get("paired_lockers", {}))
 62    if isinstance(paired, bool):                       # très ancien format booléen
 63        return {"sport": True, "school": True} if paired else {}
 64    return paired if isinstance(paired, dict) else {}
 65
 66
 67def _is_online(data, now=None):
 68    """(online: bool, secondes_depuis_dernier_heartbeat | None) d'après le Pi casier."""
 69    now = now or time.time()
 70    last_raw   = data.get("last_heartbeat", data.get("casier_derniere_activite", ""))
 71    status_raw = (data.get("online_status", data.get("casier_statut", "")) or "").lower()
 72    if not last_raw:
 73        return False, None
 74    try:
 75        seconds = int(now - datetime.fromisoformat(last_raw).timestamp())
 76    except Exception:
 77        return False, None
 78    online = seconds <= OFFLINE_THRESHOLD_SEC and status_raw not in ("offline", "hors_ligne")
 79    return online, seconds
 80
 81
 82# ══════════════════════════════════════════════════════════════════════════════
 83#  CONTEXTE UTILISATEUR & ÉTAT DES CASIERS
 84# ══════════════════════════════════════════════════════════════════════════════
 85
 86def get_user_context(token):
 87    """Récupère les infos de l'utilisateur et enrichit la session."""
 88    user_info = auth.get_account_info(token)['users'][0]
 89    local_id  = user_info['localId']
 90    providers = [p['providerId'] for p in user_info.get('providerUserInfo', [])]
 91    user_data = db.child("users").child(local_id).get(token).val() or {}
 92    photo_url = session.get('photo') or \
 93        "https://ui-avatars.com/api/?name={}&background=00ff9d&color=000".format(
 94            session.get('pseudo', 'U'))
 95    return {
 96        'local_id':    local_id,
 97        'user_info':   user_info,
 98        'user_data':   user_data,
 99        'is_google':   'google.com' in providers,
100        'photo_url':   photo_url,
101        'is_verified': user_info.get('emailVerified', False),
102        'is_premium':  user_data.get('premium', False),
103        'email':       user_info.get('email', session.get('email', '')),
104        'paired':      _normalize_paired(user_data),
105    }
106
107
108def get_locker_state(locker_key, token, current_user_id=None):
109    """
110    Retourne l'état du casier en gérant automatiquement :
111    - expiration d'une session (unlocked → locked)
112    - ouverture automatique à l'heure prévue (reserved → unlocked)
113    """
114    lid          = LOCKERS[locker_key]["id"]
115    data         = db.child("lockers").child(lid).get(token).val() or {}
116    status       = data.get("status", "locked")
117    session_data = data.get("active_session") or {}
118    if isinstance(session_data, str):
119        session_data = {}
120    now = time.time()
121
122    def _expire():
123        """Ferme la session expirée, l'archive dans l'historique et libère le casier."""
124        db.child("lockers").child(lid).update({"status": "locked", "active_session": None}, token)
125        _log_session(locker_key, lid, session_data, token, "expired")
126        _unpair_after_session(locker_key, token, session_data.get("user_id"))
127        return {"status": "locked", "session": {}}
128
129    # 1) Unlocked mais session expirée → fermer + libérer le casier du compte
130    if session_data and status == "unlocked":
131        expires_at = session_data.get("expires_at", 0)
132        if expires_at and now > expires_at:
133            return _expire()
134
135    # 2) Reserved et l'heure est arrivée → passer à unlocked (ou expirer si dépassé)
136    if session_data and status == "reserved":
137        started_at = session_data.get("started_at", 0)
138        expires_at = session_data.get("expires_at", 0)
139        if started_at and now >= started_at and now < expires_at:
140            db.child("lockers").child(lid).update({"status": "unlocked"}, token)
141            status = "unlocked"
142        elif expires_at and now >= expires_at:            # réservation passée sans ouverture
143            return _expire()
144
145    # 3) Lockdown (intrusion : un admin doit intervenir)
146    lockdown_until     = data.get("lockdown_until", 0)
147    lockdown_active    = lockdown_until > now
148    lockdown_remaining = max(0, int(lockdown_until - now)) if lockdown_active else 0
149
150    # 4) En-ligne / hors-ligne (Pi du casier allumé ?)
151    online, seconds_since_seen = _is_online(data, now)
152
153    return {
154        "status": status,
155        "session": session_data,
156        "physical_state": data.get("door_physical", data.get("etat_porte_physique", "Inconnue")),
157        "alert":      data.get("alert_active", data.get("alerte_active", "")),
158        "alert_time": data.get("alert_time", data.get("heure_alerte", "")),
159        "lockdown": lockdown_active,
160        "lockdown_remaining": lockdown_remaining,
161        "lockdown_reason": data.get("lockdown_reason", "") if lockdown_active else "",
162        "online": online,
163        "last_seen_sec": seconds_since_seen,
164        "last_seen_raw": data.get("last_heartbeat", data.get("casier_derniere_activite", "")),
165        "reminder":      data.get("reminder_active", ""),       # porte ouverte trop longtemps
166        "reminder_time": data.get("reminder_time", ""),
167        "object_alert":      data.get("object_alert_active", ""),   # objet retiré (info)
168        "object_alert_time": data.get("object_alert_time", ""),
169    }
170
171
172def _log_session(locker_key, lid, sess, token, reason="closed"):
173    """Écrit une entrée dans l'historique utilisateur (users/{uid}/history/)."""
174    uid = (sess or {}).get("user_id")
175    if not uid:
176        return
177    start = sess.get("started_at", 0)
178    end   = time.time()
179    try:
180        db.child("users").child(uid).child("history").push({
181            "locker_key":   locker_key,
182            "locker_id":    lid,
183            "started_at":   start,
184            "ended_at":     end,
185            "duration_min": round((end - start) / 60),
186            "amount_eur":   sess.get("amount_eur", 0),
187            "reason":       reason,
188        }, token)
189    except Exception as e:
190        print("[_log_session] {}".format(e))
191
192
193def _unpair_after_session(locker_key, token, user_id):
194    """
195    Retire un casier du compte de l'utilisateur à la fin d'une session : supprime
196    locker_key de users/{uid}/paired ET vide l'index propriétaire, libérant le
197    casier pour le prochain utilisateur. Idempotent et tolérant aux erreurs.
198    """
199    if not user_id:
200        return
201    try:
202        user_data = db.child("users").child(user_id).get(token).val() or {}
203        paired = _normalize_paired(user_data if isinstance(user_data, dict) else {})
204        if locker_key in paired:
205            del paired[locker_key]
206            db.child("users").child(user_id).update({"paired": paired}, token)
207        clear_locker_owner(locker_key, token)        # no-op si déjà vide
208    except Exception as e:
209        print("[_unpair_after_session] {}".format(e))
210
211
212def get_user_stats(local_id, token):
213    """Calcule les stats d'usage depuis l'historique utilisateur."""
214    try:
215        raw = db.child("users").child(local_id).child("history").get(token).val() or {}
216        if not isinstance(raw, dict):
217            raw = {}
218        now             = time.time()
219        month_start     = now - 30 * 86400
220        day_start_today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0).timestamp()
221        sessions_month = total_minutes = 0
222        total_spent    = 0.0
223        days_7         = [0] * 7   # index 0 = aujourd'hui … 6 = il y a 6 jours
224
225        for v in raw.values():
226            if not isinstance(v, dict):
227                continue
228            started  = v.get('started_at', 0) or 0
229            duration = v.get('duration_min', 0) or 0
230            if started >= month_start:
231                sessions_month += 1
232                total_minutes  += duration
233                try:
234                    total_spent += float(v.get('amount_eur', 0) or 0)
235                except (TypeError, ValueError):
236                    pass
237            if started > 0:
238                diff_days = int((day_start_today - started) / 86400)
239                if 0 <= diff_days < 7:
240                    days_7[diff_days] += duration
241
242        return {
243            'sessions_month': sessions_month,
244            'total_minutes':  total_minutes,
245            'total_spent':    round(total_spent, 2),
246            'usage_7days':    list(reversed(days_7)),   # plus ancien → plus récent
247        }
248    except Exception as e:
249        print("[get_user_stats] {}".format(e))
250        return {'sessions_month': 0, 'total_minutes': 0, 'total_spent': 0.0, 'usage_7days': [0]*7}
251
252
253def _get_booked_slots(token, for_user_id=None):
254    """Retourne la liste des créneaux occupés (format YYYY-MM-DD-HH:00)."""
255    try:
256        lid  = LOCKERS["school"]["id"]
257        data = db.child("lockers").child(lid).get(token).val() or {}
258        sess = data.get("active_session") or {}
259        if isinstance(sess, str):
260            sess = {}
261        if not (sess and sess.get("expires_at", 0) > time.time()):
262            return []
263        booked = []
264        cur, end = sess.get("started_at", 0), sess.get("expires_at", 0)
265        while cur < end:
266            dt = datetime.fromtimestamp(cur)
267            booked.append("{}-{:02d}:00".format(dt.strftime("%Y-%m-%d"), dt.hour))
268            cur += 3600
269        return booked
270    except Exception as e:
271        print("[_get_booked_slots] {}".format(e))
272        return []
273
274
275def _maybe_refresh_token():
276    """Rafraîchit le token Firebase (durée 1h) toutes les 50 min s'il y a un refresh_token."""
277    refresh_tok = session.get('refresh_token')
278    if not refresh_tok or time.time() - session.get('token_refreshed_at', 0) < 50 * 60:
279        return
280    try:
281        new_data = auth.refresh(refresh_tok)
282        session['user']               = new_data['idToken']
283        session['refresh_token']      = new_data['refreshToken']
284        session['token_refreshed_at'] = time.time()
285    except Exception as e:
286        # Si le refresh échoue, on laisse la requête suivre son cours (l'utilisateur
287        # sera redirigé naturellement si le token est invalide).
288        print("[token_refresh] {}".format(e))
289
290
291# ══════════════════════════════════════════════════════════════════════════════
292#  INDEX CASIERS — /lockers_index/{key} = uid du propriétaire (lecture O(1))
293# ══════════════════════════════════════════════════════════════════════════════
294
295def get_locker_owner_uid(locker_key, token):
296    """Retourne l'uid du propriétaire d'un casier (ou None)."""
297    try:
298        return db.child("lockers_index").child(locker_key).get(token).val() or None
299    except Exception:
300        return None
301
302
303def set_locker_owner_uid(locker_key, uid, token):
304    """Définit le propriétaire d'un casier dans l'index."""
305    try:
306        db.child("lockers_index").child(locker_key).set(uid, token)
307    except Exception as e:
308        print("[set_locker_owner_uid] {}".format(e))
309
310
311def clear_locker_owner(locker_key, token):
312    """Supprime l'entrée de l'index quand un casier est dissocié."""
313    try:
314        db.child("lockers_index").child(locker_key).remove(token)
315    except Exception as e:
316        print("[clear_locker_owner] {}".format(e))
317
318
319def _auto_start_sport_session(token, local_id, user_email):
320    """
321    Démarre une session sport après appairage : le casier passe en 'unlocked'
322    (session active) mais la porte ne s'ouvre PAS physiquement — pas de
323    cmd_open_door ici. L'ouverture reste déclenchée par le bouton OUVRIR LA PORTE.
324    Aucune action si le casier est déjà en session.
325    """
326    try:
327        lid     = LOCKERS["sport"]["id"]
328        current = db.child("lockers").child(lid).get(token).val() or {}
329        if current.get("status") in ("unlocked", "reserved"):
330            return
331        db.child("lockers").child(lid).update({
332            "status": "unlocked",
333            "active_session": {
334                "user_id":    local_id,
335                "user_email": user_email,
336                "started_at": time.time(),
337                "expires_at": 0,
338                "amount_eur": 0,
339            },
340        }, token)
341    except Exception as e:
342        print("[_auto_start_sport_session] {}".format(e))
343
344
345def _is_locker_online(locker_key, token):
346    """True si le Pi du casier a envoyé un heartbeat il y a moins de 90 s."""
347    try:
348        data = db.child("lockers").child(LOCKERS[locker_key]["id"]).get(token).val() or {}
349        return _is_online(data)[0] if isinstance(data, dict) else False
350    except Exception:
351        return False
352
353
354# ══════════════════════════════════════════════════════════════════════════════
355#  DÉCORATEURS D'ACCÈS
356# ══════════════════════════════════════════════════════════════════════════════
357
358def require_login(f):
359    @wraps(f)
360    def decorated(*args, **kwargs):
361        if 'user' not in session:
362            return redirect(url_for('main.home'))
363        _maybe_refresh_token()
364        return f(*args, **kwargs)
365    return decorated
366
367
368def require_admin(f):
369    @wraps(f)
370    def decorated(*args, **kwargs):
371        if 'user' not in session:
372            return redirect(url_for('main.home'))
373        if not is_admin(session.get('email')):
374            abort(403)
375        return f(*args, **kwargs)
376    return decorated

  1# ══════════════════════════════════════════════════════════════════════════════
  2#  ROUTES — PRINCIPALES (PWA, Dashboard, Scan, Settings, Profil)
  3# ──────────────────────────────────────────────────────────────────────────────
  4#  Regroupe :
  5#    • Les fichiers de la PWA (service-worker.js, manifest.json, FCM SW)
  6#    • Le tableau de bord (page d'accueil)
  7#    • Le scanner de QR code
  8#    • Les paramètres du compte + mise à jour de la photo de profil
  9# ══════════════════════════════════════════════════════════════════════════════
 10
 11import base64
 12
 13from flask import (
 14    Blueprint, render_template, request, redirect, session, url_for,
 15    flash, send_from_directory
 16)
 17
 18from extensions import db, auth, LOCKERS
 19from helpers import (
 20    get_user_context, get_locker_state, get_user_stats,
 21    _maybe_refresh_token, require_login, is_admin, store_profile_image,
 22)
 23
 24main_bp = Blueprint('main', __name__)
 25
 26
 27# ══════════════════════════════════════════════════════════════════════════════
 28#  ROUTES STATIQUES (PWA)
 29# ══════════════════════════════════════════════════════════════════════════════
 30
 31@main_bp.route('/service-worker.js')
 32def service_worker():
 33    r = send_from_directory('static', 'service-worker.js')
 34    r.headers['Content-Type']           = 'application/javascript'
 35    r.headers['Service-Worker-Allowed'] = '/'
 36    r.headers['Cache-Control']          = 'no-cache'
 37    return r
 38
 39
 40@main_bp.route('/manifest.json')
 41def manifest():
 42    return send_from_directory('static', 'manifest.json')
 43
 44
 45@main_bp.route('/firebase-messaging-sw.js')
 46def firebase_service_worker():
 47    return send_from_directory('static', 'firebase-messaging-sw.js', mimetype='application/javascript')
 48
 49
 50# Cache-Control agressif sur les icones (enregistré au niveau de l'app entière)
 51@main_bp.after_app_request
 52def add_cache_headers(response):
 53    if request.path.startswith('/static/icons/'):
 54        response.headers['Cache-Control'] = 'public, max-age=31536000, immutable'
 55    return response
 56
 57
 58# ══════════════════════════════════════════════════════════════════════════════
 59#  DASHBOARD
 60# ══════════════════════════════════════════════════════════════════════════════
 61
 62@main_bp.route('/')
 63def home():
 64    if 'user' not in session:
 65        return render_template('index.html', logged_in=False)
 66    try:
 67        # Refresh token si proche de l'expiration
 68        _maybe_refresh_token()
 69
 70        # Si un code d'appairage est en attente (depuis un scan QR avant login)
 71        if session.get('pending_pair_code'):
 72            return redirect(url_for('pairing.pair_locker_from_qr'))
 73
 74        token        = session['user']
 75        ctx          = get_user_context(token)
 76
 77        # ── Redirection admin direct ──────────────────────────────
 78        if is_admin(session.get('email')):
 79            return redirect(url_for('admin.admin_panel'))
 80
 81        sport_state  = get_locker_state("sport",  token, ctx['local_id'])
 82        school_state = get_locker_state("school", token, ctx['local_id'])
 83        stats        = get_user_stats(ctx['local_id'], token)
 84        return render_template('index.html',
 85                               logged_in=True,
 86                               email=session.get('email'),
 87                               pseudo=session.get('pseudo'),
 88                               photo=ctx['photo_url'],
 89                               is_verified=ctx['is_verified'],
 90                               is_premium=ctx['is_premium'],
 91                               is_admin=False,
 92                               paired_lockers=ctx['paired'],
 93                               sport_state=sport_state,
 94                               school_state=school_state,
 95                               lockers=LOCKERS,
 96                               stats=stats)
 97    except Exception as e:
 98        print("[home] {}".format(e))
 99        session.clear()
100        return redirect(url_for('main.home'))
101
102
103# ══════════════════════════════════════════════════════════════════════════════
104#  SCANNER QR
105# ══════════════════════════════════════════════════════════════════════════════
106
107@main_bp.route('/scan')
108@require_login
109def scan_page():
110    return render_template('scan.html')
111
112
113# ══════════════════════════════════════════════════════════════════════════════
114#  SETTINGS
115# ══════════════════════════════════════════════════════════════════════════════
116
117@main_bp.route('/settings')
118@require_login
119def settings():
120    try:
121        token    = session['user']
122        ctx      = get_user_context(token)
123        return render_template('settings.html',
124                               email=session.get('email'),
125                               pseudo=session.get('pseudo'),
126                               photo=ctx['photo_url'],
127                               is_google=ctx['is_google'],
128                               is_verified=ctx['is_verified'],
129                               is_premium=ctx['is_premium'],
130                               is_admin=is_admin(ctx['email']),
131                               paired_lockers=ctx['paired'],
132                               lockers=LOCKERS)
133    except Exception as e:
134        print("[settings] {}".format(e))
135        session.clear()
136        return redirect(url_for('main.home'))
137
138
139@main_bp.route('/update_settings', methods=['POST'])
140@require_login
141def update_settings():
142    token      = session['user']
143    new_pseudo = (request.form.get('new_pseudo', '') or '').strip()
144    new_email  = (request.form.get('new_email', '') or '').strip().lower()
145    new_pass   = (request.form.get('new_password', '') or '').strip()
146    try:
147        ctx      = get_user_context(token)
148        local_id = ctx['local_id']
149        if new_pseudo:
150            if len(new_pseudo) < 2 or len(new_pseudo) > 30:
151                flash("Pseudo invalide (2 à 30 caractères).")
152                return redirect(url_for('main.settings'))
153            db.child("users").child(local_id).update({"pseudo": new_pseudo}, token)
154            session['pseudo'] = new_pseudo
155        if not ctx['is_google'] and new_email and new_email != session.get('email'):
156            if '@' not in new_email or '.' not in new_email.split('@')[-1]:
157                flash("Email invalide.")
158                return redirect(url_for('main.settings'))
159            auth.update_email(token, new_email)
160            auth.send_email_verification(token)
161            session['email'] = new_email
162        if new_pass:
163            if len(new_pass) < 6:
164                flash("Le nouveau mot de passe doit contenir au moins 6 caractères.")
165                return redirect(url_for('main.settings'))
166            auth.change_password(token, new_pass)
167        flash("Profil mis a jour !")
168    except Exception as e:
169        print("[update_settings] {}".format(e))
170        flash("Erreur lors de la mise a jour.")
171    return redirect(url_for('main.settings'))
172
173
174@main_bp.route('/update_photo', methods=['POST'])
175@require_login
176def update_photo():
177    token     = session['user']
178    photo_b64 = request.form.get('photo_b64')
179    if not photo_b64:
180        return redirect(url_for('main.settings'))
181    try:
182        # Validation du format data-URL
183        if ',' not in photo_b64 or not photo_b64.startswith('data:image/'):
184            flash("Format d'image invalide.")
185            return redirect(url_for('main.settings'))
186        try:
187            data = base64.b64decode(photo_b64.split(",", 1)[1])
188        except Exception:
189            flash("Image corrompue.")
190            return redirect(url_for('main.settings'))
191        # Limite taille (env. 8 Mo de base64 décodé)
192        if len(data) > 8 * 1024 * 1024:
193            flash("Image trop lourde (max 8 Mo).")
194            return redirect(url_for('main.settings'))
195        local_id  = auth.get_account_info(token)['users'][0]['localId']
196        photo_url = store_profile_image(data, local_id, token)
197        db.child("users").child(local_id).update({"photoURL": photo_url}, token)
198        session['photo'] = photo_url
199        flash("Photo mise a jour !")
200    except Exception as e:
201        print("[update_photo] {}".format(e))
202        flash("Erreur lors de l'upload.")
203    return redirect(url_for('main.settings'))

  1# ══════════════════════════════════════════════════════════════════════════════
  2#  ROUTES — AUTHENTIFICATION
  3# ──────────────────────────────────────────────────────────────────────────────
  4#  Connexion email/mot de passe, inscription, déconnexion et connexion Google.
  5#  Toutes ces routes ouvrent / ferment la session Flask et n'exigent PAS d'être
  6#  déjà connecté (sauf logout qui se contente de vider la session).
  7# ══════════════════════════════════════════════════════════════════════════════
  8
  9import time
 10import base64
 11
 12from flask import Blueprint, request, redirect, session, url_for, flash
 13
 14from extensions import db, auth
 15from helpers import store_profile_image
 16
 17auth_bp = Blueprint('auth', __name__)
 18
 19
 20@auth_bp.route('/login', methods=['POST'])
 21def login():
 22    email    = (request.form.get('email') or '').strip().lower()
 23    password = request.form.get('password') or ''
 24    if not email or not password:
 25        flash("Email et mot de passe requis.")
 26        return redirect(url_for('main.home'))
 27    try:
 28        user              = auth.sign_in_with_email_and_password(email, password)
 29        token             = user['idToken']
 30        session.permanent = True
 31        session['user']                = token
 32        session['refresh_token']       = user.get('refreshToken', '')
 33        session['token_refreshed_at']  = time.time()
 34        session['email']               = email
 35        user_db           = db.child("users").child(user['localId']).get(token).val() or {}
 36        session['pseudo'] = user_db.get('pseudo', user_db.get('username', email.split('@')[0]))
 37        session['photo']  = user_db.get('photoURL', '')
 38        return redirect(url_for('main.home'))
 39    except Exception as e:
 40        print("[login] {}".format(e))
 41        flash("Identifiants incorrects.")
 42        return redirect(url_for('main.home'))
 43
 44
 45@auth_bp.route('/signup', methods=['POST'])
 46def signup():
 47    email     = (request.form.get('email') or '').strip().lower()
 48    password  = request.form.get('password') or ''
 49    pseudo    = (request.form.get('pseudo') or '').strip()
 50    photo_b64 = request.form.get('photo_b64', '')
 51    # Validation côté serveur
 52    if not email or '@' not in email or '.' not in email.split('@')[-1]:
 53        flash("Adresse email invalide.")
 54        return redirect(url_for('main.home'))
 55    if len(password) < 6:
 56        flash("Le mot de passe doit contenir au moins 6 caractères.")
 57        return redirect(url_for('main.home'))
 58    if not pseudo or len(pseudo) < 2 or len(pseudo) > 30:
 59        flash("Pseudo invalide (2 à 30 caractères).")
 60        return redirect(url_for('main.home'))
 61    try:
 62        user     = auth.create_user_with_email_and_password(email, password)
 63        token    = user['idToken']
 64        local_id = user['localId']
 65        auth.send_email_verification(token)
 66        photo_url = ''
 67        if photo_b64:
 68            try:
 69                data = base64.b64decode(photo_b64.split(",", 1)[1])
 70                photo_url = store_profile_image(data, local_id, token)
 71            except Exception as e:
 72                print("[signup photo] {}".format(e))
 73                photo_url = ''
 74        db.child("users").child(local_id).set({
 75            "pseudo":     pseudo,
 76            "email":      email,
 77            "photoURL":   photo_url,
 78            "premium":    False,
 79            "paired":     {},
 80            "created_at": time.time(),
 81        }, token)
 82        session.permanent              = True
 83        session['user']                = token
 84        session['refresh_token']       = user.get('refreshToken', '')
 85        session['token_refreshed_at']  = time.time()
 86        session['email']               = email
 87        session['pseudo']              = pseudo
 88        session['photo']               = photo_url
 89        flash("Compte cree ! Verifiez vos emails.")
 90        return redirect(url_for('main.home'))
 91    except Exception as e:
 92        print("[signup] {}".format(e))
 93        flash("Erreur d'inscription.")
 94        return redirect(url_for('main.home'))
 95
 96
 97@auth_bp.route('/logout')
 98def logout():
 99    """Deconnecte l'utilisateur en vidant la session Flask."""
100    session.clear()
101    flash("Vous avez ete deconnecte.")
102    return redirect(url_for('main.home'))
103
104
105@auth_bp.route('/google_login', methods=['POST'])
106def google_login():
107    """Connexion via Google : recoit l'idToken Firebase issu du popup Google
108    cote client (Firebase Auth) et ouvre la session Flask."""
109    id_token = (request.form.get('idToken') or '').strip()
110    email    = (request.form.get('email') or '').strip().lower()
111    name     = (request.form.get('name') or '').strip()
112    photo    = (request.form.get('photo') or '').strip()
113    if not id_token or not email:
114        flash("Connexion Google echouee : informations manquantes.")
115        return redirect(url_for('main.home'))
116    try:
117        # On recupere les infos du compte via le token recu du client
118        info = auth.get_account_info(id_token)['users'][0]
119        local_id = info['localId']
120
121        # Cree ou met a jour le profil dans la DB
122        existing = db.child("users").child(local_id).get(id_token).val() or {}
123        user_data = {
124            "email":    email,
125            "pseudo":   existing.get('pseudo', name or email.split('@')[0]),
126            "photoURL": existing.get('photoURL', photo),
127            "premium":  existing.get('premium', False),
128            "paired":   existing.get('paired', existing.get('paired_lockers', {})),
129        }
130        if 'created_at' not in existing:
131            user_data['created_at'] = time.time()
132        db.child("users").child(local_id).update(user_data, id_token)
133
134        # Ouvre la session
135        session.permanent              = True
136        session['user']                = id_token
137        session['refresh_token']       = ''
138        session['token_refreshed_at']  = time.time()
139        session['email']               = email
140        session['pseudo']              = user_data['pseudo']
141        session['photo']               = user_data['photoURL']
142    except Exception as e:
143        print("[google_login] {}".format(e))
144        flash("Erreur de connexion Google.")
145    return redirect(url_for('main.home'))

  1# ══════════════════════════════════════════════════════════════════════════════
  2#  ROUTES — APPAIRAGE / DISSOCIATION DES CASIERS
  3# ──────────────────────────────────────────────────────────────────────────────
  4#  Appairage d'un casier à un compte (via QR scanné nativement ou code saisi),
  5#  dissociation, et le bouton de démonstration Premium pour le jury du TFE.
  6#
  7#  Règle métier : 1 seul casier appairé par utilisateur. L'appairage vérifie que
  8#  le casier n'est pas déjà pris (index O(1)) et qu'il est en ligne.
  9# ══════════════════════════════════════════════════════════════════════════════
 10
 11from flask import Blueprint, request, redirect, session, url_for, flash
 12
 13from extensions import db, LOCKERS, LOCKER_CODES
 14from helpers import (
 15    get_user_context, require_login,
 16    get_locker_owner_uid, set_locker_owner_uid, clear_locker_owner,
 17    _auto_start_sport_session, _is_locker_online,
 18)
 19
 20pairing_bp = Blueprint('pairing', __name__)
 21
 22
 23def _attempt_pair(token, code):
 24    """
 25    Tente d'appairer le casier identifié par `code` au compte courant et retourne
 26    le message flash à afficher. Centralise toute la logique partagée entre
 27    l'appairage par QR natif et par code saisi (1 seul casier/utilisateur, casier
 28    non déjà pris, casier en ligne).
 29    """
 30    ctx        = get_user_context(token)
 31    local_id   = ctx['local_id']
 32    locker_key = LOCKER_CODES.get(code)
 33    paired     = ctx['paired']
 34
 35    if not locker_key:
 36        return "Code invalide. Verifiez le code inscrit sur votre casier."
 37    if locker_key in paired:
 38        return "Ce casier est deja appaire a votre compte."
 39    if paired:
 40        return "Vous avez deja un casier appaire. Un seul casier par utilisateur est autorise."
 41
 42    # Casier déjà pris par un autre utilisateur (O(1) via index)
 43    owner_uid = get_locker_owner_uid(locker_key, token)
 44    if owner_uid and owner_uid != local_id:
 45        owner_data  = db.child("users").child(owner_uid).get(token).val() or {}
 46        owner_email = owner_data.get('email', 'un autre utilisateur')
 47        return "Ce casier est deja utilise par le compte {}.".format(owner_email)
 48
 49    # Casier en ligne (Raspberry Pi allumé) ?
 50    if not _is_locker_online(locker_key, token):
 51        return ("Casier hors-ligne : impossible d'appairer un casier eteint ou deconnecte. "
 52                "Verifiez qu'il soit allume puis reessayez.")
 53
 54    paired[locker_key] = True
 55    db.child("users").child(local_id).update({"paired": paired}, token)
 56    set_locker_owner_uid(locker_key, local_id, token)
 57    # Démarrage auto de la session sport si premium
 58    if locker_key == "sport" and ctx['is_premium']:
 59        _auto_start_sport_session(token, local_id, ctx['email'])
 60    return "Casier appaire avec succes !"
 61
 62
 63@pairing_bp.route('/pair')
 64def pair_redirect():
 65    """Redirige depuis un QR code scanné avec la caméra native du téléphone."""
 66    code = (request.args.get('code', '') or '').strip().upper()
 67    if not code:
 68        flash("Code de casier manquant.")
 69        return redirect(url_for('main.home'))
 70    # Mémoriser le code — sera traité après login si nécessaire
 71    session['pending_pair_code'] = code
 72    if 'user' not in session:
 73        flash("Connectez-vous d'abord pour appairer ce casier.")
 74        return redirect(url_for('main.home'))
 75    return redirect(url_for('pairing.pair_locker_from_qr'))
 76
 77
 78@pairing_bp.route('/pair_qr')
 79@require_login
 80def pair_locker_from_qr():
 81    """Traite l'appairage depuis un QR code scanné nativement."""
 82    code = session.pop('pending_pair_code', '')
 83    if not code:
 84        return redirect(url_for('main.home'))
 85    try:
 86        flash(_attempt_pair(session['user'], code))
 87    except Exception as e:
 88        print("[pair_locker_from_qr] {}".format(e))
 89        flash("Erreur lors de l'appairage.")
 90    return redirect(url_for('main.home'))
 91
 92
 93@pairing_bp.route('/pair_locker', methods=['POST'])
 94@require_login
 95def pair_locker():
 96    """Traite l'appairage depuis le code saisi manuellement (formulaire)."""
 97    code = request.form.get('locker_code', '').strip().upper()
 98    try:
 99        flash(_attempt_pair(session['user'], code))
100    except Exception as e:
101        print("[pair_locker] {}".format(e))
102        flash("Erreur lors de l'appairage.")
103    return redirect(url_for('main.home'))
104
105
106@pairing_bp.route('/unpair_locker', methods=['POST'])
107@require_login
108def unpair_locker():
109    token = session['user']
110    try:
111        ctx        = get_user_context(token)
112        local_id   = ctx['local_id']
113        locker_key = request.form.get('locker_key', '')
114        if locker_key not in LOCKERS:
115            flash("Casier inconnu.")
116            return redirect(url_for('main.settings'))
117
118        # Impossible de dissocier si une session est active
119        locker_id = LOCKERS[locker_key]['id']
120        lstatus   = db.child("lockers").child(locker_id).child("status").get(token).val()
121        if lstatus and lstatus != 'locked':
122            flash("Impossible de dissocier : le casier est actuellement utilise ou reserve. Veuillez terminer la session d'abord.")
123            return redirect(url_for('main.settings'))
124
125        paired = ctx['paired']
126        paired.pop(locker_key, None)
127        db.child("users").child(local_id).update({"paired": paired}, token)
128        clear_locker_owner(locker_key, token)
129        flash("Casier '{}' dissocie.".format(LOCKERS[locker_key]['name']))
130    except Exception as e:
131        print("[unpair_locker] {}".format(e))
132        flash("Erreur lors de la dissociation.")
133    return redirect(url_for('main.settings'))
134
135
136# ══════════════════════════════════════════════════════════════════════════════
137#  PREMIUM TOGGLE (pour la démo TFE)
138# ══════════════════════════════════════════════════════════════════════════════
139
140@pairing_bp.route('/toggle_premium', methods=['POST'])
141@require_login
142def toggle_premium():
143    """Bouton de démo pour activer/désactiver Premium (pour le jury)."""
144    token = session['user']
145    try:
146        ctx     = get_user_context(token)
147        new_val = not ctx['is_premium']
148        db.child("users").child(ctx['local_id']).update({"premium": new_val}, token)
149        flash("Premium {} !".format("active" if new_val else "desactive"))
150    except Exception as e:
151        print("[toggle_premium] {}".format(e))
152        flash("Erreur lors du changement de statut.")
153    return redirect(url_for('main.settings'))

  1# ══════════════════════════════════════════════════════════════════════════════
  2#  ROUTES — CASIER SPORT
  3# ──────────────────────────────────────────────────────────────────────────────
  4#  Casier réservé aux membres Premium. L'utilisateur démarre une session, ouvre
  5#  la porte à la demande (pulse), puis termine — ce qui dissocie automatiquement
  6#  le casier pour libérer la place au prochain utilisateur.
  7# ══════════════════════════════════════════════════════════════════════════════
  8
  9import time
 10
 11import config
 12
 13from flask import Blueprint, render_template, request, redirect, session, url_for, flash
 14
 15from extensions import db, LOCKERS
 16from helpers import (
 17    get_user_context, get_locker_state, _log_session,
 18    require_login, _unpair_after_session, lockdown_message,
 19)
 20
 21sport_bp = Blueprint('sport', __name__)
 22
 23
 24@sport_bp.route('/locker/sport')
 25@require_login
 26def locker_sport():
 27    try:
 28        token = session['user']
 29        ctx   = get_user_context(token)
 30        if 'sport' not in ctx['paired']:
 31            flash("Appairez d'abord ce casier depuis le dashboard.")
 32            return redirect(url_for('main.home'))
 33        state = get_locker_state("sport", token, ctx['local_id'])
 34        return render_template('locker_sport.html',
 35                               pseudo=session.get('pseudo'),
 36                               photo=ctx['photo_url'],
 37                               is_premium=ctx['is_premium'],
 38                               local_id=ctx['local_id'],
 39                               state=state,
 40                               admin_email=(config.ADMIN_EMAILS[0] if config.ADMIN_EMAILS else ''),
 41                               locker=LOCKERS["sport"])
 42    except Exception as e:
 43        print("[locker_sport] {}".format(e))
 44        session.clear()
 45        return redirect(url_for('main.home'))
 46
 47
 48@sport_bp.route('/locker/sport/toggle', methods=['POST'])
 49@require_login
 50def toggle_sport():
 51    token = session['user']
 52    try:
 53        ctx    = get_user_context(token)
 54        action = request.form.get('action', '')
 55        if 'sport' not in ctx['paired']:
 56            flash("Vous devez d'abord appairer ce casier.")
 57            return redirect(url_for('main.home'))
 58        if not ctx['is_premium']:
 59            flash("Acces reserve aux membres Premium.")
 60            return redirect(url_for('sport.locker_sport'))
 61
 62        lid   = LOCKERS["sport"]["id"]
 63        state = get_locker_state("sport", token, ctx['local_id'])
 64
 65        # Bloquer toute action si le casier est hors-ligne (Raspberry Pi eteint)
 66        if not state.get("online"):
 67            flash("Casier hors-ligne : impossible de l'utiliser tant qu'il n'est pas allume.")
 68            return redirect(url_for('sport.locker_sport'))
 69
 70        # Bloquer toute action pendant un lockdown (intrusion : un admin intervient)
 71        if state.get("lockdown"):
 72            flash(lockdown_message())
 73            return redirect(url_for('sport.locker_sport'))
 74
 75        if action == 'start' or (not action and state["status"] == "locked"):
 76            # Démarrer une nouvelle session
 77            sess = {
 78                "user_id":    ctx['local_id'],
 79                "user_email": session.get('email'),
 80                "started_at": time.time(),
 81                "expires_at": 0,
 82                "amount_eur": 0,
 83            }
 84            db.child("lockers").child(lid).update(
 85                {"status": "unlocked", "active_session": sess, "cmd_open_door": time.time()}, token)
 86        elif action == 'open':
 87            # Ouvrir ponctuellement (pulse) pendant une session active
 88            db.child("lockers").child(lid).update({"cmd_open_door": time.time()}, token)
 89        elif action == 'end' or (not action and state["status"] == "unlocked"):
 90            # ── Verifier que la porte est bien fermee avant de cloturer ──
 91            # Si la porte est physiquement ouverte, on refuse la fin de session
 92            # pour eviter qu'un utilisateur termine en laissant ses affaires
 93            # accessibles a tous.
 94            phys = (state.get("physical_state") or "").strip().lower()
 95            if phys in ("ouverte", "open"):
 96                flash("Veuillez d'abord fermer physiquement la porte du casier avant de terminer la session.")
 97                return redirect(url_for('sport.locker_sport'))
 98            # Terminer la session
 99            _log_session("sport", lid, state["session"], token, "manual")
100            db.child("lockers").child(lid).update(
101                {"status": "locked", "active_session": None}, token)
102            # ── Dissocier automatiquement le casier sport apres la session ──
103            # Le client a fini d'utiliser le casier : on libere la place pour
104            # le prochain utilisateur. Le client devra rescanner le QR pour
105            # une prochaine session.
106            _unpair_after_session("sport", token, ctx['local_id'])
107            # Redirection vers la page "merci"
108            return redirect(url_for('sport.sport_thanks'))
109    except Exception as e:
110        print("[toggle_sport] {}".format(e))
111        flash("Erreur lors de la commande du casier.")
112    return redirect(url_for('sport.locker_sport'))
113
114
115@sport_bp.route('/locker/sport/thanks')
116@require_login
117def sport_thanks():
118    """Page de remerciement apres avoir termine la session sport.
119    Le casier a ete dissocie automatiquement, l'utilisateur n'a plus de casier paire."""
120    try:
121        ctx = get_user_context(session['user'])
122        return render_template('sport_thanks.html',
123                               pseudo=session.get('pseudo'),
124                               photo=ctx['photo_url'],
125                               is_premium=ctx['is_premium'])
126    except Exception as e:
127        print("[sport_thanks] {}".format(e))
128        return redirect(url_for('main.home'))

  1# ══════════════════════════════════════════════════════════════════════════════
  2#  ROUTES — CASIER ECOLE (réservation payante + Stripe)
  3# ──────────────────────────────────────────────────────────────────────────────
  4#  Casier louable à l'heure via paiement Stripe. Gère :
  5#    • La réservation d'un créneau (checkout Stripe)
  6#    • La confirmation de paiement (/success) — idempotente
  7#    • La prolongation d'une session en cours (+1h)
  8#    • L'ouverture / annulation / fermeture de session
  9#    • Le webhook Stripe (source de vérité asynchrone)
 10#
 11#  La fonction _apply_school_booking est ici car elle est spécifique au casier
 12#  école et partagée entre /success (token utilisateur) et le webhook (firebase-admin).
 13# ══════════════════════════════════════════════════════════════════════════════
 14
 15import time
 16from datetime import datetime, timedelta
 17
 18from flask import Blueprint, render_template, request, redirect, session, url_for, flash
 19
 20import config
 21from extensions import (
 22    db, admin_db, stripe,
 23    LOCKERS, SCHOOL_HOURS, PRICE_PER_HOUR, STRIPE_PUB_KEY,
 24)
 25from helpers import (
 26    get_user_context, get_locker_state, _log_session,
 27    _get_booked_slots, require_login, _unpair_after_session, lockdown_message,
 28)
 29
 30school_bp = Blueprint('school', __name__)
 31
 32
 33def _create_checkout(amount, name, description, success_endpoint, metadata):
 34    """Crée une session Stripe Checkout (carte, paiement unique) et retourne son URL.
 35    `success_endpoint` reçoit ?session_id={CHECKOUT_SESSION_ID} ; annulation → page école."""
 36    return stripe.checkout.Session.create(
 37        payment_method_types=['card'],
 38        line_items=[{
 39            'price_data': {
 40                'currency': 'eur',
 41                'unit_amount': amount,
 42                'product_data': {'name': name, 'description': description},
 43            },
 44            'quantity': 1,
 45        }],
 46        mode='payment',
 47        success_url=url_for(success_endpoint, _external=True) + '?session_id={CHECKOUT_SESSION_ID}',
 48        cancel_url=url_for('school.locker_school', _external=True),
 49        metadata=metadata,
 50    ).url
 51
 52
 53@school_bp.route('/locker/school')
 54@require_login
 55def locker_school():
 56    try:
 57        token = session['user']
 58        ctx   = get_user_context(token)
 59        if 'school' not in ctx['paired']:
 60            flash("Appairez d'abord ce casier depuis le dashboard.")
 61            return redirect(url_for('main.home'))
 62        state        = get_locker_state("school", token, ctx['local_id'])
 63        booked_slots = _get_booked_slots(token)
 64        # Si session active, verifie si elle appartient a l'utilisateur courant
 65        is_my_session = (state.get("session", {}).get("user_id") == ctx['local_id'])
 66        return render_template('locker_school.html',
 67                               pseudo=session.get('pseudo'),
 68                               photo=ctx['photo_url'],
 69                               is_premium=ctx['is_premium'],
 70                               state=state,
 71                               is_my_session=is_my_session,
 72                               locker=LOCKERS["school"],
 73                               stripe_pub=STRIPE_PUB_KEY,
 74                               school_hours=SCHOOL_HOURS,
 75                               booked_slots=booked_slots,
 76                               admin_email=(config.ADMIN_EMAILS[0] if config.ADMIN_EMAILS else ''),
 77                               now_ts=time.time())
 78    except Exception as e:
 79        print("[locker_school] {}".format(e))
 80        session.clear()
 81        return redirect(url_for('main.home'))
 82
 83
 84@school_bp.route('/locker/school/checkout', methods=['POST'])
 85@require_login
 86def school_checkout():
 87    token     = session['user']
 88    try:
 89        ctx       = get_user_context(token)
 90        # Empecher toute reservation si le casier est hors-ligne
 91        state_check = get_locker_state("school", token, ctx['local_id'])
 92        if not state_check.get("online"):
 93            flash("Casier hors-ligne : impossible de reserver tant qu'il n'est pas allume.")
 94            return redirect(url_for('school.locker_school'))
 95        date_str  = request.form.get('date', '').strip()
 96        start_str = request.form.get('start_hour', '').strip()
 97        hours_str = request.form.get('hours', '1')
 98
 99        # "now" = reservation immediate : le debut est l'instant present (a la
100        # minute pres) et non un creneau a l'heure pleine.
101        is_now = (start_str.lower() == "now")
102
103        # ── Validation ──
104        errors = []
105        if not date_str and not is_now:
106            errors.append("Veuillez choisir une date.")
107        if not start_str:
108            errors.append("Veuillez choisir une heure de debut.")
109
110        try:
111            hours = int(hours_str)
112            if hours < 1 or hours > 6:
113                errors.append("Duree invalide (1h a 6h).")
114        except ValueError:
115            hours = 1
116            errors.append("Duree invalide.")
117
118        start_h  = 0
119        start_dt = None
120        if is_now:
121            # Reservation immediate : debut = maintenant, fin = +hours (a la minute pres)
122            start_dt = datetime.now()
123            start_h  = start_dt.hour
124            end_dt   = start_dt + timedelta(hours=hours)
125            # La fin doit rester avant la fermeture (22h00) le meme jour
126            fermeture = start_dt.replace(hour=22, minute=0, second=0, microsecond=0)
127            if end_dt > fermeture:
128                errors.append("La session depasserait l'heure de fermeture (22h00). Reduisez la duree.")
129            # Verification disponibilite sur toutes les heures chevauchees par la session
130            today_str    = start_dt.strftime("%Y-%m-%d")
131            booked_slots = _get_booked_slots(token)
132            # On verifie chaque heure pleine touchee par l'intervalle [start_dt, end_dt[
133            for h in range(start_h, end_dt.hour + (1 if end_dt.minute > 0 else 0)):
134                slot_key = "{}-{:02d}:00".format(today_str, h)
135                if slot_key in booked_slots:
136                    errors.append("Le creneau {:02d}h-{:02d}h est deja occupe.".format(h, h + 1))
137                    break
138        elif date_str and start_str:
139            try:
140                booking_date = datetime.strptime(date_str, "%Y-%m-%d")
141                today        = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
142                max_date     = today + timedelta(days=14)
143                if booking_date < today:
144                    errors.append("La date est dans le passe.")
145                elif booking_date > max_date:
146                    errors.append("Reservation possible jusqu'a 14 jours a l'avance.")
147                start_h = int(start_str.split(":")[0])
148                if start_h < 8 or start_h > 21:
149                    errors.append("Heure de debut invalide (08h-21h).")
150                end_h = start_h + hours
151                if end_h > 22:
152                    errors.append("La session depasse l'heure de fermeture (22h00).")
153                start_dt = datetime.strptime("{} {}".format(date_str, start_str), "%Y-%m-%d %H:%M")
154                if start_dt < datetime.now():
155                    errors.append("Ce creneau est deja passe.")
156                # Verification disponibilite (pre-check)
157                booked_slots = _get_booked_slots(token)
158                for h in range(hours):
159                    slot_key = "{}-{:02d}:00".format(date_str, start_h + h)
160                    if slot_key in booked_slots:
161                        errors.append("Le creneau {:02d}h-{:02d}h est deja occupe.".format(start_h + h, start_h + h + 1))
162                        break
163            except ValueError:
164                errors.append("Format de date ou d'heure invalide.")
165
166        if errors:
167            for e in errors:
168                flash(e)
169            return redirect(url_for('school.locker_school'))
170
171        # ── Calcul montants ──
172        amount     = hours * PRICE_PER_HOUR
173        if start_dt is None:  # garde-fou (ne devrait pas arriver : errors aurait stoppe)
174            start_dt = datetime.strptime("{} {}".format(date_str, start_str), "%Y-%m-%d %H:%M")
175        start_ts   = start_dt.timestamp()
176        expires_ts = start_ts + hours * 3600
177
178        # Pour "maintenant", on derive des libelles lisibles depuis l'instant reel
179        # (sinon date_str serait vide et start_str vaudrait "now").
180        if is_now:
181            date_str  = start_dt.strftime("%Y-%m-%d")
182            start_str = start_dt.strftime("%H:%M")
183
184        checkout_url = _create_checkout(
185            amount,
186            'SmartLocker Ecole - {}h le {}'.format(hours, start_dt.strftime("%d/%m a %Hh")),
187            'Casier Ecole de {}h a {}h'.format(start_h, start_h + hours),
188            'school.school_success',
189            {
190                'user_id':    ctx['local_id'],
191                'user_email': session.get('email') or '',
192                'hours':      str(hours),
193                'amount_eur': str(amount / 100),
194                'start_ts':   str(start_ts),
195                'expires_ts': str(expires_ts),
196                'date_str':   date_str,
197                'start_str':  start_str,
198                'kind':       'school_booking',
199            },
200        )
201        return redirect(checkout_url, code=303)
202    except Exception as e:
203        print("[school_checkout] {}".format(e))
204        flash("Erreur lors de la creation du paiement. Reessayez.")
205        return redirect(url_for('school.locker_school'))
206
207
208def _record_payment(stripe_session, status_str, token):
209    """
210    Enregistre le paiement + la reservation dans /payments/{stripe_session_id}.
211    Idempotent (cle = session Stripe). Sert de trace durable et de seconde source
212    de verite pour eviter les erreurs / doubles reservations, meme si /success
213    n'est jamais atteint (le webhook l'ecrit aussi).
214    """
215    meta = stripe_session.get('metadata', {}) or {}
216    sid  = stripe_session.get('id', '')
217    if not sid:
218        return
219    lid = LOCKERS["school"]["id"]
220    record = {
221        "stripe_session_id": sid,
222        "locker_id":         lid,
223        "locker_key":        "school",
224        "user_id":           meta.get('user_id', ''),
225        "user_email":        meta.get('user_email', ''),
226        "hours":             int(meta.get('hours', 1)),
227        "amount_eur":        float(meta.get('amount_eur', 0) or 0),
228        "start_ts":          float(meta.get('start_ts', 0) or 0),
229        "expires_ts":        float(meta.get('expires_ts', 0) or 0),
230        "date_str":          meta.get('date_str', ''),
231        "start_str":         meta.get('start_str', ''),
232        "payment_status":    stripe_session.get('payment_status', 'paid'),
233        "reservation_status": status_str,   # 'unlocked' (en cours) ou 'reserved' (a venir)
234        "recorded_at":       time.time(),
235    }
236    try:
237        use_admin = (token is None and admin_db is not None)
238        if use_admin:
239            ref = admin_db.reference("payments/{}".format(sid))
240            if ref.get():
241                return  # deja enregistre -> idempotent
242            ref.set(record)
243        else:
244            existing = db.child("payments").child(sid).get(token).val()
245            if existing:
246                return  # deja enregistre -> idempotent
247            db.child("payments").child(sid).set(record, token)
248        print("[_record_payment] paiement/reservation enregistre : {}".format(sid))
249    except Exception as e:
250        print("[_record_payment] {}".format(e))
251
252
253def _apply_school_booking(stripe_session, token):
254    """
255    Applique la reservation apres paiement. Idempotent.
256    Utilise par /success (avec token utilisateur) ET par le webhook (token=None
257    → utilise firebase-admin si disponible).
258    """
259    lid  = LOCKERS["school"]["id"]
260    meta = stripe_session.get('metadata', {}) or {}
261
262    hours      = int(meta.get('hours', 1))
263    amount_eur = float(meta.get('amount_eur', 5))
264    start_ts   = float(meta.get('start_ts', time.time()))
265    expires_ts = float(meta.get('expires_ts', start_ts + hours * 3600))
266    date_str   = meta.get('date_str', '')
267    start_str  = meta.get('start_str', '')
268    user_id    = meta.get('user_id', '')
269    user_email = meta.get('user_email', '')
270    sid        = stripe_session.get('id', '')
271
272    use_admin = (token is None and admin_db is not None)
273
274    # Lecture session existante
275    if use_admin:
276        existing = admin_db.reference("lockers/{}/active_session".format(lid)).get() or {}
277    else:
278        existing = db.child("lockers").child(lid).child("active_session").get(token).val() or {}
279    if isinstance(existing, str):
280        existing = {}
281
282    # Idempotence — si deja traite, on ne fait rien
283    if existing.get("stripe_session_id") == sid:
284        return {
285            "already_applied": True,
286            "hours":      hours, "amount_eur": amount_eur,
287            "start_ts":   start_ts, "expires_ts": expires_ts,
288            "date_str":   date_str, "start_str":  start_str,
289        }
290
291    # Casier deja occupe par une autre reservation non terminee
292    if existing and existing.get("expires_at", 0) > time.time():
293        return {"conflict": True}
294
295    now    = time.time()
296    status = "unlocked" if start_ts <= now < expires_ts else "reserved"
297
298    sess = {
299        "user_id":           user_id,
300        "user_email":        user_email,
301        "started_at":        start_ts,
302        "expires_at":        expires_ts,
303        "hours":             hours,
304        "amount_eur":        amount_eur,
305        "stripe_session_id": sid,
306        "date_str":          date_str,
307        "start_str":         start_str,
308    }
309    if use_admin:
310        admin_db.reference("lockers/{}".format(lid)).set(
311            {"status": status, "active_session": sess})
312    else:
313        db.child("lockers").child(lid).set(
314            {"status": status, "active_session": sess}, token)
315
316    # Trace durable du paiement + reservation (anti double-reservation / audit)
317    _record_payment(stripe_session, status, token)
318
319    return {
320        "already_applied": False,
321        "hours":      hours, "amount_eur": amount_eur,
322        "start_ts":   start_ts, "expires_ts": expires_ts,
323        "date_str":   date_str, "start_str":  start_str,
324    }
325
326
327@school_bp.route('/locker/school/success')
328@require_login
329def school_success():
330    stripe_session_id = request.args.get('session_id')
331    if not stripe_session_id:
332        flash("Session de paiement introuvable.")
333        return redirect(url_for('school.locker_school'))
334    token = session['user']
335    try:
336        stripe_session = stripe.checkout.Session.retrieve(stripe_session_id)
337        if stripe_session.payment_status != 'paid':
338            flash("Paiement non confirme. Reessayez.")
339            return redirect(url_for('school.locker_school'))
340
341        result = _apply_school_booking(stripe_session, token)
342
343        if result.get("conflict"):
344            flash("Le casier vient d'etre occupe par une autre reservation. Contactez le support pour un remboursement.")
345            return redirect(url_for('school.locker_school'))
346
347        return render_template('payment_success.html',
348                               hours=result['hours'],
349                               amount_eur=result['amount_eur'],
350                               expires_at=result['expires_ts'],
351                               start_ts=result['start_ts'],
352                               date_str=result['date_str'],
353                               start_str=result['start_str'])
354    except Exception as e:
355        print("[school_success] {}".format(e))
356        flash("Erreur de confirmation du paiement.")
357        return redirect(url_for('school.locker_school'))
358
359
360@school_bp.route('/locker/school/extend', methods=['POST'])
361@require_login
362def school_extend():
363    token = session['user']
364    try:
365        ctx   = get_user_context(token)
366        state = get_locker_state("school", token, ctx['local_id'])
367        if state["status"] != "unlocked" or not state["session"]:
368            flash("Aucune session active a prolonger.")
369            return redirect(url_for('school.locker_school'))
370        expires_at = state["session"].get("expires_at", 0)
371        remaining  = expires_at - time.time()
372        if remaining > 1800:
373            flash("Vous ne pouvez prolonger que lorsqu'il reste moins de 30 minutes.")
374            return redirect(url_for('school.locker_school'))
375        new_expires = expires_at + 3600
376        amount      = PRICE_PER_HOUR
377
378        checkout_url = _create_checkout(
379            amount,
380            'SmartLocker Ecole - Prolongation +1h',
381            'Extension de votre session en cours',
382            'school.school_extend_success',
383            {
384                'user_id':        ctx['local_id'],
385                'amount_eur':     '5.0',
386                'new_expires_ts': str(new_expires),
387                'kind':           'school_extend',
388            },
389        )
390        return redirect(checkout_url, code=303)
391    except Exception as e:
392        print("[school_extend] {}".format(e))
393        flash("Erreur lors de la creation du paiement de prolongation.")
394        return redirect(url_for('school.locker_school'))
395
396
397@school_bp.route('/locker/school/extend/success')
398@require_login
399def school_extend_success():
400    stripe_session_id = request.args.get('session_id')
401    if not stripe_session_id:
402        flash("Session de paiement introuvable.")
403        return redirect(url_for('school.locker_school'))
404    token = session['user']
405    lid   = LOCKERS["school"]["id"]
406    try:
407        stripe_session = stripe.checkout.Session.retrieve(stripe_session_id)
408        if stripe_session.payment_status != 'paid':
409            flash("Paiement de prolongation non confirme.")
410            return redirect(url_for('school.locker_school'))
411        new_expires = float(stripe_session.metadata.get('new_expires_ts', 0))
412        if not new_expires:
413            flash("Erreur de prolongation.")
414            return redirect(url_for('school.locker_school'))
415        data = db.child("lockers").child(lid).get(token).val() or {}
416        sess = data.get("active_session") or {}
417        if isinstance(sess, str):
418            sess = {}
419        # Idempotence : si déjà appliqué, on ne refait pas l'extension
420        applied_extends = sess.get("applied_extends") or []
421        if not isinstance(applied_extends, list):
422            applied_extends = []
423        if stripe_session_id in applied_extends:
424            flash("Prolongation déjà appliquée.")
425            return redirect(url_for('school.locker_school'))
426        sess["expires_at"]  = new_expires
427        sess["hours"]       = sess.get("hours", 1) + 1
428        sess["amount_eur"]  = float(sess.get("amount_eur", 0)) + 5.0
429        applied_extends.append(stripe_session_id)
430        sess["applied_extends"] = applied_extends
431        db.child("lockers").child(lid).update({"active_session": sess}, token)
432        flash("Session prolongee d'1 heure !")
433    except Exception as e:
434        print("[school_extend_success] {}".format(e))
435        flash("Erreur de confirmation de prolongation.")
436    return redirect(url_for('school.locker_school'))
437
438
439@school_bp.route('/locker/school/open', methods=['POST'])
440@require_login
441def school_open():
442    """Envoie une commande d'ouverture pulse au Pi du casier ecole.
443    Disponible uniquement pendant une session active (status == unlocked).
444    Le client peut ouvrir/refermer autant de fois qu'il veut pendant ses heures payees."""
445    token = session['user']
446    try:
447        ctx = get_user_context(token)
448        if 'school' not in ctx['paired']:
449            flash("Casier non appaire.")
450            return redirect(url_for('main.home'))
451        lid   = LOCKERS["school"]["id"]
452        state = get_locker_state("school", token, ctx['local_id'])
453
454        # Verifier que le casier est en ligne
455        if not state.get("online"):
456            flash("Casier hors-ligne : impossible d'ouvrir la porte.")
457            return redirect(url_for('school.locker_school'))
458
459        # Bloquer pendant un lockdown (intrusion detectee : un admin intervient)
460        if state.get("lockdown"):
461            flash(lockdown_message())
462            return redirect(url_for('school.locker_school'))
463
464        # Verifier qu'une session est active ET appartient a l'utilisateur
465        if state["status"] != "unlocked":
466            flash("Aucune session active : reservez d'abord un creneau.")
467            return redirect(url_for('school.locker_school'))
468        sess = state.get("session") or {}
469        if sess.get("user_id") != ctx['local_id']:
470            flash("Cette session ne vous appartient pas.")
471            return redirect(url_for('school.locker_school'))
472
473        # Envoyer une commande pulse au Pi (ouvre la porte 4s puis se ferme)
474        db.child("lockers").child(lid).update({"cmd_open_door": time.time()}, token)
475        flash("Porte ouverte.")
476    except Exception as e:
477        print("[school_open] {}".format(e))
478        flash("Erreur lors de l'ouverture.")
479    return redirect(url_for('school.locker_school'))
480
481
482@school_bp.route('/locker/school/cancel', methods=['POST'])
483@require_login
484def school_cancel():
485    """Annule une reservation FUTURE (statut 'reserved') si l'heure d'ouverture
486    est dans plus d'1 heure. Au-dela on ne peut plus annuler (le client a deja
487    bloque le creneau)."""
488    token = session['user']
489    try:
490        ctx = get_user_context(token)
491        if 'school' not in ctx['paired']:
492            flash("Casier non appaire.")
493            return redirect(url_for('main.home'))
494        lid   = LOCKERS["school"]["id"]
495        state = get_locker_state("school", token, ctx['local_id'])
496
497        # Doit etre en mode 'reserved' (pas encore ouvert)
498        if state["status"] != "reserved":
499            flash("Aucune reservation en attente a annuler.")
500            return redirect(url_for('school.locker_school'))
501
502        sess = state.get("session") or {}
503        if sess.get("user_id") != ctx['local_id']:
504            flash("Cette reservation ne vous appartient pas.")
505            return redirect(url_for('school.locker_school'))
506
507        started_at = sess.get("started_at", 0)
508        time_before = started_at - time.time()
509        # Doit rester au moins 1 heure avant l'ouverture
510        if time_before < 3600:
511            mins = max(0, int(time_before / 60))
512            flash("Annulation impossible : il reste {} minutes avant l'ouverture. L'annulation n'est possible que jusqu'a 1h avant le creneau.".format(mins))
513            return redirect(url_for('school.locker_school'))
514
515        # Logger l'annulation dans l'historique (montant=0, raison=cancelled)
516        cancel_sess = dict(sess)
517        cancel_sess["amount_eur"] = 0  # pas de remboursement enregistre cote app
518        _log_session("school", lid, cancel_sess, token, "cancelled")
519
520        # Supprimer la reservation
521        db.child("lockers").child(lid).set(
522            {"status": "locked", "active_session": None}, token)
523        # Reservation annulee -> retirer le casier du compte (libere la place)
524        _unpair_after_session("school", token, ctx['local_id'])
525        flash("Reservation annulee et casier retire de votre compte. Pour le remboursement, contactez l'administration.")
526    except Exception as e:
527        print("[school_cancel] {}".format(e))
528        flash("Erreur lors de l'annulation.")
529    return redirect(url_for('school.locker_school'))
530
531
532@school_bp.route('/locker/school/close', methods=['POST'])
533@require_login
534def school_close():
535    token = session['user']
536    try:
537        ctx   = get_user_context(token)
538        if 'school' not in ctx['paired']:
539            flash("Casier non appairé.")
540            return redirect(url_for('main.home'))
541        lid   = LOCKERS["school"]["id"]
542        state = get_locker_state("school", token, ctx['local_id'])
543        if state["status"] == "unlocked":
544            sess = state.get("session") or {}
545            # On ne ferme que si c'est la session de l'utilisateur
546            if sess.get("user_id") == ctx['local_id']:
547                _log_session("school", lid, sess, token, "manual")
548                db.child("lockers").child(lid).set(
549                    {"status": "locked", "active_session": None}, token)
550                # Fin de session -> retirer le casier du compte (libere la place)
551                _unpair_after_session("school", token, ctx['local_id'])
552                flash("Session terminée. Le casier a été retiré de votre compte.")
553    except Exception as e:
554        print("[school_close] {}".format(e))
555        flash("Erreur lors de la fermeture.")
556    return redirect(url_for('school.locker_school'))
557
558
559# ==============================================================================
560#  STRIPE WEBHOOK (source de verite asynchrone)
561# ==============================================================================
562
563@school_bp.route('/stripe/webhook', methods=['POST'])
564def stripe_webhook():
565    """
566    Recoit les evenements Stripe. Est la source de verite : si l'utilisateur
567    ferme son navigateur avant /success, le webhook applique quand meme
568    la reservation.
569    Le webhook n'a pas de session utilisateur, il utilise donc un token admin
570    (ou ecrit directement sans auth). Ici on utilise db.child sans token --
571    attention aux regles de securite Firebase.
572    """
573    payload = request.data
574    sig     = request.headers.get('Stripe-Signature', '')
575    try:
576        event = stripe.Webhook.construct_event(payload, sig, config.STRIPE_WEBHOOK_SECRET)
577    except Exception as e:
578        print("[stripe_webhook] Signature invalide: {}".format(e))
579        return '', 400
580
581    if event['type'] == 'checkout.session.completed':
582        data = event['data']['object']
583        meta = data.get('metadata', {}) or {}
584        kind = meta.get('kind', '')
585        print("[Stripe webhook] {} recu pour {}".format(data.get('id'), kind))
586
587        # On ecrit directement dans Firebase (token=None).
588        # NOTE: Firebase Realtime Database doit etre configure en mode test
589        # OU avoir des regles qui autorisent l'ecriture sur /lockers sans auth.
590        # A terme, utiliser une service-account cle pour auth admin.
591        if kind == 'school_booking':
592            try:
593                _apply_school_booking(data, None)
594                print("[Stripe webhook] school_booking applique")
595            except Exception as e:
596                print("[Stripe webhook] Erreur school_booking: {}".format(e))
597
598    return '', 200