from flask import Flask, render_template, request, redirect, url_for, flash, jsonify, send_from_directory from flask_sqlalchemy import SQLAlchemy import os import requests from urllib.parse import urlparse import logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) app = Flask(__name__) app.secret_key = os.environ.get('FLASK_SECRET_KEY', 'une_cle_secrete_par_defaut_pour_dev') app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://Podcast_owner:npg_gFdMDLO9lVa0@ep-delicate-surf-a4v7wopn-pooler.us-east-1.aws.neon.tech/Podcast?sslmode=require' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) AUDIO_CACHE_DIR = '/tmp/audio_cache' try: os.makedirs(AUDIO_CACHE_DIR, exist_ok=True) logger.info(f"Répertoire de cache audio configuré sur : {AUDIO_CACHE_DIR}") except OSError as e: logger.error(f"Impossible de créer le répertoire de cache audio à {AUDIO_CACHE_DIR}: {e}") class Podcast(db.Model): __tablename__ = 'podcast' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(200), nullable=False) url = db.Column(db.String(500), nullable=False, unique=True) subject = db.Column(db.String(100), nullable=False) filename_cache = db.Column(db.String(255), nullable=True) def __repr__(self): return f'' @app.route('/') def index(): try: podcasts = Podcast.query.order_by(Podcast.name).all() except Exception as e: logger.error(f"Erreur lors de la récupération des podcasts: {e}") flash("Erreur lors du chargement des podcasts depuis la base de données.", "error") podcasts = [] return render_template('index.html', podcasts=podcasts) @app.route('/gestion', methods=['GET', 'POST']) def gestion(): if request.method == 'POST': name = request.form.get('name') url = request.form.get('url') subject = request.form.get('subject') if not name or not url or not subject: flash('Tous les champs sont requis !', 'error') else: existing_podcast = Podcast.query.filter_by(url=url).first() if existing_podcast: flash('Un podcast avec cette URL existe déjà.', 'warning') else: try: new_podcast = Podcast(name=name, url=url, subject=subject) db.session.add(new_podcast) db.session.commit() flash('Podcast ajouté avec succès !', 'success') return redirect(url_for('gestion')) except Exception as e: db.session.rollback() logger.error(f"Erreur lors de l'ajout du podcast: {e}") flash(f"Erreur lors de l'ajout du podcast: {e}", 'error') try: podcasts = Podcast.query.order_by(Podcast.name).all() except Exception as e: logger.error(f"Erreur lors de la récupération des podcasts pour la gestion: {e}") flash("Erreur lors du chargement des podcasts pour la gestion.", "error") podcasts = [] return render_template('gestion.html', podcasts=podcasts) @app.route('/delete_podcast/', methods=['POST']) def delete_podcast(podcast_id): try: podcast_to_delete = db.session.get(Podcast, podcast_id) if not podcast_to_delete: flash('Podcast non trouvé.', 'error') return redirect(url_for('gestion')) if podcast_to_delete.filename_cache: cached_file_path = os.path.join(AUDIO_CACHE_DIR, podcast_to_delete.filename_cache) if os.path.exists(cached_file_path): try: os.remove(cached_file_path) logger.info(f"Fichier cache {podcast_to_delete.filename_cache} supprimé.") except OSError as e: logger.error(f"Erreur lors de la suppression du fichier cache {podcast_to_delete.filename_cache}: {e}") flash(f'Erreur lors de la suppression du fichier cache {podcast_to_delete.filename_cache}.', 'error') db.session.delete(podcast_to_delete) db.session.commit() flash('Podcast supprimé avec succès.', 'success') except Exception as e: db.session.rollback() logger.error(f"Erreur lors de la suppression du podcast ID {podcast_id}: {e}") flash(f"Erreur lors de la suppression du podcast: {e}", 'error') return redirect(url_for('gestion')) @app.route('/play/') def play_podcast_route(podcast_id): podcast = db.session.get(Podcast, podcast_id) if not podcast: logger.warning(f"Tentative de lecture d'un podcast non trouvé: ID {podcast_id}") return jsonify({'error': 'Podcast non trouvé'}), 404 if podcast.filename_cache: cached_filepath = os.path.join(AUDIO_CACHE_DIR, podcast.filename_cache) if os.path.exists(cached_filepath): logger.info(f"Service du podcast {podcast.id} depuis le cache: {podcast.filename_cache}") audio_url = url_for('serve_cached_audio', filename=podcast.filename_cache) return jsonify({'audio_url': audio_url}) else: logger.warning(f"Fichier cache {podcast.filename_cache} pour podcast {podcast.id} non trouvé. Re-téléchargement.") podcast.filename_cache = None final_cached_filepath = None try: parsed_url = urlparse(podcast.url) path_parts = os.path.splitext(parsed_url.path) extension = path_parts[1] if path_parts[1] else '.audio' base_filename = str(podcast.id) logger.info(f"Téléchargement de {podcast.url} pour le podcast ID {podcast.id}") response = requests.get(podcast.url, stream=True, timeout=(10, 60)) response.raise_for_status() content_type = response.headers.get('Content-Type') if content_type: if 'mpeg' in content_type: extension = '.mp3' elif 'ogg' in content_type: extension = '.ogg' elif 'wav' in content_type: extension = '.wav' elif 'aac' in content_type: extension = '.aac' elif 'mp4' in content_type: extension = '.m4a' cached_filename_with_ext = f"{base_filename}{extension}" final_cached_filepath = os.path.join(AUDIO_CACHE_DIR, cached_filename_with_ext) with open(final_cached_filepath, 'wb') as f: for chunk in response.iter_content(chunk_size=8192): f.write(chunk) logger.info(f"Téléchargement terminé: {final_cached_filepath}") podcast.filename_cache = cached_filename_with_ext db.session.commit() audio_url = url_for('serve_cached_audio', filename=cached_filename_with_ext) return jsonify({'audio_url': audio_url}) except requests.exceptions.Timeout: logger.error(f"Timeout lors du téléchargement de {podcast.url}") return jsonify({'error': 'Le téléchargement du podcast a pris trop de temps.'}), 504 except requests.exceptions.RequestException as e: logger.error(f"Erreur de téléchargement pour {podcast.url}: {e}") return jsonify({'error': f'Impossible de télécharger le podcast: {e}'}), 500 except Exception as e: db.session.rollback() logger.error(f"Erreur inattendue lors du traitement du podcast {podcast.id}: {e}") return jsonify({'error': f'Erreur inattendue: {e}'}), 500 finally: if final_cached_filepath and os.path.exists(final_cached_filepath) and (not podcast or podcast.filename_cache != os.path.basename(final_cached_filepath)): try: os.remove(final_cached_filepath) logger.info(f"Fichier partiel nettoyé : {final_cached_filepath}") except OSError as e_clean: logger.error(f"Erreur lors du nettoyage du fichier partiel {final_cached_filepath}: {e_clean}") @app.route('/audio_cache/') def serve_cached_audio(filename): logger.debug(f"Service du fichier cache: {filename} depuis {AUDIO_CACHE_DIR}") return send_from_directory(AUDIO_CACHE_DIR, filename) if __name__ == '__main__': with app.app_context(): try: db.create_all() logger.info("Tables de base de données vérifiées/créées (si elles n'existaient pas).") except Exception as e: logger.error(f"Erreur lors de la création des tables de la base de données: {e}") logger.error("Assurez-vous que votre serveur PostgreSQL est en cours d'exécution et que la base de données existe.") app.run(debug=True, host='0.0.0.0', port=int(os.environ.get('PORT', 5000)))