Posuňte své hudební API pro čtení myšlenek na vyšší úroveň: Přidávání uživatelských účtů s historií nálad a chytrými preferencemi

Proměňte svůj generátor playlistů detekujících emoce v personalizovaného hudebního společníka, který se učí z každé interakce. Tento navazující tutoriál přidává ověřování uživatelů, analýzu sledování nálad a inteligentní učení preferencí, aby vytvářel skutečně personalizované hudební zážitky.

Co dnes vytváříme

Pamatujete si na naše hudební API pro čtení myšlenek, které dokázalo detekovat emoce a generovat playlisty? Dnes ho osobnímu provedení. Přidáváme:

Ověřování uživatelů, které skutečně funguje (žádné složité bolesti hlavy s OAuth)
Nástěnka historie nálad s krásnou analýzou
Chytré preference playlistů, které se učí z chování uživatelů
Personalizovaná doporučení, která se časem zlepšují
Perzistence dat, aby uživatelé nikdy neztratili svou hudební cestu

Do konce tohoto tutoriálu si vaše API zapamatuje, že Sarah miluje indie rock, když je smutná, zatímco Mike preferuje klasickou hudbu pro soustředění.

Co budete potřebovat

Vaše dokončené API pro čtení myšlenek z předchozího tutoriálu
30 minut soustředěného kódování
Atlas MongoDB účet (bezplatná úroveň funguje perfektně)
Základní znalost databází (udržíme to jednoduché!)

Nastavení ověřování uživatelů (jednoduchý způsob)

Nejprve přidejme balíčky, které potřebujeme pro správu uživatelů.

V editoru kódu přejděte do terminálu, zadejte nebo vložte následující příkaz a stiskněte Enter:

npm install mongoose bcryptjs jsonwebtoken express-session connect-mongo

Krok 1: Nastavení připojení k databázi

Po dokončení instalace vytvořte nový soubor s názvem database.js a přidejte následující kód:

const mongoose = require('mongoose'); const connectDB = async () => { try { console.log('🔗 Připojování k MongoDB...'); await mongoose.connect(process.env.MONGODB_URI, { useNewUrlParser: true, useUnifiedTopology: true, }); console.log('✅ MongoDB se úspěšně připojilo!'); } catch (error) { console.error('❌ Připojení k MongoDB selhalo:', error.message); process.exit(1); } }; module.exports = connectDB;

A uložte pomocí cmd + s, ctrl + s nebo file a poté uložte.

Vytvořte si účet MongoDB Atlas

Navštivte: mongodb.com/cloud/atlas
Klikněte: tlačítko „Začít“ (obvykle v pravém horním rohu)

Možnosti registrace

Účet si můžete vytvořit třemi způsoby:

Možnost A: Registrace e-mailem

Klikněte na „Registrovat se e-mailem“
Zadejte svou e-mailovou adresu
Vytvořte si silné heslo
Klikněte na „Vytvořit si účet Atlas“

Možnost B: Registrace přes Google

Klikněte na „Registrovat se přes Google“
Vyberte si svůj účet Google
Udělte potřebná oprávnění

Možnost C: Registrace přes GitHub

Klikněte na „Registrovat se přes GitHub"
Autorizujte MongoDB Atlas pro přístup k vašemu účtu GitHub

Ověřte svůj e-mail

Zkontrolujte svou e-mailovou schránku
Klikněte na ověřovací odkaz od MongoDB
Tím se potvrdí, že váš účet je skutečný

Vytvořte si svůj první databázový cluster

Pokud se po přihlášení nezobrazí váš dashboard, možná budete muset kliknout na své jméno v pravém horním rohu, abyste otevřeli následující rozbalovací nabídku, a kliknout na Atlas:

Poté se zobrazí ovládací panel Atlas. Čas vytvořit databázi!

Vyberte typ nasazení

Klikněte na „Klastry“ v části „Databáze“ v levém postranním panelu

Klastry MongoDB Atlas v postranním panelu

Klikněte na „Vytvořit klastr“

Vyberte „Zdarma“

Budete přesměrováni na stránku pro nasazení clusteru a chcete vybrat bezplatný plán.

Výběr poskytovatele cloudových služeb: Zobrazí se tři možnosti poskytovatele:

AWS (Amazon Web Services) ⭐ Doporučený
Google Cloud Platform
Microsoft Azure

Výběr: AWS (je nejoblíbenější a má nejvíce regionů)

Výběr regionu: Po výběru AWS se zobrazí rozbalovací nabídka s mnoha regiony. Pro lepší výkon vyberte tu nejblíže k vaší poloze:

🇺🇸 Spojené státy:

us-east-1 (Severní Virginie) - Východní pobřeží
us-west-2 (Oregon) - Západní pobřeží
us-central-1 (Iowa) - Střední Evropa

🇪🇺 Evropa:

eu-west-1 (Irsko) - Západní Evropa
eu-central-1 (Frankfurt) - Střední Evropa
eu-west-2 (Londýn) - Spojené království

🌏 Asie a Tichomoří:

ap-southeast-1 (Singapur) - Jihovýchodní Asie
ap-south-1 (Bombaj) - Indie
ap-northeast-1 (Tokio) - Japonsko

💡 Tip pro profesionály: Pokud si nejste jisti, us-east-1 je obvykle nejbezpečnější volbou s největším počtem funkcí.

Poté klikněte na tlačítko „Vytvořit nasazení“

Vytvořit uživatele databáze

Krok 3.1: Přidat uživatele databáze

Zobrazí se obrazovka „Rychlý start zabezpečení“
Metoda ověřování: Ponechte vybranou možnost „Uživatelské jméno a heslo“
Uživatelské jméno: Zadejte uživatelské jméno (např. mood-music-user)
Heslo:
- Možnost A: Klikněte na „Automaticky vygenerovat bezpečné heslo“ (doporučeno)
- Možnost B: Vytvořte si vlastní silné heslo (alespoň 8 znaků)
Heslo ihned zkopírujte! Budete ho potřebovat pro svůj připojovací řetězec

⚠️ Heslo ihned zkopírujte a uložte!

Klikněte na: "Vytvořit databázi" Uživatel"
Klikněte: "Vyberte způsob připojení"

Vyberte způsob připojení

Zobrazí se několik možností připojení:

Ovladače 👈 Toto chceme pro aplikace Node.js
Compass (desktopová grafická aplikace MongoDB)
Shell (rozhraní příkazového řádku MongoDB)
MongoDB pro VS Code (rozšíření VS Code)
Atlas SQL (rozhraní SQL pro MongoDB)

Vyberte: "Ovladače" - tímto získáte připojovací řetězec pro aplikace jako Node.js

Nakonfigurujte připojení ovladače

Po výběru možnosti „Ovladače“:

Ovladač: V rozbalovací nabídce vyberte „Node.js“
Verze: Vyberte verzi Node.js nebo ji ponechte jako výchozí (obvykle funguje dobře)
Připojovací řetězec: Připojovací řetězec se zobrazí níže

Zkopírujte připojovací řetězec

Uvidíte něco jako toto:

mongodb+srv://<uživatelské_jméno>:<heslo>@cluster0.abc123.mongodb.net/?retryWrites=true&w=majority

Důležité: Toto je šablona! Je třeba:

Nahradit <username> svým uživatelským jménem k databázi
Nahradit <password> svým heslem k databázi
Přidat název vaší databáze za .net/

Příklad transformace

Před (šablona):

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

Po (připraveno k použití):

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

Upozornění:

<username> → mood-music-user
<password> → MySecurePassword123
Přidán /mood-music-db jako název databáze

Klikněte na 'hotovo'

Krok 5: Přidání připojovacího řetězce do projektu

Aktualizace souboru .env

Otevřete soubor .env a přidat:

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

Generovat silné tajné klíče

Pro JWT_SECRET a SESSION_SECRET potřebujete náhodné řetězce, které neporuší vaše konfigurační soubory.

⚠️ Důležité: Vyhněte se speciálním znakům jako @, #, $, %, /, ? v heslech, protože mohou narušit připojovací řetězce a soubory JSON.

Možnost A: Jednoduchý online generátor (doporučeno)

Navštivte: JWTSECRETS
Nastavení:
- Počet hesel: 1
- Délka hesla: 32
- ✅ Zaškrtněte „velká písmena (A-Z)“
- ✅ Zaškrtněte „malá písmena“ (a-z)"
- ✅ Zaškrtněte „číslice (0-9)“
- ❌ Zrušte zaškrtnutí „interpunkce“
Klikněte na „Získat hesla“

Možnost B: Použijte konzoli prohlížeče (super snadné!)

Otevřete libovolnou webovou stránku (například google.com)
Stiskněte F12 (nebo klikněte pravým tlačítkem myši → Prohlédnout)
Klikněte na kartu „Konzole“

Vložte tento kód a stiskněte Enter:

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

Kopírovat výsledek - bude to něco jako: k8m9x2n7p4q1w3e5r6t8y9u2i4o7p1a5s3d6f8g2h4j7k9l

Možnost C: Ruční metoda (pokud vše ostatní selže)

Stačí zadat dlouhý náhodný řetězec pomocí:

Písmena: A-Z, a-z
Čísla: 0-9
Příklad: MyApp2024SecretKey789RandomString456Auth

Konečný příklad .env

SPOTIFY_CLIENT_ID=vaše_spotify_id_klienta_zde SPOTIFY_CLIENT_SECRET=vaše_tajemství_klienta_spotify_zde 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

Klíčové body:

✅ Žádné speciální znaky v JWT_SECRET a SESSION_SECRET
✅ Heslo MongoDB se vyhýbá znakům zarušujícím URL
✅ Všechny tajné kódy jsou dlouhé a náhodné
✅ Bezpečné pro použití v souborech JSON a připojovacích řetězcích

Krok 2: Uživatelský model se sledováním nálady

Vytvořit složku s názvem models a do ní přidejte soubor s názvem User.js. Poté do souboru přidejte a uložte následující kód:

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], moodMappingMusic: { happy: [String], sad: [String], energic: [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 }); // Hašování hesla před uložením userSchema.pre('save', async function(next) { if (!this.isModified('password')) return next(); this.password = await bcrypt.hash(this.password, 12); next(); }); // Porovnání hesel userSchema.methods.comparePassword = async function(password) { return bcrypt.compare(password, this.password); }; // Výpočet uživatelských statistik userSchema.methods.updateStats = function() { const moods = this.moodHistory.map(entry => entry.detectedMood); this.stats.totalPlaylists = this.moodHistory.length; // Nalezení nejčastějších nálad 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' ); // Určení oblíbené denní doby 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 = 'noc'; else if (avgHour < 12) this.stats.favoriteTime = 'ráno'; else if (avgHour < 18) this.stats.favoriteTime = 'odpoledne'; else this.stats.favoriteTime = 'večer'; }; module.exports = mongoose.model('User', userSchema);

Krok 3: Middleware pro ověřování

Vytvořte složku s názvem middleware a do ní přidejte soubor s názvem auth.js. Poté do souboru přidejte následující kód a uložte jej:

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: 'Token nebyl poskytnut' }); } const decoded = jwt.verify(token, process.env.JWT_SECRET); const user = await User.findById(decoded.userId); if (!user) { return res.status(401).json({ chyba: 'Uživatel nenalezen' }); } req.user = user; next(); } catch (error) { res.status(401).json({ chyba: 'Neplatný token' }); } }; module.exports = auth;

Uživatelský řídicí panel s krásnou analytikou

Vytvořte ve svém projektu novou složku a pojmenujte ji public, poté do této složky přidejte soubor a pojmenujte jej index.html:

<!DOCTYPE html> <html> <head> Mind-Reading Music API - Osobní dashboard       🧠🎵 Vítejte zpět!
    <p><a href="#" onclick="showRegister()">Nemáte účet? Zaregistrujte se</a></p> </div> <div id="registerSection" class="register-section" style="display:none;"> <h2>🎵 Vytvořte si hudební profil</h2> <input type="text" id="regUsername" placeholder="Uživatelské jméno"> <input type="email" id="regEmail" placeholder="E-mail"> <input type="password" id="regPassword" placeholder="Heslo"> <button onclick="register()">Vytvořit účet</button> <p><a href="#" onclick="showLogin()">Již máte účet? Přihlášení</a></p> </div> </div> <div id="dashboardSection" style="display:none;"> <div class="header"> <h1>🧠🎵 Váš osobní čtenář hudebních myšlenek</h1> <p>Vítejte zpět, <span id="username"></span>! Jste připraveni objevit svůj dokonalý soundtrack?</p> <button onclick="logout()" style="width:auto; margin-top:10px;">Odhlásit</button> </div> <div class="stats-grid"> <div class="stat-card"> <h3>📊 Celkem playlistů</h3> <div id="totalPlaylists" class="stat-number">0</div&</div> <div class="stat-card"> <h3>😊 Oblíbená nálada</h3> <div id="favoriteMood" class="stat-text">-</div> </div> <div class="stat-card"> <h3>🕐 Nejlepší čas</h3> <div id="bestTime" class="stat-text">-</div> </div> <div class="stat-card"> <h3>🎵 Nejlepší žánr</h3> <div id="topGenre" class="stat-text">-</div> </div> </div> </div> <div class="mood-input-section"> <h2>💭 Jak se právě teď cítíte?</h2> <textarea id="moodText" placeholder="Popište svou aktuální náladu, co se děje nebo jak se chcete cítit..."></textarea> <button onclick="generatePersonalizedPlaylist()">🎧 Vygenerujte si můj perfektní playlist</button> <div id="result" style="display:none;" class="result"></div> </div> <div class="mood-history"> <h2>📈 Vaše cesta nálady</h2> <div id="historyContainer"></div> </div> </div> </div> </div> </script src="/js/app.js"></script> </body> </html>

Nyní ve vaší složce public vytvořte složku a pojmenujte ji js a ve složce js vytvořte soubor app.js s následujícím kódem:

let authToken = localStorage.getItem('authToken'); let currentUser = null; if (authToken) { loadDashboard(); } funkce showLogin() { document.querySelector('.login-section').style.display = 'block'; document.getElementById('registerSection').style.display = 'none'; } funkce showRegister() { document.querySelector('.login-section').style.display = 'none'; document.getElementById('registerSection').style.display = 'block'; } async funkce login() { const username = document.getElementById('loginUsername').value; const password = document.getElementById('loginPassword').value; if (!username || !password) { alert('Vyplňte prosím všechna pole'); 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 || 'Přihlášení se nezdařilo'); } } catch (error) { console.error('Chyba přihlášení:', error); alert('Přihlášení se nezdařilo. Zkuste to prosím znovu.'); } } 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('Vyplňte prosím všechna pole'); 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('Účet úspěšně vytvořen! Přihlaste se.'); showLogin(); } else { alert(data.error || 'Registrace selhala'); } } catch (error) { console.error('Chyba registrace:', error); alert('Registrace selhala. Zkuste to prosím znovu.'); } } async function loadDashboard() { try { const response = await fetch('/api/profile', { headers: { 'Autorizace': 'Bearer ' + authToken } }); if (response.ok) { currentUser = await response.json(); showDashboard(); updateStats(); loadMoodHistory(); } else { logout(); } } catch (error) { console.error('Chyba při načítání dashboardu:', error); logout(); } } function showDashboard() { document.getElementById('authSection').style.display = 'none'; document.getElementById('dashboardSection').style.display = 'block'; document.getElementById('username').textContent = currentUser.username; } funkce 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]) || '-'; } funkce loadMoodHistory() { const historyContainer = document.getElementById('historyContainer'); pokud (!currentUser.moodHistory || currentUser.moodHistory.length === 0) { historyContainer.innerHTML = 'Zatím žádná historie nálad. Vygenerujte si svůj první playlist!
'; return; } const recentHistory = currentUser.moodHistory.slice(-5).reverse(); historyContainer.innerHTML = recentHistory.map(entry => ` ${entry.detectedMood} - ${new Date(entry.timestamp).toLocaleDateString()} ${entry.text}
 ${entry.playlistGenerated.length} vygenerovaných skladeb ` ).join(''); } async function generatePersonalizedPlaylist() { const moodText = document.getElementById('moodText').value; if (!moodText.trim()) { alert('Popište prosím, jak se cítíte!'); 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 || 'Nepodařilo se vygenerovat playlist'); } } catch (error) { console.error('Chyba při generování playlistu:', error); alert('Nepodařilo se vygenerovat playlist. Zkuste to prosím znovu.'); } } function displayPersonalizedResults(data) { const resultDiv = document.getElementById('result'); resultDiv.style.display = 'block'; const html = ` Zjištěná nálada: ${data.moodAnalysis.mood} (Spolehlivost: ${data.moodAnalysis.confidence}/10)
 ${data.personalizedMessage || 'Zde je váš playlist!'}
  ${data.playlist.map(track => `  ${track.album_image ? `` : ''}  ${název skladby}
${track.artist}   
 
 `).join('')} 
 `; 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 ? 'Díky! Budeme doporučovat další podobné skladby.' : 'Rozumím! Budeme se podobným skladbám vyhýbat.'); } catch (error) { console.error('Chyba zpětné vazby:', error); } } function logout() { localStorage.removeItem('authToken'); authToken = null; currentUser = null; document.getElementById('authSection').style.display = 'block'; document.getElementById('dashboardSection').style.display = 'none'; showLogin();

Nahraďte soubor server.js

Nahraďte kód souboru server.js následujícím:

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'); // Připojení k MongoDB const connectDB = async () => { try { console.log('🔗 Připojování k MongoDB...'); await mongoose.connect(process.env.MONGODB_URI, { useNewUrlParser: true, useUnifiedTopology: true, }); console.log('✅ MongoDB úspěšně připojeno!'); } catch (error) { console.error('❌ Připojení k MongoDB se nezdařilo:', 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')); // Zobrazení hlavní stránky app.get('/', (req, res) => { res.sendFile(__dirname + '/public/index.html'); }); // Registrace uživatele app.post('/api/register', async (req, res) => { try { const { uživatelské_jméno, e-mail, heslo } = req.body; if (! uživatelské_jméno || !email || !heslo) { return res.status(400).json({ chyba: 'Všechna pole jsou povinná' }); } if (password.length < 6) { return res.status(400).json({ chyba: 'Heslo musí mít alespoň 6 znaků' }); } const existingUser = await User.findOne({ $or: {[ email }, { uživatelské_jméno }] }); if (existingUser) { return res.status(400).json({ chyba: 'Uživatelské_jméno nebo e-mail již existuje' }); } const user = new User({ uživatelské_jméno, e-mail, heslo }); await user.save(); res.status(201).json({ zpráva: 'Uživatel úspěšně vytvořen' }); } catch (error) { console.error('Chyba registrace:', error); res.status(500).json({ chyba: 'Registrace selhala' }); } }); // Přihlášení uživatele app.post('/api/login', async (req, res) => { try { const { uživatelské_jméno, heslo } = req.body; const uživatel = await User.findOne({ $or: {[ uživatelské_jméno }, { email: uživatelské_jméno }] }); if (!user || !(await user.comparePassword(heslo))) { return res.status(401).json({ chyba: 'Neplatné přihlašovací údaje' }); } const token = jwt.sign( { userId: user._id }, process.env.JWT_SECRET, { expiresIn: '7d' } ); res.json({ token, uživatel: { uživatelské_jméno: user.username, email: user.email } }); } catch (error) { console.error('Chyba přihlášení:', error); res.status(500).json({ chyba: 'Přihlášení se nezdařilo' }); } }); // Získání uživatelského profilu 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({ chyba: 'Načtení profilu se nezdařilo' }); } }); // Generování personalizovaného playlistu app.post('/api/personalized-playlist', auth, async (req, res) => { try { const { text, playlistSize = 15 } = req.body; if (!text) { return res.status(400).json({ error: 'Prosím, řekněte mi, jak se cítíte!' }); } const moodAnalysis = moodAnalyzer.analyzeMood(text); const playlist = await playlistGen.generatePlaylist(moodAnalysis.mood, moodAnalysis.intensity, playlistSize ); // Uložení do historie uživatele 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: `Na základě vaší historie jsem tento playlist upravil speciálně pro vaši náladu v ${moodAnalysis.mood}!` }); } catch (error) { console.error('Chyba personalizovaného playlistu:', error); res.status(500).json({ error: 'Nepodařilo se vygenerovat personalizovaný playlist. Zkuste to prosím znovu.' }); } }); // Zpětná vazba ke skladbě app.post('/api/track-feedback', auth, async (req, res) => { try { const { trackId, liked } = req.body; res.json({ message: 'Zpětná vazba přijata! V budoucnu vylepšíme doporučení.' }); } catch (error) { console.error('Chyba zpětné vazby:', error); res.status(500).json({ error: 'Zpětnou vazbu se nepodařilo zpracovat' }); } }); app.listen(PORT, () => { console.log(`🚀 API pro čtení myšlenek běží na http://localhost:${PORT}`); console.log('🧠 Připraveno analyzovat nálady a generovat playlisty!'); });

Co byste nyní měli umět

1. Anonymní uživatelé (původní funkce)

Navštivte svůj web bez přihlášení
Generujte playlisty pomocí vaší stávající analýzy nálady
Získejte hudební doporučení na základě emocí

2. Registrovaní uživatelé (nové funkce)

Vytvořte si účet a přihlaste se
Generujte personalizované playlisty, které se časem zlepšují
Zobrazte historii nálad a osobní analýzy
Označte skladby, které se vám líbí/nelíbí, pro trénování umělé inteligence
Zobrazte statistiky, jako je oblíbená nálada, celkový počet playlistů atd.

Podrobný průvodce testováním

Test 1: Zkontrolujte spuštění serveru

node server.js

Měli byste vidět:

🔑 Pokus o ověření Spotify... 🎵 Spotify se úspěšně připojilo! 🔗 Připojování k MongoDB... ✅ Připojení k MongoDB úspěšné! 🚀 API pro čtení myšlenek běží na http://localhost:3000 🧠 Připraveno analyzovat nálady a generovat playlisty!

Test 2: Navštivte své webové stránky

Přejděte na: http://localhost:3000

Co byste měli vidět:

Přihlašovací formulář s dotazem na uživatelské jméno/heslo
Odkaz „Nemáte účet? Zaregistrujte se“

Test 3: Vytvořte si první účet

Klikněte: „Nemáte účet? Zaregistrujte se“
Vyplňte:
- Uživatelské jméno: testuser
- E-mail: test@example.com
- Heslo: password123
Klikněte na: „Vytvořit účet“
Očekávaný výsledek: „Účet byl úspěšně vytvořen! Přihlaste se.“

Test 4: Přihlaste se do svého řídicího panelu

Použijte přihlašovací údaje, které jste právě vytvořili
Klikněte na: „Přihlásit se“
Měli byste vidět:
- Uvítací zpráva s vaším uživatelským jménem
- Karty se statistikami zobrazující 0 seznamů skladeb, zatím žádnou oblíbenou náladu
- Textové pole s otázkou „Jak se právě teď cítíte?“

Test 5: Vytvořte si svůj první personalizovaný seznam skladeb

Napište něco jako: „Jsem nadšený ze svého nového projektu!“
Klikněte: „Vygenerovat můj perfektní playlist“
Měli byste vidět:
- Zjištěnou náladu (pravděpodobně „energická“ nebo „šťastná“)
- Seznam skladeb s obalem alba
- Náhled audio přehrávačů (pokud jsou k dispozici)
- Tlačítka palce nahoru/dolů pro každou skladbu

Test 6: Otestujte systém učení

Klikněte na palec nahoru 👍 u skladeb, které se vám líbí
Klikněte na palec dolů 👎 u skladeb, které se vám nelíbí
Očekává se: Upozornění „Děkujeme! Doporučíme vám další podobné skladby“

Test 7: Zkontrolujte aktualizaci statistik

Obnovit stránka nebo vygenerovat další playlist
Vaše statistiky by nyní měly zobrazovat:
- Celkem playlistů: 1 (nebo více)
- Oblíbená nálada: jakákoli zjištěná nálada
- Měly by se začít zobrazovat další statistiky

Testování různých scénářů

Vyzkoušejte různé nálady:

„Právě jsem se rozešel s přítelkyní a prší“ (mělo by být zjištěno: smutné)
„Jsem nabuzený na trénink!“ (mělo by být detekováno: energické)
„Chci si jen odpočinout a tiše se učit“ (mělo by být detekováno: klid)
„V tuto noc na rande se cítím romanticky“ (mělo by být detekováno: romantické)

Testovací okrajové případy:

„“ (prázdné - mělo by se zobrazit chyba)
„asdf náhodný text“ (mělo by být nastaveno na neutrální/klidné)
„Jsem NESMIREČNĚ nadšený!!!“ (mělo by dojít k vyšší spolehlivosti)

Běžné problémy a rychlé opravy

❌ "Připojení k MongoDB selhalo"

Kontrola: Je váš soubor .env správně nastaven s připojovacím řetězcem MongoDB?

# Spusťte toto pro otestování uzlu připojení k databázi -e "require('dotenv').config(); console.log('MONGODB_URI:', process.env.MONGODB_URI ? 'Set ✅' : 'Missing ❌');"

❌ „Připojení ke Spotify selhalo“

Zkontrolujte: Jsou vaše klíče Spotify API v souboru .env?

# Spusťte toto pro kontrolu přihlašovacích údajů Spotify node -e "require('dotenv').config(); console.log('ID klienta Spotify:', process.env.SPOTIFY_CLIENT_ID ? 'Set ✅' : 'Chybí ❌');"

❌ Přihlášení/registrace nefunguje

Kontrola: Vidíte v konzoli prohlížeče nějaké chybové zprávy?

Stiskněte F12 → karta Konzole
Hledejte červené chybové zprávy

❌ Stránka zobrazuje staré rozhraní

Řešení: Aktualizujte stránku

Stiskněte Ctrl+Shift+R (Windows/Linux)
Stiskněte Cmd+Shift+R (Mac)

Co by mělo fungovat vs. co je stále základní

✅ Mělo by fungovat nyní:

Registrace a přihlášení uživatele
Základní detekce nálady a generování playlistů
Ukládání historie nálad do databáze
Jednoduchá zpětná vazba lajků/nelajků
Sledování statistik (celkový počet playlistů, oblíbená nálada)

🚧 Stále základní (pokročilé funkce na později):

Komplexní strojové učení z uživatelské zpětné vazby
Sociální funkce a sdílení playlistů
Pokročilá analytika a vzorce nálad
Rozhraní mobilní aplikace

Další kroky po testování

Jakmile vše funguje:

Vyzkoušejte s různými uživateli - vytvořte více účtů, abyste viděli, jak se personalizace liší
Vygenerujte více playlistů - sledujte, jak se vaše statistiky a preference vyvíjejí
Poskytněte zpětnou vazbu ke skladbám - sledujte, jak se systém učí vašemu vkusu
Zkontrolujte svůj dashboard MongoDB Atlas - měli byste vidět ukládaná data

Závěr

Právě jste vytvořili něco pozoruhodného - umělou inteligenci, která nejen rozumí lidským emocím, ale se v průběhu času učí a přizpůsobuje individuálním preferencím. Vaše rozhraní API pro čtení myšlenek nyní disponuje pamětí, osobností a schopností růst se svými uživateli.

Kombinace detekce nálady, učení uživatelů a personalizovaných doporučení vytváří zážitek, který je s každou interakcí magičtější. Cesta každého uživatele se stává jedinečnou a vytváří osobní soundtrack k jeho emocionálnímu životu.

Vaše rozhraní API si nyní pamatuje každou náladu, učí se z každé interakce a vytváří komplexní pochopení hudebních preferencí každého uživatele. To je základ pro skutečně personalizované zážitky s umělou inteligencí.

Co bude dál?

Jste připraveni jít ještě dál? Zde je několik zajímavých směrů:

Pokročilá analytika: Přidejte rozpoznávání nálad a prediktivní doporučení
Sociální funkce: Umožněte uživatelům sdílet playlisty a objevovat hudební vkus přátel
Mobilní aplikace: Vytvářejte aplikace React Native nebo Flutter pro iOS/Android
Integrace hlasu: Přidejte převod řeči na text pro hands-free zadávání nálad
Strojové učení: Implementujte kolaborativní filtrování pro ještě lepší doporučení
Nasazení: Nasazení do AWS/Vercel se správnými proměnnými prostředí

Neustále experimentujte a vytvářejte – budoucnost personalizovaných zážitků s umělou inteligencí je ve vašich rukou!

Jste připraveni na další výzvu? Zůstaňte naladěni na náš nadcházející tutoriál o přidávání sociálních funkcí a kolaborativním filtrování k vytvoření sítě pro objevování hudby, která propojuje lidi prostřednictvím sdílených emocionálních zážitků.