Merge remote-tracking branch 'origin/main' into claude/lecture-video

# Conflicts:
#	CHANGELOG.md

bin/api/epg_api.dart

@@ -3,6 +3,7 @@ import 'package:shelf/shelf.dart';
 import 'package:http/http.dart' as http;
 import '../models/playlist_config.dart';
 import '../services/xmltv_epg_service.dart';
+import '../utils/log_redactor.dart';
 
 /// API EPG — proxy vers Xtream avec cache 30 minutes
 /// GET /api/epg/<channel_id>?days=1
@@ -112,8 +113,11 @@ class EpgApi {
         },
       );
     } catch (e) {
+      // Détail redacté en log uniquement : une ClientException Dart contient
+      // l'URI amont, credentials Xtream inclus.
+      print('[EpgApi] Erreur EPG: ${LogRedactor.redactUrl('$e')}');
       return Response.internalServerError(
-        body: json.encode({'error': 'Erreur lors de la récupération EPG: $e'}),
+        body: json.encode({'error': 'Erreur lors de la récupération EPG'}),
         headers: {'Content-Type': 'application/json'},
       );
     }
@@ -258,7 +262,12 @@ class EpgApi {
 
       return {'channel_id': channelId, 'programmes': programmes};
     } catch (e) {
-      return {'channel_id': channelId, 'programmes': [], 'error': e.toString()};
+      print('[EpgApi] Erreur panneau pour $channelId: ${LogRedactor.redactUrl('$e')}');
+      return {
+        'channel_id': channelId,
+        'programmes': [],
+        'error': 'EPG indisponible',
+      };
     }
   }
 

bin/api/proxy_handler.dart

@@ -3,6 +3,8 @@ import 'dart:convert';
 import 'dart:io';
 import 'package:shelf/shelf.dart';
 import 'package:http/http.dart' as http;
+import '../database/database.dart';
+import '../middleware/auth_middleware.dart';
 import '../models/playlist_config.dart';
 import '../utils/log_redactor.dart';
 
@@ -31,6 +33,7 @@ bool isForbiddenProxyHost(String host) {
 /// Handler for the Xtream Proxy
 class ProxyHandler {
   final Future<PlaylistConfig?> Function(Request) _getPlaylist;
+  final AppDatabase _db;
   final http.Client _client = http.Client();
 
   final Map<String, (PlaylistConfig, DateTime)> _playlistCache = {};
@@ -70,7 +73,7 @@ class ProxyHandler {
     return playlist;
   }
 
-  ProxyHandler(this._getPlaylist);
+  ProxyHandler(this._getPlaylist, this._db);
 
   /// Create Xtream proxy handler with M3U8 URL rewriting support
   Handler get handler {
@@ -84,8 +87,16 @@ class ProxyHandler {
         return Response.notFound(null);
       }
 
-      // NOTE: Authentication REMOVED from proxy to allow browser-initiated requests (img src, etc.)
-      // SSRF protection is still active via domain validation below.
+      // Authentification par session. Les requêtes initiées par le navigateur
+      // (img src, hls.js) ne portent pas d'en-tête Authorization mais envoient
+      // le cookie HttpOnly `session` (SameSite=Lax, même origine) posé au
+      // login : extractAuthToken accepte les deux. Un proxy ouvert offrait un
+      // rebond SSRF non authentifié vers n'importe quel hôte public via les
+      // extensions d'image.
+      final token = extractAuthToken(request);
+      if (token == null || _db.findSessionByToken(token) == null) {
+        return Response(401, body: 'Unauthorized');
+      }
 
       Uri? targetUrl;
 
@@ -139,6 +150,7 @@ class ProxyHandler {
             targetUrl.path.contains('/picons/') ||
             targetUrl.path.contains('/logos/');
 
+        String? allowedHost;
         if (!isStaticAsset) {
           // For API calls, enforce domain allowlist
           final playlist = await _getCachedPlaylist(request);
@@ -149,7 +161,7 @@ class ProxyHandler {
           }
 
           final targetHost = targetUrl.host.toLowerCase();
-          final allowedHost = Uri.parse(playlist.dns).host.toLowerCase();
+          allowedHost = Uri.parse(playlist.dns).host.toLowerCase();
 
           if (targetHost != allowedHost) {
             print(
@@ -175,7 +187,6 @@ class ProxyHandler {
 
         try {
           print('[Proxy] Forwarding to: ${LogRedactor.redactUrl(targetUrl.toString())}');
-          final proxyRequest = http.Request(request.method, targetUrl);
 
           // Forward safe request headers
           for (final header in _allowedRequestHeaders) {
@@ -184,18 +195,61 @@ class ProxyHandler {
             }
           }
 
-          proxyRequest.headers.addAll(proxyHeaders);
-          proxyRequest.followRedirects = true;
-
+          List<int>? postBody;
           if (request.method == 'POST') {
             final bodyBytes = await request.read().toList();
-            proxyRequest.bodyBytes = bodyBytes.expand((i) => i).toList();
+            postBody = bodyBytes.expand((i) => i).toList();
           }
 
-          // Added 90s timeout to allow frontend (60s) to time out gracefully first
-          final response = await _client
-              .send(proxyRequest)
-              .timeout(const Duration(seconds: 90));
+          // Redirections suivies MANUELLEMENT : chaque destination est
+          // revalidée (hôte privé, allowlist de domaine). Avec
+          // followRedirects, la validation ne portait que sur l'URL
+          // initiale — une 302 du serveur amont suffisait pour atteindre
+          // un hôte interne malgré l'anti-SSRF.
+          http.StreamedResponse response;
+          var currentUrl = targetUrl;
+          var redirects = 0;
+          while (true) {
+            final proxyRequest = http.Request(request.method, currentUrl);
+            proxyRequest.headers.addAll(proxyHeaders);
+            proxyRequest.followRedirects = false;
+            if (postBody != null) proxyRequest.bodyBytes = postBody;
+
+            // Added 90s timeout to allow frontend (60s) to time out gracefully first
+            response = await _client
+                .send(proxyRequest)
+                .timeout(const Duration(seconds: 90));
+
+            final location = response.headers['location'];
+            final isRedirect = response.statusCode >= 300 &&
+                response.statusCode < 400 &&
+                location != null;
+            if (!isRedirect) break;
+
+            if (++redirects > 3) {
+              return Response.forbidden('Too many redirects');
+            }
+            final next = Uri.parse(location);
+            currentUrl = next.isAbsolute ? next : currentUrl.resolve(location);
+            if (currentUrl.scheme != 'http' && currentUrl.scheme != 'https') {
+              return Response.forbidden('Unsupported redirect scheme');
+            }
+            if (isForbiddenProxyHost(currentUrl.host)) {
+              print(
+                '[Proxy] Blocked SSRF redirect to private host: ${currentUrl.host}',
+              );
+              return Response.forbidden('Access to this host is forbidden');
+            }
+            if (allowedHost != null &&
+                currentUrl.host.toLowerCase() != allowedHost) {
+              print(
+                '[Proxy] Blocked redirect to ${currentUrl.host} (Allowed: $allowedHost)',
+              );
+              return Response.forbidden(
+                'Access to this domain is forbidden by policy',
+              );
+            }
+          }
 
           // Build response headers from source response
           final responseHeaders = <String, String>{
@@ -221,7 +275,12 @@ class ProxyHandler {
           rethrow;
         }
       } catch (e) {
-        print('[ProxyHandler] error on $path: $e');
+        // Redaction : une ClientException porte l'URL amont, credentials
+        // Xtream inclus. Jamais de détail d'exception vers le client.
+        print(
+          '[ProxyHandler] error on ${LogRedactor.redactUrl(path)}: '
+          '${LogRedactor.redactUrl('$e')}',
+        );
 
         // Return transparent 1x1 pixel image fallback for images
         if (targetUrl?.path.endsWith('.png') == true ||
@@ -235,7 +294,7 @@ class ProxyHandler {
         }
 
         return Response.internalServerError(
-          body: jsonEncode({'error': 'Proxy error', 'message': e.toString()}),
+          body: jsonEncode({'error': 'Proxy error'}),
           headers: {'content-type': 'application/json'},
         );
       }

bin/api/recordings_api.dart

@@ -3,6 +3,7 @@ import 'dart:convert';
 import 'package:path/path.dart' as p;
 import 'package:shelf/shelf.dart';
 import '../database/database.dart';
+import '../models/recording.dart';
 import '../models/user.dart';
 import '../services/recording_scheduler.dart';
 import '../utils/safe_path.dart';
@@ -11,25 +12,43 @@ class RecordingsApi {
   final AppDatabase _db;
   final RecordingScheduler _scheduler;
 
+  /// Durée maximale d'un enregistrement (env MAX_RECORDING_HOURS).
+  final int maxRecordingHours = int.tryParse(
+        Platform.environment['MAX_RECORDING_HOURS'] ?? '',
+      ) ??
+      12;
+
   RecordingsApi(this._db, this._scheduler);
 
+  Response _json(int status, Map<String, dynamic> body) => Response(
+        status,
+        body: json.encode(body),
+        headers: {'Content-Type': 'application/json'},
+      );
+
+  /// L'utilisateur courant peut-il agir sur cet enregistrement ?
+  /// (même patron de contrôle de propriété que playlists_handler)
+  bool _canAccess(User? user, Recording recording) {
+    if (user == null) return false;
+    return user.isAdmin || recording.userId == user.id;
+  }
+
   /// Handler pour GET /api/recordings/logs/<id>
   /// Exposé séparément car shelf_router a un conflit entre DELETE /<id> et GET /logs/<id>
   Future<Response> getLogHandler(Request request, String id) async {
     final recording = _db.getRecordingById(id);
-    
+
     if (recording == null) {
-      return Response.notFound(
-        json.encode({'error': 'Enregistrement non trouvé'}),
-        headers: {'Content-Type': 'application/json'},
-      );
+      return _json(404, {'error': 'Enregistrement non trouvé'});
+    }
+
+    final user = request.context['user'] as User?;
+    if (!_canAccess(user, recording)) {
+      return _json(403, {'error': 'Accès refusé'});
     }
 
     if (recording.filePath == null) {
-      return Response.notFound(
-        json.encode({'error': 'Aucun fichier ni log associé pour le moment.'}),
-        headers: {'Content-Type': 'application/json'},
-      );
+      return _json(404, {'error': 'Aucun fichier ni log associé pour le moment.'});
     }
 
     // Les enregistrements sont écrits en .mkv avec un .log à côté
@@ -39,55 +58,115 @@ class RecordingsApi {
     // Anti path-traversal : le log doit rester dans le dossier des enregistrements
     final safeLogPath = SafePath.resolveWithin(recordingsDirPath, logFilePath);
     if (safeLogPath == null) {
-      return Response.forbidden(
-        json.encode({'error': 'Chemin de log invalide'}),
-        headers: {'Content-Type': 'application/json'},
-      );
+      return _json(403, {'error': 'Chemin de log invalide'});
     }
 
     final logFile = File(safeLogPath);
 
     if (!await logFile.exists()) {
-      return Response.notFound(
-        json.encode({'error': 'Le fichier de log est introuvable.'}),
-        headers: {'Content-Type': 'application/json'},
-      );
+      return _json(404, {'error': 'Le fichier de log est introuvable.'});
     }
 
     final logs = await logFile.readAsString();
-    return Response.ok(
-      json.encode({'logs': logs}),
-      headers: {'Content-Type': 'application/json'},
-    );
+    return _json(200, {'logs': logs});
   }
 
   /// GET /api/recordings — Liste les enregistrements de l'utilisateur
-  /// (tous les enregistrements pour un admin)
+  /// (tous les enregistrements pour un admin), enrichis des informations de
+  /// suivi : taille du fichier, progression, relances FFmpeg.
   Response handleGetAll(Request request) {
     final user = request.context['user'] as User?;
     final recordings = (user != null && !user.isAdmin)
         ? _db.getUserRecordings(user.id)
         : _db.getAllRecordings();
+    final now = DateTime.now().toUtc();
     return Response.ok(
-      json.encode(recordings.map((r) => r.toMap()).toList()),
+      json.encode(recordings.map((r) => _enrich(r, now)).toList()),
       headers: {'Content-Type': 'application/json'},
     );
   }
 
+  Map<String, dynamic> _enrich(Recording r, DateTime now) {
+    final map = r.toMap();
+
+    if (r.status == 'recording') {
+      final start = r.startTime.toUtc();
+      final end = r.endTime.toUtc();
+      final total = end.difference(start).inSeconds;
+      if (total > 0) {
+        final elapsed = now.difference(start).inSeconds;
+        map['progress_pct'] =
+            (elapsed * 100 / total).clamp(0, 100).round();
+      }
+      map['is_active'] = _scheduler.isCapturing(r.id);
+      final retries = _scheduler.retryCountOf(r.id);
+      if (retries != null) map['retry_count'] = retries;
+    }
+
+    final path = r.filePath;
+    if (path != null) {
+      try {
+        final file = File(path);
+        if (file.existsSync()) map['file_size_bytes'] = file.lengthSync();
+      } catch (_) {}
+    }
+
+    return map;
+  }
+
   /// POST /api/recordings — Planifie un nouvel enregistrement
   Future<Response> handlePost(Request request) async {
-    try {
-      final payload = await request.readAsString();
-      final data = json.decode(payload);
+    final user = request.context['user'] as User?;
+    final userId = user?.id ?? request.context['userId'] as String?;
+    if (userId == null) {
+      return _json(401, {'error': 'Authentification requise'});
+    }
 
-      final userId = request.context['userId'] as String? ?? 'dev_user_id';
+    Map<String, dynamic> data;
+    try {
+      data = json.decode(await request.readAsString()) as Map<String, dynamic>;
+    } catch (_) {
+      return _json(400, {'error': 'Corps JSON invalide'});
+    }
+
+    final channelId = data['channel_id']?.toString() ?? '';
+    final streamUrl = data['stream_url']?.toString() ?? '';
+    if (channelId.isEmpty) {
+      return _json(400, {'error': 'channel_id est requis'});
+    }
+    if (streamUrl.isEmpty) {
+      return _json(400, {'error': 'stream_url est requis'});
+    }
+
+    final startTime = _parseZonedDate(data['start_time']);
+    final endTime = _parseZonedDate(data['end_time']);
+    if (startTime == null || endTime == null) {
+      // Une date sans indicateur de fuseau ('Z' ou ±hh:mm) est ambiguë :
+      // l'interpréter dans le fuseau du serveur décale l'enregistrement
+      // de plusieurs heures selon le TZ du conteneur.
+      return _json(400, {
+        'error':
+            'start_time et end_time doivent être des dates ISO-8601 avec fuseau '
+            '(ex: 2026-08-27T21:00:00Z)',
+      });
+    }
+    if (!endTime.isAfter(startTime)) {
+      return _json(400, {'error': 'end_time doit être après start_time'});
+    }
+    if (endTime.difference(startTime) > Duration(hours: maxRecordingHours)) {
+      return _json(400, {
+        'error': 'Durée maximale dépassée ($maxRecordingHours h)',
+      });
+    }
+
+    try {
       final recording = _db.createRecording(
         userId: userId,
-        channelId: data['channel_id'],
-        streamUrl: data['stream_url'],
-        title: data['title'] ?? 'Sans Titre',
-        startTime: DateTime.parse(data['start_time']),
-        endTime: DateTime.parse(data['end_time']),
+        channelId: channelId,
+        streamUrl: streamUrl,
+        title: data['title']?.toString() ?? 'Sans Titre',
+        startTime: startTime,
+        endTime: endTime,
       );
 
       return Response.ok(
@@ -95,58 +174,87 @@ class RecordingsApi {
         headers: {'Content-Type': 'application/json'},
       );
     } catch (e) {
-      return Response.internalServerError(
-        body: json.encode({'error': 'Erreur lors de la programmation: $e'}),
-        headers: {'Content-Type': 'application/json'},
-      );
+      print('[RecordingsApi] Erreur à la création: $e');
+      return _json(500, {'error': 'Erreur lors de la programmation'});
     }
   }
 
+  /// Parse une date ISO-8601 en exigeant un indicateur de fuseau, et la
+  /// normalise en UTC. Retourne null si absente, invalide ou naïve.
+  DateTime? _parseZonedDate(dynamic raw) {
+    final str = raw?.toString() ?? '';
+    if (str.isEmpty) return null;
+    // 'Z' final ou offset ±hh[:mm] après l'heure
+    final hasZone =
+        str.endsWith('Z') || RegExp(r'[+-]\d{2}:?\d{2}$').hasMatch(str);
+    if (!hasZone) return null;
+    return DateTime.tryParse(str)?.toUtc();
+  }
+
   /// DELETE /api/recordings/<id> — Annule ou supprime un enregistrement
-  /// Si un enregistrement FFmpeg est actif, il est arrêté avant la suppression
+  /// Si un enregistrement FFmpeg est actif, il est arrêté avant la suppression.
+  /// Les fichiers associés (.mkv, .log, parties) sont supprimés avec la ligne.
   Future<Response> handleDelete(Request request, String id) async {
     final recording = _db.getRecordingById(id);
 
     if (recording == null) {
-      return Response.notFound(
-        json.encode({'error': 'Enregistrement non trouvé'}),
-        headers: {'Content-Type': 'application/json'},
-      );
+      return _json(404, {'error': 'Enregistrement non trouvé'});
+    }
+
+    final user = request.context['user'] as User?;
+    if (!_canAccess(user, recording)) {
+      return _json(403, {'error': 'Accès refusé'});
     }
 
     // Tuer FFmpeg si cet enregistrement est en cours AVANT de supprimer de la DB
     await _scheduler.stopRecording(id);
 
+    // Supprimer les fichiers pour ne pas laisser d'orphelins sur le volume,
+    // en restant confiné au dossier des enregistrements.
+    final path = recording.filePath;
+    if (path != null) {
+      final safePath = SafePath.resolveWithin(recordingsDirPath, path);
+      if (safePath != null) {
+        await _scheduler.deleteRecordingFiles(safePath);
+      }
+    }
+
     _db.deleteRecording(id);
 
-    return Response.ok(
-      json.encode({'message': 'Enregistrement supprimé avec succès'}),
-      headers: {'Content-Type': 'application/json'},
-    );
+    return _json(200, {'message': 'Enregistrement supprimé avec succès'});
   }
 
   /// POST /api/recordings/stop/<id> — Arrête un enregistrement FFmpeg en cours
   Future<Response> handleStop(Request request, String id) async {
     final recording = _db.getRecordingById(id);
     if (recording == null) {
-      return Response.notFound(
-        json.encode({'error': 'Enregistrement non trouvé'}),
-        headers: {'Content-Type': 'application/json'},
-      );
+      return _json(404, {'error': 'Enregistrement non trouvé'});
     }
+
+    final user = request.context['user'] as User?;
+    if (!_canAccess(user, recording)) {
+      return _json(403, {'error': 'Accès refusé'});
+    }
+
     final stopped = await _scheduler.stopRecording(id);
     if (stopped) {
-      return Response.ok(
-        json.encode({'message': 'Enregistrement arrêté'}),
-        headers: {'Content-Type': 'application/json'},
-      );
-    } else {
-      // Pas de processus FFmpeg actif pour cet ID → marquer comme complété quand même
-      _db.updateRecordingStatus(id, 'completed');
-      return Response.ok(
-        json.encode({'message': 'Enregistrement marqué comme terminé'}),
-        headers: {'Content-Type': 'application/json'},
-      );
+      return _json(200, {'message': 'Enregistrement arrêté'});
     }
+
+    if (recording.status == 'scheduled') {
+      // Rien n'a encore été capturé : annulé, pas « terminé ». Marquer
+      // completed sans fichier faisait ensuite échouer la lecture.
+      _db.updateRecordingStatus(id, 'cancelled');
+      return _json(200, {'message': 'Enregistrement annulé'});
+    }
+
+    if (recording.status == 'recording') {
+      // Statut « recording » sans processus actif (orphelin) : clôturer.
+      _db.updateRecordingStatus(id, 'completed');
+      return _json(200, {'message': 'Enregistrement marqué comme terminé'});
+    }
+
+    // Déjà completed/failed/cancelled : ne pas écraser le statut final.
+    return _json(200, {'message': 'Enregistrement déjà clôturé'});
   }
 }

bin/api/season_passes_api.dart

@@ -9,17 +9,29 @@ class SeasonPassesApi {
 
   SeasonPassesApi(this._db);
 
-  /// GET /api/season-passes — liste tous les season passes
+  /// GET /api/season-passes — liste les season passes de l'utilisateur
+  /// (tous les passes pour un admin)
   Response handleGetAll(Request request) {
     try {
-      final passes = _db.getAllSeasonPasses();
+      final user = request.context['user'] as User?;
+      if (user == null) {
+        return Response(
+          401,
+          body: json.encode({'error': 'Authentification requise'}),
+          headers: {'Content-Type': 'application/json'},
+        );
+      }
+      final passes = user.isAdmin
+          ? _db.getAllSeasonPasses()
+          : _db.getSeasonPassesForUser(user.id);
       return Response.ok(
         json.encode(passes),
         headers: {'Content-Type': 'application/json'},
       );
     } catch (e) {
+      print('[SeasonPass] Erreur au listage: $e');
       return Response.internalServerError(
-        body: json.encode({'error': 'Erreur: $e'}),
+        body: json.encode({'error': 'Erreur interne'}),
         headers: {'Content-Type': 'application/json'},
       );
     }
@@ -59,10 +71,20 @@ class SeasonPassesApi {
 
       // Récupérer l'utilisateur depuis le contexte
       final user = request.context['user'] as User?;
-      final userId = user?.id ?? 'admin'; // fallback
+      if (user == null) {
+        return Response(
+          401,
+          body: json.encode({'error': 'Authentification requise'}),
+          headers: {'Content-Type': 'application/json'},
+        );
+      }
 
-      // Vérifier si un season pass identique existe déjà
-      final existing = _db.getAllSeasonPasses();
+      // 'exact' par défaut : « Journal » ne doit pas capturer tous les
+      // programmes qui contiennent le mot. 'contains' reste disponible.
+      final matchMode = data['match_mode'] == 'contains' ? 'contains' : 'exact';
+
+      // Vérifier si un season pass identique existe déjà pour cet utilisateur
+      final existing = _db.getSeasonPassesForUser(user.id);
       final duplicate = existing.any(
         (p) =>
             (p['show_title'] as String).toLowerCase() ==
@@ -78,10 +100,11 @@ class SeasonPassesApi {
       }
 
       final pass = _db.createSeasonPass(
-        userId: userId,
+        userId: user.id,
         showTitle: showTitle,
         channelId: channelId,
         streamUrl: streamUrl,
+        matchMode: matchMode,
       );
 
       print('[SeasonPass] Créé: "$showTitle" sur chaîne $channelId');
@@ -101,14 +124,30 @@ class SeasonPassesApi {
   /// DELETE /api/season-passes/<id> — supprimer un season pass
   Response handleDelete(Request request, String id) {
     try {
+      final user = request.context['user'] as User?;
+      final pass = _db.getSeasonPassById(id);
+      if (pass == null) {
+        return Response.notFound(
+          json.encode({'error': 'Season Pass non trouvé'}),
+          headers: {'Content-Type': 'application/json'},
+        );
+      }
+      // Contrôle de propriété : seul le propriétaire ou un admin supprime.
+      if (user == null || (!user.isAdmin && pass['user_id'] != user.id)) {
+        return Response.forbidden(
+          json.encode({'error': 'Accès refusé'}),
+          headers: {'Content-Type': 'application/json'},
+        );
+      }
       _db.deleteSeasonPass(id);
       return Response.ok(
         json.encode({'message': 'Season Pass supprimé'}),
         headers: {'Content-Type': 'application/json'},
       );
     } catch (e) {
+      print('[SeasonPass] Erreur à la suppression: $e');
       return Response.internalServerError(
-        body: json.encode({'error': 'Erreur: $e'}),
+        body: json.encode({'error': 'Erreur interne'}),
         headers: {'Content-Type': 'application/json'},
       );
     }

bin/api/users_handler.dart

@@ -65,6 +65,13 @@ class UsersHandler {
         }), headers: {'Content-Type': 'application/json'},);
       }
 
+      if (password.length < 8) {
+        return Response.badRequest(body: jsonEncode({
+          'success': false,
+          'error': 'Le mot de passe doit faire au moins 8 caractères',
+        }), headers: {'Content-Type': 'application/json'},);
+      }
+
       if (db.findUserByUsername(username) != null) {
          return Response.badRequest(body: jsonEncode({
           'success': false,
@@ -103,6 +110,13 @@ class UsersHandler {
         }), headers: {'Content-Type': 'application/json'},);
       }
 
+      if (password.length < 8) {
+        return Response.badRequest(body: jsonEncode({
+          'success': false,
+          'error': 'Le mot de passe doit faire au moins 8 caractères',
+        }), headers: {'Content-Type': 'application/json'},);
+      }
+
       db.updateUserPassword(id, password);
       return Response.ok(jsonEncode({'success': true}), headers: {'Content-Type': 'application/json'});