Potenzia la tua API musicale per la lettura del pensiero: aggiungi account utente con cronologia degli stati d'animo e preferenze intelligenti

Trasforma il tuo generatore di playlist per il rilevamento delle emozioni in un compagno musicale personalizzato che impara da ogni interazione. Questo tutorial di approfondimento aggiunge l'autenticazione utente, l'analisi del monitoraggio degli stati d'animo e l'apprendimento intelligente delle preferenze per creare esperienze musicali davvero personalizzate.

Cosa stiamo sviluppando oggi

Ricordi la nostra API musicale per la lettura del pensiero, in grado di rilevare le emozioni e generare playlist? Oggi la rendiamo personale. Stiamo aggiungendo:

Autenticazione utente che funziona davvero (senza complessi mal di testa OAuth)
Dashboard della cronologia degli stati d'animo con analisi dettagliate
Preferenze playlist intelligenti che imparano dal comportamento dell'utente
Consigli personalizzati che migliorano nel tempo
Persistenza dei dati in modo che gli utenti non perdano mai il loro percorso musicale

Alla fine di questo tutorial, la tua API ricorderà che Sarah ama l'indie rock quando è triste, mentre Mike preferisce la musica classica per le sessioni di concentrazione.

Cosa ti servirà

La tua API Mind-Reading Music completata dal tutorial precedente
30 minuti di programmazione mirata tempo
Account MongoDB Atlas (il livello gratuito funziona perfettamente)
Conoscenza di base dei database (lo terremo semplice!)

Impostazione dell'autenticazione utente (il modo più semplice)

Per prima cosa, aggiungiamo i pacchetti necessari per la gestione degli utenti.

Vai al terminale nell'editor di codice, digita o incolla il seguente comando e premi Invio:

npm install mongoose bcryptjs jsonwebtoken express-session connect-mongo

Passaggio 1: Configurazione della connessione al database

Una volta completata l'installazione, crea un nuovo file denominato database.js e aggiungi il seguente codice:

const mongoose = require('mongoose'); const connectDB = async () => { try { console.log('🔗 Connessione a MongoDB...'); attendi mongoose.connect(process.env.MONGODB_URI, { useNewUrlParser: true, useUnifiedTopology: true, }); console.log('✅ MongoDB connesso correttamente!'); } catch (error) { console.error('❌ Connessione MongoDB fallita:', error.message); process.exit(1); } }; module.exports = connectDB;

E salva con cmd + s, ctrl + s o file quindi salva.

Crea il tuo account MongoDB Atlas

Visita: mongodb.com/cloud/atlas
Clicca: sul pulsante "Inizia" (solitamente nell'angolo in alto a destra)

Opzioni di registrazione

Hai tre modi per creare un account:

Opzione A: Registrazione tramite e-mail

Fai clic su "Registrati con e-mail"
Inserisci il tuo indirizzo e-mail
Crea una password complessa
Fai clic su "Crea il tuo account Atlas"

Opzione B: Registrazione con Google

Fai clic su "Registrati con Google"
Scegli il tuo account Google
Concedi le autorizzazioni necessarie

Opzione C: GitHub Registrati

Fai clic su "Registrati con GitHub"
Autorizza MongoDB Atlas ad accedere al tuo account GitHub

Verifica la tua email

Controlla la tua casella di posta elettronica
Fai clic sul collegamento di verifica di MongoDB
Questo conferma che il tuo account è reale

Crea il tuo primo cluster di database

Se non vedi la tua dashboard dopo aver effettuato l'accesso, potresti dover fare clic sul tuo nome nell'angolo in alto a destra per aprire il seguente menu a discesa e fare clic su Atlas:

Verrà quindi visualizzata la dashboard di Atlas. È ora di creare il tuo database!

Scegli il tipo di distribuzione

Fai clic su "Cluster" in "Database" nella barra laterale sinistra

Cluster MongoDB Atlas nella barra laterale

Fai clic su "Crea un cluster"

Scegli "Gratuito"

Verrai reindirizzato a una pagina di distribuzione del tuo cluster e potrai selezionare il piano gratuito.

Selezione del piano gratuito di MongoDB Atlas

Selezione del provider cloud: vedrai tre opzioni di provider:

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

Scegli: AWS (è il più popolare e ha il maggior numero di regioni)

Selezione della regione: dopo aver selezionato AWS, vedrai un menu a discesa con molte regioni. Scegli quella più vicina alla tua posizione per prestazioni migliori:

🇺🇸 Stati Uniti:

us-east-1 (Virginia settentrionale) - Costa orientale
us-west-2 (Oregon) - Costa occidentale
us-central-1 (Iowa) - Centrale

🇪🇺 Europa:

eu-west-1 (Irlanda) - Europa occidentale
eu-central-1 (Francoforte) - Europa centrale
eu-west-2 (Londra) - Regno Unito

🌏 Asia Pacifico:

ap-southeast-1 (Singapore) - Asia sud-orientale
ap-south-1 (Mumbai) - India
ap-northeast-1 (Tokyo) - Giappone

💡 Suggerimento: se non sei sicuro, us-east-1 è solitamente la scelta più sicura con il maggior numero di funzionalità.

Quindi fai clic sul pulsante "Crea distribuzione"

Pulsante di creazione distribuzione MongoDB

Crea utente del database

Passaggio 3.1: aggiungi utente del database

Vedrai la schermata "Avvio rapido sulla sicurezza"
Metodo di autenticazione: mantieni selezionati "Nome utente e password"
Nome utente: inserisci un nome utente (ad esempio, mood-music-user)
Password:
- Opzione A: fai clic su "Genera automaticamente password sicura" (consigliato)
- Opzione B: crea la tua password sicura password (almeno 8 caratteri)
Copia subito la password! Ti servirà per la stringa di connessione

Modulo per la creazione di utenti del database MongoDB

⚠️ Copia e salva la tua password immediatamente!

Clicca: "Crea utente database"
Clicca: "Scegli un metodo di connessione"

Scegli metodo di connessione

Vedrai diverse opzioni di connessione:

Driver 👈 Questo è ciò che vogliamo per le app Node.js
Compass (applicazione GUI desktop di MongoDB)
Shell (interfaccia della riga di comando di MongoDB)
MongoDB per VS Code (estensione VS Code)
Atlas SQL (interfaccia SQL per MongoDB)

Seleziona: "Driver" - questo ti fornisce la stringa di connessione per le applicazioni come Node.js

Selezione del metodo di connessione MongoDB

Configura la connessione del driver

Dopo aver selezionato "Driver":

Driver: Seleziona "Node.js" dal menu a discesa
Versione: Seleziona la tua versione di Node.js o lascia quella predefinita (di solito funziona bene)
Stringa di connessione: vedrai la stringa di connessione apparire qui sotto

Copia la tua stringa di connessione

Vedrai qualcosa di simile a questo:

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

Importante: questo è un modello! Devi:

Sostituisci <username> con il nome utente del tuo database
Sostituisci <password> con la password del tuo database
Aggiungi il nome del tuo database dopo .net/

Esempio di trasformazione

Prima (modello):

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

Dopo (pronto all'uso):

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

Avviso:

<username> → mood-music-user
<password> → MySecurePassword123
Aggiunto /mood-music-db come nome del database

Fare clic su 'fatto'

Passaggio 5: aggiungere la stringa di connessione al progetto

Aggiornare il file .env

Aprire il file .env e aggiungi:

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

Genera segreti sicuri

Per JWT_SECRET e SESSION_SECRET, hai bisogno di stringhe casuali che non danneggino i tuoi file di configurazione.

⚠️ Importante: evita caratteri speciali come @, #, $, %, /, ? nelle password poiché possono danneggiare le stringhe di connessione e i file JSON.

Opzione A: Generatore online semplice (consigliato)

Visita: JWTSECRETS
Impostazioni:
- Numero di password: 1
- Lunghezza password: 32
- ✅ Seleziona "lettere maiuscole (A-Z)"
- ✅ Seleziona "lettere minuscole (a-z)"
- ✅ Seleziona "cifre (0-9)"
- ❌ Deseleziona "punteggiatura"
Fai clic su "Ottieni password"

Opzione B: usa la console del tuo browser (facilissimo!)

Apri un sito web qualsiasi (come google.com)
Premi F12 (o fai clic con il pulsante destro del mouse → Ispeziona)
Fai clic sulla scheda "Console"

Incolla questo codice e premi Invio:

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

Copia il risultato: sarà qualcosa del tipo: k8m9x2n7p4q1w3e5r6t8y9u2i4o7p1a5s3d6f8g2h4j7k9l

Opzione C: Metodo manuale (se tutto il resto fallisce)

Digita semplicemente una lunga stringa casuale usando:

Lettere: A-Z, a-z
Numeri: 0-9
Esempio: MyApp2024SecretKey789RandomString456Auth

Esempio finale .env

SPOTIFY_CLIENT_ID=il_tuo_id_client_spotify_qui SPOTIFY_CLIENT_SECRET=il_tuo_segreto_client_spotify_qui 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

Punti chiave:

✅ Nessun carattere speciale in JWT_SECRET e SESSION_SECRET
✅ La password MongoDB evita l'interruzione dell'URL caratteri
✅ Tutti i segreti sono lunghi e casuali
✅ Sicuro da usare in file JSON e stringhe di connessione

Passaggio 2: Modello utente con monitoraggio dell'umore

Crea una cartella denominata models e aggiungi un file denominato User.js al suo interno. Quindi aggiungi e salva il seguente codice nel file:

const mongoose = require('mongoose'); const bcrypt = require('bcryptjs'); const moodEntrySchema = new mongoose.Schema({ text: String, detectedMood: String, confidence: Number, playlistGenerated: [{ trackName: String, artist: String, spotifyId: String, liked: { type: Boolean, default: null } }], timestamp: { type: Date, default: 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 }); // Esegui l'hash della password prima di salvarla userSchema.pre('save', async function(next) { if (!this.isModified('password')) return next(); this.password = await bcrypt.hash(this.password, 12); next(); }); // Confronta le password userSchema.methods.comparePassword = async function(password) { return bcrypt.compare(password, this.password); }; // Calcola le statistiche utente userSchema.methods.updateStats = function() { const moods = this.moodHistory.map(entry => entry.detectedMood); this.stats.totalPlaylists = this.moodHistory.length; // Trova l'umore più comune 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' ); // Determina l'ora preferita del giorno 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 = 'night'; else if (avgHour < 12) this.stats.favoriteTime = 'morning'; else if (avgHour < 18) this.stats.favoriteTime = 'afternoon'; else this.stats.favoriteTime = 'evening'; }; module.exports = mongoose.model('User', userSchema);

Passaggio 3: Middleware di autenticazione

Crea una cartella denominata middleware e aggiungi al suo interno un file denominato auth.js. Quindi aggiungi il seguente codice al file e salvalo:

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({ errore: 'Nessun token fornito' }); } const decoded = jwt.verify(token, process.env.JWT_SECRET); const user = await User.findById(decoded.userId); if (!user) { return res.status(401).json({ errore: 'Utente non trovato' }); } req.user = user; next(); } catch (error) { res.status(401).json({ errore: 'Token non valido' }); } }; module.exports = auth;

Dashboard utente con analisi dettagliate

Crea una nuova cartella nel tuo progetto e chiamala public, quindi aggiungi un file al suo interno e chiamalo index.html:

<!DOCTYPE html> <html> <head> <title>API per la lettura della mente - Dashboard personale</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; colore: #333; } .dashboard { larghezza massima: 1200px; margine: 0 auto; padding: 20px; } .header { sfondo: rgba(255,255,255,0.95); filtro sfondo: sfocatura(10px); raggio bordo: 20px; padding: 30px; margine inferiore: 30px; allineamento testo: centro; ombra riquadro: 0 8px 32px rgba(0,0,0,0.1); } .stats-grid { display: griglia; colonne modello griglia: ripeti(adattamento automatico, minmax(250px, 1fr)); spazio: 20px; margine inferiore: 30px; } .stat-card { sfondo: rgba(255,255,255,0.9); raggio bordo: 15px; padding: 25px; text-align: center; box-shadow: 0 4px 15px rgba(0,0,0,0.1); } .mood-input-section { background: rgba(255,255,255,0.95); border-radius: 20px; padding: 30px; margin-bottom: 30px; } .mood-history { background: rgba(255,255,255,0.95); border-radius: 20px; padding: 30px; } .history-item { background: #f8f9fa; border-radius: 10px; padding: 15px; margin-bottom: 15px; border-left: 4px solid #667eea; } .login-section, .register-section { background: rgba(255,255,255,0.95); border-radius: 20px; padding: 30px; max-width: 400px; margin: 50px auto; } input, textarea, button { width: 100%; padding: 12px; margin: 10px 0; border: 2px solid #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>🧠🎵 Bentornato!</h2> <input type="text" id="loginUsername" placeholder="Nome utente"> <input type="password" id="loginPassword" placeholder="Password"> <button onclick="login()">Accedi</button> <p><a href="#" onclick="showRegister()">Non hai un account? Registrati</a></p> </div> <div id="registerSection" class="register-section" style="display:none;"> <h2>🎵 Crea il tuo profilo musicale</h2> <input type="text" id="regUsername" placeholder="Nome utente"> <input type="email" id="regEmail" placeholder="Email"> <input type="password" id="regPassword" placeholder="Password"> <button onclick="register()">Crea account</button> <p><a href="#" onclick="showLogin()">Hai già un account? Accedi</a></p> </div> </div> <div id="dashboardSection" style="display:none;"> <div class="header"> <h1>🧠🎵 Il tuo lettore musicale personale</h1> <p>Bentornato, <span id="username"></span>! Pronto a scoprire la tua colonna sonora perfetta?</p> <button onclick="logout()" style="width:auto; margin-top:10px;">Esci</button> </div> <div class="stats-grid"> <div class="stat-card"> <h3>📊 Playlist totali</h3> <div id="totalPlaylists" class="stat-number">0</div&</div> <div class="stat-card"> <h3>😊 Umore preferito</h3> <div id="favoriteMood" class="stat-text">-</div> </div> <div class="stat-card"> <h3>🕐 Momento migliore</h3> <div id="bestTime" class="stat-text">-</div> </div> <div class="stat-card"> <h3>🎵 Genere principale</h3> <div id="topGenre" class="stat-text">-</div> </div> </div> <div class="mood-input-section"> <h2>💭 Come ti senti in questo momento?</h2> <textarea id="moodText" placeholder="Descrivi il tuo stato d'animo attuale, cosa sta succedendo o come vorresti sentirti..."></textarea> <button onclick="generatePersonalizedPlaylist()">🎧 Genera la mia playlist perfetta</button> <div id="result" style="display:none;" class="result"></div> </div> <div class="mood-history"> <h2>📈 Il tuo percorso verso l'umore</h2> <div id="historyContainer"></div> </div> </div> </div> <script src="/js/app.js"></script> </body> </html>

Ora all'interno della tua cartella public, crea una cartella e chiamala js e crea un file app.js all'interno della cartella js con il seguente codice:

let authToken = localStorage.getItem('authToken'); let currentUser = null; if (authToken) { loadDashboard(); } function showLogin() { document.querySelector('.login-section').style.display = 'block'; document.getElementById('registerSection').style.display = 'none'; } function showRegister() { document.querySelector('.login-section').style.display = 'none'; document.getElementById('registerSection').style.display = 'block'; } async function login() { const username = document.getElementById('loginUsername').value; const password = document.getElementById('loginPassword').value; if (!username || !password) { alert('Si prega di compilare tutti i campi'); return; } 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 || 'Accesso non riuscito'); } } catch (error) { console.error('Errore di accesso:', error); alert('Accesso non riuscito. Riprova.'); } } 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('Compila tutti i campi'); 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('Account creato con successo! Effettua il login.'); showLogin(); } else { alert(data.error || 'Registrazione fallita'); } } catch (error) { console.error('Errore di registrazione:', error); alert('Registrazione fallita. Riprova.'); } } async function loadDashboard() { try { const response = await fetch('/api/profile', { headers: { 'Authorization': 'Bearer ' + authToken } }); if (response.ok) { currentUser = await response.json(); showDashboard(); updateStats(); loadMoodHistory(); } else { logout(); } } catch (error) { console.error('Errore di caricamento della dashboard:', error); logout(); } } function showDashboard() { document.getElementById('authSection').style.display = 'none'; document.getElementById('dashboardSection').style.display = 'block'; document.getElementById('username').textContent = currentUser.username; } function updateStats() { document.getElementById('totalPlaylists').textContent = currentUser.stats.totalPlaylists || 0; document.getElementById('favoriteMood').textContent = currentUser.stats.mostCommonMood || '-'; document.getElementById('bestTime').textContent = currentUser.stats.favoriteTime || '-'; document.getElementById('topGenre').textContent = (currentUser.preferences.favoriteGenres && currentUser.preferences.favoriteGenres[0]) || '-'; } function loadMoodHistory() { const historyContainer = document.getElementById('historyContainer'); if (!currentUser.moodHistory || currentUser.moodHistory.length === 0) { historyContainer.innerHTML = '<p>Nessuna cronologia degli stati d'animo ancora. Genera la tua prima 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} tracce generate</small> </div>` ).join(''); } async function generatePersonalizedPlaylist() { const moodText = document.getElementById('moodText').value; if (!moodText.trim()) { alert('Descrivi come ti senti!'); 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 || 'Impossibile generare la playlist'); } } catch (error) { console.error('Errore di generazione della playlist:', error); alert('Impossibile generare la playlist. Riprova.'); } } function displayPersonalizedResults(data) { const resultDiv = document.getElementById('result'); resultDiv.style.display = 'block'; const html = ` <h3>Stato d'animo rilevato: ${data.moodAnalysis.mood} (Fiducia: ${data.moodAnalysis.confidence}/10)</h3> <p>${data.personalizedMessage || 'Ecco la tua playlist!'}</p> <div class="playlist"> ${data.playlist.map(track => ` <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; } funzione asincrona likeTrack(trackId, piaciuto) { prova { await fetch('/api/track-feedback', { metodo: 'POST', intestazioni: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + authToken }, corpo: JSON.stringify({ trackId: trackId, piaciuto: piaciuto }) }); alert(piaciuto ? 'Grazie! Ne consiglieremo altri simili.' : 'Capito! Eviteremo tracce simili.'); } catch (error) { console.error('Errore di feedback:', errore); } } function logout() { localStorage.removeItem('authToken'); authToken = null; currentUser = null; document.getElementById('authSection').style.display = 'block'; document.getElementById('dashboardSection').style.display = 'none'; showLogin(); }

Sostituisci il tuo file server.js

Sostituisci il codice del tuo file server.js con quanto segue:

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'); // Connettiti a MongoDB const connectDB = async () => { try { console.log('🔗 Connessione a MongoDB...'); await mongoose.connect(process.env.MONGODB_URI, { useNewUrlParser: true, useUnifiedTopology: true, }); console.log('✅ MongoDB connesso correttamente!'); } catch (error) { console.error('❌ Connessione a MongoDB fallita:', 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')); // Servire la pagina principale app.get('/', (req, res) => { res.sendFile(__dirname + '/public/index.html'); }); // Registrazione utente app.post('/api/register', async (req, res) => { try { const { username, email, password } = req.body; if (!username || !email || !password) { return res.status(400).json({ errore: 'Tutti i campi sono obbligatori' }); } if (password.length < 6) { return res.status(400).json({ errore: 'La password deve essere lunga almeno 6 caratteri' }); } const existingUser = await User.findOne({ $or: {[ email }, { username }] }); if (existingUser) { return res.status(400).json({ errore: 'Il nome utente o l'email esiste già' }); } const user = new User({ username, email, password }); attendi user.save(); res.status(201).json({ messaggio: 'Utente creato correttamente' }); } catch (error) { console.error('Errore di registrazione:', errore); res.status(500).json({ errore: 'Registrazione fallita' }); } }); // Accesso utente 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: 'Credenziali non valide' }); } 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('Accesso errore:', errore); res.status(500).json({ errore: 'Accesso non riuscito' }); } }); // Ottieni il profilo utente 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: 'Impossibile caricare il profilo' }); } }); // Generazione playlist personalizzata app.post('/api/personalized-playlist', auth, async (req, res) => { try { const { text, playlistSize = 15 } = req.body; if (!text) { return res.status(400).json({ error: 'Per favore, dimmi come ti senti!' }); } const moodAnalysis = moodAnalyzer.analyzeMood(text); const playlist = await playlistGen.generatePlaylist( moodAnalysis.mood, moodAnalysis.intensity, playlistSize ); // Salva nella cronologia dell'utente 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: `In base alla tua cronologia, ho personalizzato questa playlist specificatamente per il tuo umore ${moodAnalysis.mood}!` }); } catch (error) { console.error('Errore playlist personalizzata:', error); res.status(500).json({ error: 'Impossibile generare la playlist personalizzata. Riprova.' }); } }); // Traccia il feedback app.post('/api/track-feedback', auth, async (req, res) => { try { const { trackId, liked } = req.body; res.json({ message: 'Feedback ricevuto! Miglioreremo i consigli futuri.' }); } catch (error) { console.error('Errore nel feedback:', error); res.status(500).json({ error: 'Impossibile elaborare il feedback' }); } }); app.listen(PORT, () => { console.log(`🚀 API musicale per la lettura della mente in esecuzione su http://localhost:${PORT}`); console.log('🧠 Pronto per analizzare gli stati d'animo e generare playlist!'); });

Cosa dovresti essere in grado di fare ora

1. Utenti anonimi (funzionalità originale)

Visita il tuo sito web senza effettuare l'accesso
Genera playlist utilizzando l'analisi dell'umore esistente
Ricevi consigli musicali basati sulle emozioni

2. Utenti registrati (nuove funzionalità)

Crea un account ed effettua l'accesso
Genera playlist personalizzate che migliorano nel tempo
Visualizza la cronologia dell'umore e le analisi personali
Aggiungi Mi piace/Non mi piace alle tracce per addestrare l'IA
Visualizza statistiche come l'umore preferito, il numero totale di playlist, ecc.

Guida ai test passo passo

Test 1: verifica l'avvio del server

node server.js

Dovresti vedere:

🔑 Tentativo di autenticazione Spotify... 🎵 Spotify connesso correttamente! 🔗 MongoDB si connette... ✅ MongoDB si è connesso correttamente! 🚀 API musicale per la lettura della mente in esecuzione su http://localhost:3000 🧠 Pronta ad analizzare gli stati d'animo e generare playlist!

Test 2: visita il tuo sito web

Vai a: http://localhost:3000

Cosa dovresti vedere:

Un modulo di accesso che richiede nome utente/password
Un link "Non hai un account? Registrati"

Test 3: crea il tuo primo account

Clicca: "Non hai un account? Registrati"
Compila:
- Nome utente: testuser
- Email: test@example.com
- Password: password123
Clicca: "Crea account"
Risultato previsto: "Account creato con successo! Accedi."

Test 4: Accedi alla tua dashboard

Utilizza le credenziali appena create
Clicca: "Accedi"
Dovresti vedere:
- Messaggio di benvenuto con il tuo nome utente
- Schede statistiche che mostrano 0 playlist, nessun umore preferito ancora
- Area di testo che chiede "Come ti senti in questo momento?"

Test 5: Genera la tua prima playlist personalizzata

Digita qualcosa come: "Sono super entusiasta del mio nuovo progetto!"
Clicca: "Genera la mia playlist perfetta"
Dovresti vedere:
- Stato d'animo rilevato (probabilmente "energico" o "felice")
- Elenco dei brani con copertina dell'album
- Anteprima dei lettori audio (se disponibili)
- Pulsanti pollice su/giù per ogni brano

Test 6: Metti alla prova il sistema di apprendimento

Clicca sul pollice su 👍 sui brani che ti piacciono
Clicca sul pollice giù 👎 sui brani che non ti piacciono
Previsto: Messaggi di avviso che dicono "Grazie! Ne consiglieremo altri simili"

Test 7: Controlla l'aggiornamento delle statistiche

Aggiorna pagina o genera un'altra playlist
Le tue statistiche ora dovrebbero mostrare:
- Playlist totali: 1 (o più)
- Stato d'animo preferito: qualsiasi stato d'animo sia stato rilevato
- Altre statistiche dovrebbero iniziare ad apparire

Test di scenari diversi

Prova stati d'animo diversi:

"Ho appena rotto con la mia ragazza e sta piovendo" (dovrebbe rilevare: triste)
"Sono carico per la mia sessione di allenamento!" (dovrebbe rilevare: energico)
"Voglio solo rilassarmi e studiare in silenzio" (dovrebbe rilevare: rilassarmi)
"Mi sento romantico in questa serata romantica" (dovrebbe rilevare: romantico)

Casi limite di prova:

"" (vuoto - dovrebbe mostrare un errore)
"asdf testo casuale" (dovrebbe essere impostato di default su neutro/rilassato)
"Sono ESTREMAMENTE emozionato!!!" (dovrebbe rilevare una maggiore confidenza)

Problemi comuni e soluzioni rapide

❌ "Connessione MongoDB non riuscita"

Controlla: il tuo file .env è configurato correttamente con la stringa di connessione MongoDB?

# Esegui questo per testare la connessione al database node -e "require('dotenv').config(); console.log('MONGODB_URI:', process.env.MONGODB_URI ? 'Set ✅' : 'Missing ❌');"

❌ "Connessione Spotify non riuscita"

Controlla: le tue chiavi API Spotify sono nel file .env?

# Esegui questo per verificare le credenziali di Spotify node -e "require('dotenv').config(); console.log('ID client Spotify:', process.env.SPOTIFY_CLIENT_ID ? 'Imposta ✅' : '❌ mancante');"

❌ Login/Registrazione non funziona

Controlla: Stai visualizzando messaggi di errore nella console del browser?

Premi F12 → scheda Console
Cerca messaggi di errore rossi

❌ La pagina mostra la vecchia interfaccia

Soluzione: Aggiorna la pagina

Premi Ctrl+Maiusc+R (Windows/Linux)
Premi Cmd+Maiusc+R (Mac)

Cosa dovrebbe funzionare e cosa è ancora di base

✅ Dovrebbe funzionare ora:

Registrazione e login utente
Rilevamento dell'umore di base e generazione di playlist
Salvataggio della cronologia dell'umore nel database
Semplice mi piace/non mi piace feedback
Monitoraggio delle statistiche (playlist totali, umore preferito)

🚧 Ancora di base (funzionalità avanzate per dopo):

Apprendimento automatico complesso dal feedback degli utenti
Funzionalità social e condivisione di playlist
Analisi avanzate e modelli di umore
Interfaccia dell'app mobile

Passaggi successivi dopo il test

Una volta che tutto funziona:

Prova con utenti diversi - crea più account per vedere come cambia la personalizzazione
Genera più playlist - guarda come si evolvono le tue statistiche e preferenze
Fornisci feedback sulle tracce - guarda come il sistema impara i tuoi gusti
Controlla la dashboard di MongoDB Atlas - dovresti vedere i dati memorizzati

Conclusione

Hai appena creato qualcosa di straordinario: un'intelligenza artificiale che non solo comprende le emozioni umane, ma impara e si adatta alle preferenze individuali nel tempo. La tua API musicale per la lettura della mente ora ha memoria, personalità e la capacità di crescere con i suoi utenti.

La combinazione di rilevamento dell'umore, apprendimento dell'utente e consigli personalizzati crea un'esperienza che diventa più magica a ogni interazione. Il percorso di ogni utente diventa unico, creando una colonna sonora personale per la sua vita emotiva.

La tua API ora ricorda ogni stato d'animo, impara da ogni interazione e crea una comprensione completa delle preferenze musicali di ogni utente. Questa è la base per esperienze di intelligenza artificiale davvero personalizzate.

Cosa c'è dopo?

Pronti a spingervi ancora oltre? Ecco alcune interessanti indicazioni:

Analisi avanzata: aggiungi il riconoscimento dei modelli di umore e suggerimenti predittivi
Funzionalità social: consenti agli utenti di condividere playlist e scoprire i gusti musicali degli amici
App mobile: crea app React Native o Flutter per iOS/Android
Integrazione vocale: aggiungi la conversione da voce a testo per l'input dell'umore a mani libere
Apprendimento automatico: implementa il filtraggio collaborativo per suggerimenti ancora migliori
Distribuzione: distribuisci su AWS/Vercel con variabili di ambiente appropriate

Continua a sperimentare e costruire: il futuro delle esperienze di intelligenza artificiale personalizzate è nelle tue mani!

Pronti per la prossima sfida? Restate sintonizzati per il nostro prossimo tutorial sull'aggiunta di funzionalità social e filtraggio collaborativo per creare una rete di scoperta musicale che connette le persone attraverso emozioni condivise esperienze.