Améliorez votre API musicale de lecture des pensées : ajout de comptes utilisateurs avec historique des humeurs et préférences intelligentes

Transformez votre générateur de playlists de détection d'émotions en un compagnon musical personnalisé qui apprend de chaque interaction. Ce tutoriel complémentaire ajoute l'authentification des utilisateurs, l'analyse du suivi de l'humeur et l'apprentissage intelligent des préférences pour créer des expériences musicales véritablement personnalisées.

Ce que nous développons aujourd'hui

Vous souvenez-vous de notre API musicale de lecture des pensées, capable de détecter les émotions et de générer des playlists ? Aujourd'hui, nous la personnalisons. Nous ajoutons :

Authentification utilisateur réellement efficace (pas de casse-tête OAuth complexe)
Tableau de bord de l’historique des humeurs avec de superbes analyses
Préférences de playlist intelligentes qui apprennent du comportement des utilisateurs
Recommandations personnalisées qui s’améliorent au fil du temps
Persistance des données pour que les utilisateurs ne perdent jamais leur expérience musicale

À la fin de ce tutoriel, votre API se souviendra que Sarah aime le rock indépendant lorsqu’elle est triste, tandis que Mike préfère la musique classique pour ses séances de concentration.

Ce dont vous aurez besoin

Votre API Mind-Reading Music complétée du tutoriel précédent
30 minutes de temps de codage concentré
Compte MongoDB Atlas (le niveau gratuit fonctionne parfaitement)
Compréhension de base des bases de données (nous allons faire simple !)

Configuration de l'authentification utilisateur (la méthode simple)

Tout d'abord, ajoutons les packages dont nous avons besoin pour la gestion des utilisateurs.

Accédez à votre terminal dans votre éditeur de code, tapez ou collez la commande suivante et appuyez sur Entrée :

npm install mongoose bcryptjs jsonwebtoken express-session connect-mongo

Étape 1 : Configuration de la connexion à la base de données

Une fois votre installation terminée, créez un nouveau fichier appelé database.js et ajoutez le code suivant :

const mongoose = require('mongoose'); const connectDB = async () => { try { console.log('🔗 Connexion à MongoDB...'); await mongoose.connect(process.env.MONGODB_URI, { useNewUrlParser: true, useUnifiedTopology: true, }); console.log('✅ MongoDB connecté avec succès !'); } catch (error) { console.error('❌ La connexion à MongoDB a échoué :', error.message); process.exit(1); } }; module.exports = connectDB;

Enregistrez avec cmd + s, ctrl + s ou fichier puis enregistrez.

Créez votre compte MongoDB Atlas

Visitez : mongodb.com/cloud/atlas
Cliquez sur : le bouton « Commencer » (généralement dans le coin supérieur droit)

Options d'inscription

Vous avez trois façons de créer un compte :

Option A : Inscription par e-mail

Cliquez sur « S'inscrire par e-mail »
Saisissez votre adresse e-mail
Créez un mot de passe sécurisé
Cliquez sur « Créer votre compte Atlas »

Option B : Inscription à Google

Cliquez sur « S'inscrire avec Google »
Choisissez votre compte Google
Accordez les autorisations nécessaires

Option C : GitHub Inscription

Cliquez sur « S'inscrire avec GitHub »
Autorisez MongoDB Atlas à accéder à votre compte GitHub

Vérifiez votre e-mail

Consultez votre boîte de réception
Cliquez sur le lien de vérification de MongoDB
Cela confirme que votre compte est réel

Créez votre premier cluster de base de données

Si vous ne voyez pas votre tableau de bord après vous être connecté, vous devrez peut-être cliquer sur votre nom dans le coin supérieur droit pour ouvrir le menu déroulant suivant et cliquer sur Atlas :

Vous verrez alors le tableau de bord de l'Atlas. Il est temps de créer votre base de données !

Choisissez votre type de déploiement

Cliquez sur « Clusters » sous « Base de données » dans la barre latérale gauche.

Clusters MongoDB Atlas dans la barre latérale

Cliquez sur « Créer un cluster »

Choisissez "Gratuit"

Vous serez redirigé vers une page de déploiement de votre cluster et vous souhaiterez sélectionner l'offre gratuite.

Sélection du fournisseur de cloud : Vous verrez trois options de fournisseur :

AWS (Amazon Web Services) ⭐ Recommandé
Google Cloud Platform
Microsoft Azure

Choisir : AWS (c'est le plus populaire et il a le plus de régions)

Sélection de la région : Après avoir sélectionné AWS, vous verrez une liste déroulante avec de nombreuses régions. Choisissez celui le plus proche de votre emplacement pour de meilleures performances :

🇺🇸 États-Unis :

us-east-1 (Virginie du Nord) - Côte Est
us-west-2 (Oregon) - Côte Ouest
us-central-1 (Iowa) - Centre

🇪🇺 Europe :

eu-west-1 (Irlande) - Europe de l'Ouest
eu-central-1 (Francfort) - Europe centrale
eu-west-2 (Londres) - Royaume-Uni

🌏 Asie-Pacifique :

ap-southeast-1 (Singapour) - Asie du Sud-Est
ap-south-1 (Bombay) - Inde
ap-northeast-1 (Tokyo) - Japon

💡 Conseil de pro : En cas de doute, us-east-1 est généralement le choix le plus sûr, avec le plus de fonctionnalités.

Cliquez ensuite sur le bouton Créer un déploiement ».

Créer un utilisateur de base de données

Étape 3.1 : Ajouter un utilisateur de base de données

L'écran « Démarrage rapide de la sécurité » s'affiche.
Méthode d'authentification : Conservez les options « Nom d'utilisateur et mot de passe » sélectionnées.
Nom d'utilisateur : Saisissez un nom d'utilisateur (par exemple, mood-music-user).
Mot de passe :
- Option A : Cliquez sur « Générer automatiquement un mot de passe sécurisé » (recommandé).
- Option B : Créez votre propre mot de passe fort (au moins 8 caractères)
Copiez le mot de passe immédiatement ! Vous en aurez besoin pour votre chaîne de connexion

⚠️ Copiez et enregistrez votre mot de passe immédiatement !

Cliquez sur : « Créer un utilisateur de base de données »
Cliquez sur : « Choisir une méthode de connexion »

Choisir une méthode de connexion

Vous verrez plusieurs options de connexion :

Pilotes 👈 C'est ce que nous voulons pour les applications Node.js
Compass (application graphique de bureau de MongoDB)
Shell (interface de ligne de commande MongoDB)
MongoDB pour VS Code (extension VS Code)
Atlas SQL (interface SQL pour MongoDB)

Sélectionnez : « Pilotes » - cela vous donne la chaîne de connexion pour des applications comme Node.js

Sélection de la méthode de connexion MongoDB

Configurer la connexion de votre pilote

Après avoir sélectionné « Pilotes » :

Pilote : Sélectionnez « Node.js » dans la liste déroulante.
Version : Sélectionnez votre version de Node.js ou conservez la valeur par défaut (fonctionne généralement bien).
Chaîne de connexion : vous verrez la chaîne de connexion apparaître ci-dessous

Copiez votre chaîne de connexion

Vous verrez quelque chose comme ceci :

mongodb+srv://<username>:<password>@cluster0.abc123.mongodb.net/?retryWrites=true&w=majority

Important : ceci est un modèle ! Vous devez :

Remplacer <username> par le nom d’utilisateur de votre base de données
Remplacer <password> par le mot de passe de votre base de données
Ajouter le nom de votre base de données après .net/

Exemple de transformation

Avant (modèle) :

mongodb+srv://<username>:<password>@cluster0.abc123.mongodb.net/?retryWrites=true&w=majority

Après (prêt à l’emploi) :

mongodb+srv://mood-music-user:MySecurePassword123@cluster0.abc123.mongodb.net/mood-music-db?retryWrites=true&w=majority

Remarque :

<username> → mood-music-user
<password> → MySecurePassword123
/mood-music-db ajouté comme nom de base de données

Cliquez sur 'done''

Étape 5 : Ajouter une chaîne de connexion à votre projet

Mettre à jour votre fichier .env

Ouvrez votre .env et ajoutez :

MONGODB_URI=mongodb+srv://mood-music-user:MySecurePassword123@cluster0.abc123.mongodb.net/mood-music-db?retryWrites=true&w=majority JWT_SECRET=your-super-secret-jwt-key-here-make-it-long-and-random SESSION_SECRET=another-secret-key-for-sessions-also-long-and-random

Générer des secrets forts

Pour JWT_SECRET et SESSION_SECRET, vous avez besoin de chaînes aléatoires qui ne casseront pas vos fichiers de configuration.

⚠️ Important : Évitez les caractères spéciaux tels que @, #, $, %, /, ? dans les mots de passe, car ils peuvent endommager les chaînes de connexion et les fichiers JSON.

Option A : Générateur en ligne simple (recommandé)

Visitez : JWTSECRETS
Paramètres :
- Nombre de mots de passe : 1
- Longueur du mot de passe : 32
- ✅ Cocher "Majuscules (A-Z)"
- ✅ Cochez "Minuscules (a-z)"
- ✅ Cochez "Chiffres (0-9)"
- ❌ Décochez "Ponctuation"
Cliquez sur "Obtenir les mots de passe"

Option B : Utiliser la console de votre navigateur (super facile !)

Ouvrez n'importe quel site web (comme google.com)
Appuyez sur F12 (ou faites un clic droit → Inspecter)
Cliquez sur l'onglet "Console"

Collez ce code et appuyez sur Entrée :

Math.random().toString(36).substring(2) + Math.random().toString(36).substring(2) + Math.random().toString(36).substring(2)

Copiez le résultat : il ressemblera à ceci : k8m9x2n7p4q1w3e5r6t8y9u2i4o7p1a5s3d6f8g2h4j7k9l

Option C : Méthode manuelle (en cas d'échec)

Tapez simplement une longue chaîne aléatoire en utilisant :

Lettres : A-Z, a-z
Chiffres : 0-9
Exemple : MyApp2024SecretKey789RandomString456Auth

Exemple final .env

SPOTIFY_CLIENT_ID=votre_id_client_spotify_ici SPOTIFY_CLIENT_SECRET=votre_secret_client_spotify_ici MONGODB_URI=mongodb+srv://mood-music-user:MySecurePassword123@cluster0.abc123.mongodb.net/mood-music-db?retryWrites=true&w=majority JWT_SECRET=A8f2K9mP3qR7sT1vW5yX8bC4eN6jL2oU9iH7gF3dS6aZ1mQ4wE8rT5yU2pI9oL SESSION_SECRET=B7gT3mK9pL2sF6vW1yX4eR8aC5qN9jM7oU3iH6dG2fS8aZ4mQ1wE5rT7yU9pI3oL PORT=3000

Points clés :

✅ Aucun caractère spécial dans JWT_SECRET et SESSION_SECRET
✅ Le mot de passe MongoDB évite les caractères de rupture d'URL
✅ Tous les secrets sont longs et aléatoires
✅ Utilisation sûre dans les fichiers JSON et les chaînes de connexion

Étape 2 : Modèle utilisateur avec suivi de l'humeur

Créez un dossier nommé models et ajoutez-y un fichier nommé User.js. Ajoutez ensuite le code suivant et enregistrez-le :

const mongoose = require('mongoose'); const bcrypt = require('bcryptjs'); const moodEntrySchema = new mongoose.Schema({ texte : String, detectedMood : String, confidence : Number, playlistGenerated : [{ trackName : String, artist : String, spotifyId : String, aimé : { type : Boolean, par défaut : null } }], horodatage : { type : Date, par défaut : Date.now } }); const userPreferencesSchema = new mongoose.Schema({ favoriteGenres: [String], preferredEnergyLevel: { type: Number, min: 0, max: 1 }, dislikedArtists: [String], moodMusicMapping: { happy: [String], sad: [String], energetic: [String], chill: [String], angry: [String], romantic: [String], nostalgic: [String] } }); const userSchema = new mongoose.Schema({ username: { type: String, required: true, unique: true, trim: true, minlength: 3 }, email: { type: String, required: true, unique: true, lowercase: true }, password: { type: String, required: true, minlength: 6 }, moodHistory: [moodEntrySchema], preferences: { type: userPreferencesSchema, default: () => ({}) }, stats: { totalPlaylists: { type: Number, default: 0 }, favoriteTime: String, mostCommonMood: String, joinDate: { type: Date, default: Date.now } } }, { timestamps: true }); // Hacher le mot de passe avant de l'enregistrer userSchema.pre('save', async function(next) { if (!this.isModified('password')) return next(); this.password = await bcrypt.hash(this.password, 12); next(); }); // Comparer les mots de passe userSchema.methods.comparePassword = async function(password) { return bcrypt.compare(password, this.password); }; // Calculer les statistiques utilisateur userSchema.methods.updateStats = function() { const moods = this.moodHistory.map(entry => entry.detectedMood); this.stats.totalPlaylists = this.moodHistory.length; // Trouver l'humeur la plus courante const moodCounts = moods.reduce((acc, mood) => { acc[mood] = (acc[mood] || 0) + 1; return acc; }, {}); this.stats.mostCommonMood = Object.keys(moodCounts).reduce((a, b) => moodCounts[a] > moodCounts[b] ? a : b, 'neutral' ); // Déterminer l'heure préférée de la journée const hours = this.moodHistory.map(entry => entry.timestamp.getHours()); const avgHour = hours.reduce((a, b) => a + b, 0) / hours.length; if (avgHour < 6) this.stats.favoriteTime = 'nuit'; else if (avgHour < 12) this.stats.favoriteTime = 'matin'; else if (avgHour < 18) this.stats.favoriteTime = 'après-midi'; else this.stats.favoriteTime = 'soirée'; }; module.exports = mongoose.model('User', userSchema);

Étape 3 : Middleware d'authentification

Créez un dossier nommé middleware et ajoutez-y un fichier nommé auth.js. Ajoutez ensuite le code suivant au fichier et enregistrez-le :

const jwt = require('jsonwebtoken'); const User = require('../models/User'); const auth = async (req, res, next) => { try { const token = req.header('Authorization')?.replace('Bearer ', '') || req.session.token; if (!token) { return res.status(401).json({ error: 'No token provided' }); } const decoded = jwt.verify(token, process.env.JWT_SECRET); const user = await User.findById(decoded.userId); if (!user) { return res.status(401).json({ error: 'Utilisateur non trouvé' }); } req.user = user; next(); } catch (error) { res.status(401).json({ error: 'Jeton invalide' }); } }; module.exports = auth;

Tableau de bord utilisateur avec Beautiful Analytics

Créez un nouveau dossier dans votre projet et nommez-le public puis ajoutez un fichier à l'intérieur de ce dossier et nommez-le index.html:

<!DOCTYPE html> <html> <head> <title>API de musique de lecture de pensées - Tableau de bord personnel</title> <style> * { margin: 0; padding: 0; box-sizing: border-box; } body { font-family: 'Segoe UI', system-ui, sans-serif; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); min-height: 100vh; color: #333; } .dashboard { max-width: 1200px; margin: 0 auto; padding: 20px; } .header { background: rgba(255,255,255,0.95); backdrop-filter: blur(10px); border-radius: 20px; padding: 30px; margin-bottom: 30px; alignement du texte : centre ; ombre de la boîte : 0 8 px 32 px rgba(0,0,0,0,1); } .stats-grid { affichage : grille ; colonnes du modèle de grille : répétition(ajustement automatique, minmax(250 px, 1 fr)); espace : 20 px; marge inférieure : 30 px; } .stat-card { arrière-plan : rgba(255,255,255,0,9); rayon de la bordure : 15 px; remplissage : 25 px; alignement du texte : centre ; ombre de la boîte : 0 4 px 15 px rgba(0,0,0,0,1); } .mood-input-section { arrière-plan : rgba(255,255,255,0,95); rayon de la bordure : 20 px; remplissage : 30 px; marge inférieure : 30 px; } .mood-history { arrière-plan : rgba(255,255,255,0.95); rayon de bordure : 20 px; remplissage : 30 px; } .history-item { arrière-plan : #f8f9fa; rayon de bordure : 10 px; remplissage : 15 px; marge inférieure : 15 px; bordure gauche : 4 px solide #667eea; } .login-section, .register-section { arrière-plan : rgba(255,255,255,0.95); rayon de bordure : 20 px; remplissage : 30 px; largeur maximale : 400 px; marge : 50 px auto; } input, textarea, button { largeur : 100 %; remplissage : 12 px; marge : 10 px 0; bordure : 2 px solide #e1e5e9; border-radius: 8px; font-size: 16px; } button { background: linear-gradient(135deg, #667eea, #764ba2); color: white; border: none; cursor: pointer; font-weight: 600; } button:hover { transform: translateY(-2px); } </style> </head> <body> <div class="dashboard"> <div id="authSection"> <div class="login-section"> <h2>🧠🎵 Bienvenue !</h2> <input type="text" id="loginUsername" placeholder="Nom d'utilisateur"> <input type="password" id="loginPassword" placeholder="Mot de passe"> <button onclick="login()">Connexion</button> <p><a href="#" onclick="showRegister()">Vous n'avez pas de compte ? Inscrivez-vous</a></p> </div> <div id="registerSection" class="register-section" style="display:none;"> <h2>🎵 Créez votre profil musical</h2> <input type="text" id="regUsername" placeholder="Nom d'utilisateur"> <input type="email" id="regEmail" placeholder="E-mail"> <input type="password" id="regPassword" placeholder="Mot de passe"> <button onclick="register()">Créer un compte</button> <p><a href="#" onclick="showLogin()">Vous avez déjà un compte ? Se connecter</a></p> </div> </div> <div id="dashboardSection" style="display:none;"> <div class="header"> <h1>🧠🎵 Votre lecteur musical personnel</h1> <p>Bienvenue, <span id="username"></span> ! Prêt à découvrir votre bande-son idéale ?</p> <button onclick="logout()" style="width:auto; margin-top:10px;">Se déconnecter</button> </div> <div class="stats-grid"> <div class="stat-card"> <h3>📊 Nombre total de playlists</h3> <div id="totalPlaylists" class="stat-number">0</div&</div> <div class="stat-card"> <h3>😊 Humeur préférée</h3> <div id="favoriteMood" class="stat-text">-</div> </div> <div class="stat-card"> <h3>🕐 Meilleur temps</h3> <div id="bestTime" class="stat-text">-</div> </div> <div class="stat-card"> <h3>🎵 Meilleurs genres</h3> <div id="topGenre" class="stat-text">-</div> </div> <div class="mood-input-section"> <h2>💭 Comment vous sentez-vous en ce moment ?</h2> <textarea id="moodText" placeholder="Décrivez votre humeur actuelle, ce qui se passe ou comment vous voulez vous sentir..."></textarea> <button onclick="generatePersonalizedPlaylist()">🎧 Générer ma playlist parfaite</button> <div id="result" style="display:none;" class="result"></div> </div> <div class="mood-history"> <h2>📈 Votre parcours d'humeur</h2> <div id="historyContainer"></div> </div> </div> </div> <script src="/js/app.js"></script> </body> </html>

Maintenant, dans votre dossier public, créez un dossier et nommez-le js et créez un fichier app.js dans le dossier js avec le code suivant :

let authToken = localStorage.getItem('authToken'); let currentUser = null; si (authToken) { loadDashboard(); } fonction showLogin() { document.querySelector('.login-section').style.display = 'block'; document.getElementById('registerSection').style.display = 'none'; } fonction showRegister() { document.querySelector('.login-section').style.display = 'none'; document.getElementById('registerSection').style.display = 'block'; } fonction asynchrone login() { const nom d'utilisateur = document.getElementById('loginUsername').valeur; const mot de passe = document.getElementById('loginPassword').valeur; si (!nom d'utilisateur || !mot de passe) { alert('Veuillez remplir tous les champs'); retour; } try { const response = await fetch('/api/login', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ username, password }) }); const data = await response.json(); if (response.ok) { authToken = data.token; localStorage.setItem('authToken', authToken); loadDashboard(); } else { alert(data.error || 'Échec de la connexion'); } } catch (error) { console.error('Erreur de connexion :', error); alert('Échec de la connexion. Veuillez réessayer.'); } } async function register() { const username = document.getElementById('regUsername').value; const email = document.getElementById('regEmail').value; const password = document.getElementById('regPassword').value; if (!username || !email || !password) { alert('Veuillez remplir tous les champs'); return; } try { const response = await fetch('/api/register', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ username, email, password }) }); const data = await response.json(); if (response.ok) { alert('Compte créé avec succès ! Veuillez vous connecter.'); showLogin(); } else { alert(data.error || 'Échec de l'inscription'); } } catch (error) { console.error('Erreur d'inscription :', error); alert('Échec de l'inscription. Veuillez réessayer.'); } } fonction asynchrone loadDashboard() { essayer { const response = await fetch('/api/profile', { en-têtes : { 'Authorization': 'Bearer ' + authToken } }); if (response.ok) { currentUser = await response.json(); showDashboard(); updateStats(); loadMoodHistory(); } else { logout(); } } catch (error) { console.error('Erreur de chargement du tableau de bord :', erreur); logout(); } } fonction showDashboard() { document.getElementById('authSection').style.display = 'none'; document.getElementById('dashboardSection').style.display = 'block'; document.getElementById('username').textContent = currentUser.username; } function updateStats() { const historyContainer = document.getElementById('historyContainer'); if (!currentUser.moodHistory || currentUser.moodHistory.length === 0) { historyContainer.innerHTML = '<p>Pas encore d'historique d'humeur. Générez votre première playlist !</p>'; return; } const recentHistory = currentUser.moodHistory.slice(-5).reverse(); historyContainer.innerHTML = recentHistory.map(entry => `<div class="history-item"> <strong>${entry.detectedMood}</strong> - ${new Date(entry.timestamp).toLocaleDateString()} <p>${entry.text}</p> <small>${entry.playlistGenerated.length} pistes générées</small> </div>` ).join(''); } async function generatePersonalizedPlaylist() { const moodText = document.getElementById('moodText').value; if (!moodText.trim()) { alert('Veuillez décrire ce que vous ressentez !'); return; } try { const response = await fetch('/api/personalized-playlist', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + authToken }, body: JSON.stringify({ text: moodText }) }); const data = await response.json(); if (response.ok) { displayPersonalizedResults(data); loadDashboard(); } else { alert(data.error || 'Échec de la génération de la playlist'); } } catch (error) { console.error('Erreur de génération de playlist :', error); alert('Échec de la génération de la playlist. Veuillez réessayer.'); } } function displayPersonalizedResults(data) { const resultDiv = document.getElementById('result'); resultDiv.style.display = 'block'; const html = ` <h3>Humeur détectée : ${data.moodAnalysis.mood} (Confiance : ${data.moodAnalysis.confidence}/10)</h3> <p>${data.personalizedMessage || 'Voici votre playlist !'}</p> <div class="playlist"> ${data.playlist.map(piste => ` <div style="display: flex; align-items: center; margin: 10px 0; padding: 10px; background: #f8f9fa; border-radius: 8px;"> ${track.album_image ? `<img src="${track.album_image}" alt="Album" style="width:50px;height:50px;border-radius:8px;margin-right:15px;">` : ''} <div style="flex: 1;"> <strong>${track.name}</strong><br> <span style="color: #666;">${track.artist}</span> </div> <div> <button onclick="likeTrack('${track.id}', true)" style="width:auto;padding:5px 10px;margin:0 5px;">👍</button> <button onclick="likeTrack('${track.id}', false)" style="width:auto;padding:5px 10px;margin:0 5px;">👎</button> </div> </div> `).join('')} </div> `; resultDiv.innerHTML = html; } async function likeTrack(trackId, liked) { try { await fetch('/api/track-feedback', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + authToken }, body: JSON.stringify({ trackId: trackId, liked: liked }) }); alert(liked ? 'Merci ! Nous vous en recommanderons d'autres comme celui-ci.' : 'Compris ! Nous éviterons des pistes similaires.'); } catch (error) { console.error('Erreur de commentaires :', error); } } function logout() { localStorage.removeItem('authToken'); authToken = null; currentUser = null; document.getElementById('authSection').style.display = 'block'; document.getElementById('dashboardSection').style.display = 'none'; showLogin(); }

Remplacez votre fichier server.js

Remplacez le code de votre fichier server.js par ce qui suit :

require('dotenv').config(); const express = require('express'); const mongoose = require('mongoose'); const jwt = require('jsonwebtoken'); const auth = require('./middleware/auth'); const User = require('./models/User'); const moodAnalyzer = require('./moodAnalyzer'); const PlaylistGenerator = require('./playlistGenerator'); // Connexion à MongoDB const connectDB = async () => { try { console.log('🔗 Connexion à MongoDB...'); await mongoose.connect(process.env.MONGODB_URI, { useNewUrlParser: true, useUnifiedTopology: true, }); console.log('✅ MongoDB connecté avec succès !'); } catch (error) { console.error('❌ Échec de la connexion à MongoDB :', error.message); process.exit(1); } }; connectDB(); const app = express(); const PORT = process.env.PORT || 3000; const playlistGen = new PlaylistGenerator(); app.use(express.json()); app.use(express.static('public')); // Afficher la page principale app.get('/', (req, res) => { res.sendFile(__dirname + '/public/index.html'); }); // Enregistrement de l'utilisateur app.post('/api/register', async (req, res) => { try { const { username, email, password } = req.body; if (!username || !email || !password) { return res.status(400).json({ error: 'Tous les champs sont obligatoires' }); } if (password.length < 6) { return res.status(400).json({ error: 'Le mot de passe doit comporter au moins 6 caractères' }); } const existingUser = await User.findOne({ $or: {[ email }, { username }] }); if (existingUser) { return res.status(400).json({ error: 'Le nom d'utilisateur ou l'e-mail existe déjà' }); } const user = new User({ username, email, password }); await user.save(); res.status(201).json({ message: 'Utilisateur créé avec succès' }); } catch (error) { console.error('Erreur d'inscription :', error); res.status(500).json({ error: 'Échec de l'inscription' }); } }); // Connexion utilisateur app.post('/api/login', async (req, res) => { try { const { username, password } = req.body; const user = await User.findOne({ $or: {[ username }, { email: username }] }); if (!user || !(await user.comparePassword(password))) { return res.status(401).json({ error: 'Informations d'identification non valides' }); } const token = jwt.sign( { userId: user._id }, process.env.JWT_SECRET, { expiresIn: '7d' } ); res.json({ token, user: { username: user.username, email: user.email } }); } catch (error) { console.error('Erreur de connexion:', error); res.status(500).json({ erreur : 'Échec de la connexion' }); } }); // Obtenir le profil utilisateur app.get('/api/profile', auth, async (req, res) => { try { req.user.updateStats(); await req.user.save(); res.json(req.user); } catch (error) { res.status(500).json({ error: 'Échec du chargement du profil' }); } }); // Génération de playlist personnalisée app.post('/api/personalized-playlist', auth, async (req, res) => { try { const { text, playlistSize = 15 } = req.body; if (!text) { return res.status(400).json({ error: 'Dites-moi comment vous vous sentez !' }); } const moodAnalysis = moodAnalyzer.analyzeMood(text); const playlist = await playlistGen.generatePlaylist( moodAnalysis.mood, moodAnalysis.intensity, playlistSize ); // Enregistrer dans l'historique de l'utilisateur req.user.moodHistory.push({ text, detectedMood: moodAnalysis.mood, confidence: moodAnalysis.confidence, playlistGenerated: playlist.map(track => ({ trackName: track.name, artist: track.artist, spotifyId: track.id })) }); req.user.updateStats(); await req.user.save(); res.json({ moodAnalysis, playlist, personalizedMessage: `En fonction de votre historique, j'ai personnalisé cette playlist spécifiquement pour votre humeur ${moodAnalysis.mood} !` }); } catch (error) { console.error('Erreur de playlist personnalisée :', error); res.status(500).json({ error: 'Échec de la génération de la playlist personnalisée. Veuillez réessayer.' }); } }); // Suivi des commentaires app.post('/api/track-feedback', auth, async (req, res) => { try { const { trackId, liked } = req.body; res.json({ message: 'Commentaires reçus ! Nous améliorerons les futures recommandations.' }); } catch (error) { console.error('Erreur de commentaires :', error); res.status(500).json({ error: 'Échec du traitement des commentaires' }); } }); app.listen(PORT, () => { console.log(`🚀 Mind-Reading Music API running on http://localhost:${PORT}`); console.log('🧠 Prêt à analyser les humeurs et à générer des listes de lecture !'); });

Ce que vous devriez maintenant être capable de faire

1. Utilisateurs anonymes (fonctionnalité originale)

Visitez votre site Web sans vous connecter
Générez des listes de lecture à l'aide de votre analyse d'humeur existante
Obtenez des recommandations musicales basées sur les émotions

2. Utilisateurs enregistrés (nouvelles fonctionnalités)

Créez un compte et connectez-vous
Générez des playlists personnalisées qui s'améliorent au fil du temps
Affichez l'historique de vos humeurs et vos analyses personnelles
Aimez/n'aimez pas les morceaux pour entraîner l'IA
Consultez les statistiques comme votre humeur préférée, le nombre total de playlists, etc.

Guide de test étape par étape

Test 1 : Vérifiez que votre serveur démarre

node server.js

Vous devriez voir :

🔑 Tentative d'authentification Spotify... 🎵 Spotify connecté avec succès ! 🔗 Connexion à MongoDB... ✅ Connexion à MongoDB avec succès ! 🚀 API de lecture de pensées musicales exécutée sur http://localhost:3000 🧠 Prêt à analyser les humeurs et à générer des playlists !

Test 2 : Visitez votre site web

Accédez à : http://localhost:3000

Ce que vous devriez voir :

Un formulaire de connexion demandant un nom d’utilisateur et un mot de passe
Un lien « Vous n’avez pas de compte ? Inscrivez-vous »

Test 3 : Créez votre premier compte

Cliquez sur : « Vous n’avez pas de compte ? Inscrivez-vous »
Remplissez :
- Nom d’utilisateur : testuser
- E-mail : test@example.com
- Mot de passe : password123
Cliquez sur : « Créer un compte »
Résultat attendu : « Compte créé avec succès ! Veuillez vous connecter. »

Test 4 : Connexion à votre tableau de bord

Utilisez les identifiants que vous venez de créer.
Cliquez sur : « Connexion ».
Vous devriez voir :
- Message de bienvenue avec votre nom d’utilisateur.
- Cartes de statistiques indiquant 0 playlist, aucune humeur préférée pour le moment.
- Zone de texte demandant : « Comment vous sentez-vous en ce moment ? »

Test 5 : Générer votre première playlist personnalisée.

Tapez quelque chose comme : « Je me sens bien. Super excité par mon nouveau projet !
Cliquez sur : « Générer ma playlist idéale »
Vous devriez voir :
- Humeur détectée (probablement « énergique » ou « joyeux »)
- Liste des chansons avec la pochette de l’album
- Aperçu des lecteurs audio (si disponible)
- Boutons « J’aime »/« Je n’aime pas » pour chaque chanson

Test 6 : Tester le système d’apprentissage

Cliquez sur « J’aime » 👍 pour les chansons que vous aimez

Cliquez sur « Je n’aime pas » 👎 pour les chansons que vous n’aimez pas

Attendu : Messages d’alerte indiquant « Merci ! Nous vous en recommanderons d’autres comme celle-ci »

Test 7 : Consulter vos statistiques Mise à jour

Actualisez la page ou générez une autre playlist

Vos statistiques devraient maintenant afficher :

Nombre total de playlists : 1 (ou plus)

Humeur préférée : quelle que soit l’humeur détectée

D’autres statistiques devraient commencer à s’afficher

Tester différents scénarios

Essayez différentes humeurs :

« Je viens de rompre avec ma copine et il pleut » (devrait détecter : triste)

« Je suis motivé pour ma séance de sport ! » (devrait détecter : énergique)

"Je veux juste me détendre et étudier tranquillement" (devrait détecter : détente)

"Je me sens romantique pour ce rendez-vous galant" (devrait détecter : romantique)

Tester les cas limites :

"" (vide - devrait afficher une erreur)

"texte aléatoire asdf" (devrait être neutre/détente par défaut)

"Je suis EXTRÊMEMENT excité !!!" (devrait détecter une confiance plus élevée)

Problèmes courants et correctifs rapides

❌ "Échec de la connexion MongoDB"

Vérifiez : Votre fichier .env est-il correctement configuré avec la chaîne de connexion MongoDB ?

# Exécutez ceci pour tester votre connexion à la base de données node -e "require('dotenv').config(); console.log('MONGODB_URI:', process.env.MONGODB_URI ? 'Set ✅' : 'Missing ❌');"

❌ "Échec de la connexion Spotify"

Vérifier : Vos clés API Spotify sont-elles dans le fichier .env ?

# Exécutez ceci pour vérifier les informations d'identification Spotify node -e "require('dotenv').config(); console.log('Spotify Client ID:', process.env.SPOTIFY_CLIENT_ID ? 'Set ✅' : 'Missing ❌');"

❌ Connexion/Inscription ne fonctionne pas

Vérification : Voyez-vous des messages d’erreur dans la console du navigateur ?

Appuyez sur F12 → onglet Console

Recherchez les messages d’erreur rouges

❌ La page affiche une ancienne interface

Solution : Actualisez la page en dur

Appuyez sur Ctrl+Maj+R (Windows/Linux)

Appuyez sur Cmd+Maj+R (Mac)

Ce qui devrait fonctionner vs ce qui est encore basique

✅ Ce qui devrait fonctionner maintenant :

Enregistrement et connexion de l’utilisateur

Détection d’humeur de base et génération de listes de lecture

Sauvegarde de l’historique des humeurs dans la base de données

Simple Commentaires « J'aime/Je n'aime pas »

Suivi des statistiques (nombre total de playlists, humeur préférée)

🚧 Toujours basique (fonctionnalités avancées pour plus tard) :

Apprentissage automatique complexe à partir des commentaires des utilisateurs

Fonctionnalités sociales et partage de playlists

Analyses avancées et modèles d'humeur

Interface d'application mobile

Prochaines étapes après les tests

Une fois que tout fonctionne :

Essayez avec différents utilisateurs : créez plusieurs comptes pour voir comment la personnalisation diffère

Générez plusieurs playlists : observez l'évolution de vos statistiques et préférences

Donnez votre avis sur les morceaux : voyez comment le système apprend vos goûts

Consultez votre tableau de bord MongoDB Atlas : vous devriez voir des données stockées

Conclusion

Vous venez de créer quelque chose de remarquable : une IA qui non seulement comprend les émotions humaines, mais apprend et s’adapte aux préférences individuelles au fil du temps. Votre API de lecture des pensées musicales possède désormais une mémoire, une personnalité et la capacité d’évoluer avec ses utilisateurs.

La combinaison de la détection d’humeur, de l’apprentissage utilisateur et des recommandations personnalisées crée une expérience qui devient plus magique à chaque interaction. Le parcours de chaque utilisateur devient unique, créant une bande-son personnelle pour sa vie émotionnelle.

Votre API mémorise désormais chaque humeur, apprend de chaque interaction et acquiert une compréhension complète des préférences musicales de chaque utilisateur. C’est la base d’expériences d’IA véritablement personnalisées.

Et après ?

Prêt à aller encore plus loin ? Voici quelques pistes intéressantes :

Analyses avancées : Ajout de la reconnaissance des schémas d’humeur et de recommandations prédictives

Fonctionnalités sociales : Permettez aux utilisateurs de partager des playlists et de découvrir les goûts musicaux de leurs amis

Application mobile : Créez des applications React Native ou Flutter pour iOS/Android

Intégration vocale : Ajout de la conversion de la parole en texte pour une saisie d’humeur mains libres

Apprentissage automatique : Implémentez un filtrage collaboratif pour des recommandations encore plus performantes

Déploiement : Déploiement sur AWS/Vercel avec des variables d’environnement appropriées

Continuez à expérimenter et à développer : l’avenir des expériences d’IA personnalisées est entre vos mains !

Prêt pour le prochain défi ? Restez à l’écoute pour notre prochain tutoriel sur l’ajout de fonctionnalités sociales et de filtrage collaboratif pour créer un réseau de découverte musicale qui connecte les gens à travers des expériences émotionnelles partagées.