-
-
+
+
+
+
-
-
-
-
- | ID |
- Nom d'utilisateur |
- Admin |
- Créé le |
- Actions |
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+ | ID |
+ Nom d'utilisateur |
+ Admin |
+ Créé le |
+ Actions |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/public/js/complete-app.js b/public/js/complete-app.js
index 88620dd..ac1bd7e 100644
--- a/public/js/complete-app.js
+++ b/public/js/complete-app.js
@@ -1160,6 +1160,34 @@ function setupSearch() {
}
// ==================== ADMIN ====================
+
+// Tab switching
+function switchAdminTab(tabName) {
+ // Update tab buttons
+ document.querySelectorAll('.admin-tab').forEach(btn => {
+ btn.classList.toggle('active', btn.dataset.tab === tabName);
+ });
+
+ // Update tab content
+ document.querySelectorAll('.admin-tab-content').forEach(content => {
+ content.style.display = 'none';
+ });
+
+ const targetTab = document.getElementById(`tab-${tabName}`);
+ if (targetTab) {
+ targetTab.style.display = 'block';
+ }
+
+ // Load data for the selected tab
+ if (tabName === 'users') {
+ loadUsers();
+ } else if (tabName === 'rss') {
+ loadRssFeeds();
+ } else if (tabName === 'openrouter') {
+ loadOpenRouterSettings();
+ }
+}
+
async function loadUsers() {
try {
const users = await api.get('/api/users');
@@ -1200,7 +1228,9 @@ async function openAdminModal() {
modal.style.display = 'flex';
setTimeout(() => modal.classList.add('active'), 10);
- await loadUsers();
+
+ // Switch to users tab by default
+ switchAdminTab('users');
}
function closeAdminModal() {
@@ -1248,32 +1278,74 @@ async function createUser() {
}
}
-async function changeUserPassword(id, username) {
- const password = prompt(`Nouveau mot de passe pour "${username}" :`);
+// Password Change Modal
+let currentPasswordChangeUserId = null;
+let currentPasswordChangeUsername = null;
- if (!password) return;
+function openPasswordChangeModal(userId, username) {
+ currentPasswordChangeUserId = userId;
+ currentPasswordChangeUsername = username;
- if (password.length < 6) {
+ const modal = document.getElementById('changePasswordModal');
+ const usernameDisplay = document.getElementById('changePasswordUsername');
+ const newPasswordInput = document.getElementById('newPassword');
+ const confirmPasswordInput = document.getElementById('confirmPassword');
+
+ if (usernameDisplay) {
+ usernameDisplay.textContent = `Modifier le mot de passe de "${username}"`;
+ }
+
+ if (newPasswordInput) newPasswordInput.value = '';
+ if (confirmPasswordInput) confirmPasswordInput.value = '';
+
+ modal.style.display = 'flex';
+ setTimeout(() => modal.classList.add('active'), 10);
+
+ if (newPasswordInput) newPasswordInput.focus();
+}
+
+function closePasswordChangeModal() {
+ const modal = document.getElementById('changePasswordModal');
+ modal.classList.remove('active');
+ setTimeout(() => {
+ modal.style.display = 'none';
+ }, 300);
+
+ currentPasswordChangeUserId = null;
+ currentPasswordChangeUsername = null;
+}
+
+async function confirmPasswordChange() {
+ const newPasswordInput = document.getElementById('newPassword');
+ const confirmPasswordInput = document.getElementById('confirmPassword');
+
+ const newPassword = newPasswordInput.value;
+ const confirmPassword = confirmPasswordInput.value;
+
+ if (!newPassword || newPassword.length < 6) {
alert('Le mot de passe doit contenir au moins 6 caractères');
return;
}
- const confirmPassword = prompt('Confirmer le nouveau mot de passe :');
-
- if (password !== confirmPassword) {
+ if (newPassword !== confirmPassword) {
alert('Les mots de passe ne correspondent pas');
return;
}
try {
- await api.put(`/api/users/${id}`, { password });
+ await api.put(`/api/users/${currentPasswordChangeUserId}`, { password: newPassword });
alert('Mot de passe modifié avec succès');
+ closePasswordChangeModal();
} catch (error) {
console.error('Erreur modification mot de passe:', error);
alert('Erreur lors de la modification du mot de passe');
}
}
+async function changeUserPassword(id, username) {
+ openPasswordChangeModal(id, username);
+}
+
async function deleteUser(id, username) {
const confirmed = await confirmDialog.show({
icon: '⚠️',
@@ -1294,13 +1366,299 @@ async function deleteUser(id, username) {
}
}
+// ==================== RSS FEEDS ====================
+async function loadRssFeeds() {
+ try {
+ const feeds = await api.get('/api/rss/feeds');
+ renderRssFeeds(feeds);
+ } catch (error) {
+ console.error('Erreur chargement flux RSS:', error);
+ alert('Erreur lors du chargement des flux RSS');
+ }
+}
+
+function renderRssFeeds(feeds) {
+ const container = document.getElementById('rssFeedsList');
+ if (!container) return;
+
+ if (feeds.length === 0) {
+ container.innerHTML = '
Aucun flux RSS configuré
';
+ return;
+ }
+
+ container.innerHTML = feeds.map(feed => `
+
+ `).join('');
+}
+
+async function addRssFeed() {
+ const input = document.getElementById('rssUrlInput');
+ const url = input.value.trim();
+
+ if (!url) {
+ alert('Veuillez entrer une URL de flux RSS');
+ return;
+ }
+
+ if (!url.startsWith('http://') && !url.startsWith('https://')) {
+ alert('L\'URL doit commencer par http:// ou https://');
+ return;
+ }
+
+ try {
+ await api.post('/api/rss/feeds', { url });
+ input.value = '';
+ alert('Flux RSS ajouté avec succès');
+ await loadRssFeeds();
+ } catch (error) {
+ console.error('Erreur ajout flux RSS:', error);
+ alert('Erreur lors de l\'ajout du flux RSS. Vérifiez l\'URL.');
+ }
+}
+
+async function toggleRssFeed(feedId, enabled) {
+ try {
+ await api.put(`/api/rss/feeds/${feedId}`, { enabled });
+ } catch (error) {
+ console.error('Erreur toggle flux RSS:', error);
+ alert('Erreur lors de la modification du flux RSS');
+ }
+}
+
+async function deleteRssFeed(feedId) {
+ const confirmed = await confirmDialog.show({
+ icon: '📰',
+ title: 'Supprimer ce flux RSS',
+ message: 'Êtes-vous sûr de vouloir supprimer ce flux RSS ?\n\nTous les articles associés seront également supprimés.',
+ okText: 'Supprimer'
+ });
+
+ if (!confirmed) return;
+
+ try {
+ await api.delete(`/api/rss/feeds/${feedId}`);
+ alert('Flux RSS supprimé avec succès');
+ await loadRssFeeds();
+ } catch (error) {
+ console.error('Erreur suppression flux RSS:', error);
+ alert('Erreur lors de la suppression du flux RSS');
+ }
+}
+
+async function fetchRssArticles() {
+ const btn = document.getElementById('fetchRssBtn');
+ if (!btn) return;
+
+ const originalText = btn.textContent;
+ btn.disabled = true;
+ btn.textContent = '🔄 Récupération en cours...';
+
+ try {
+ const result = await api.post('/api/rss/fetch', {});
+ alert(result.message || 'Articles récupérés avec succès');
+ await loadRssArticles();
+ } catch (error) {
+ console.error('Erreur fetch articles RSS:', error);
+ alert('Erreur lors de la récupération des articles RSS');
+ } finally {
+ btn.disabled = false;
+ btn.textContent = originalText;
+ }
+}
+
+async function loadRssArticles() {
+ try {
+ const articles = await api.get('/api/rss/articles');
+ renderRssArticles(articles);
+ } catch (error) {
+ console.error('Erreur chargement articles RSS:', error);
+ }
+}
+
+function renderRssArticles(articles) {
+ const container = document.getElementById('rssArticlesList');
+ if (!container) return;
+
+ if (!articles || articles.length === 0) {
+ container.innerHTML = '';
+ return;
+ }
+
+ container.innerHTML = articles.map(article => `
+
+
${escapeHtml(article.title)}
+
+ ${escapeHtml(article.feed_title)}
+ ${new Date(article.pub_date).toLocaleDateString('fr-FR')}
+
+ ${article.description ? `
${escapeHtml(article.description)}
` : ''}
+
+ `).join('');
+}
+
+async function summarizeRss() {
+ const btn = document.getElementById('summarizeRssBtn');
+ if (!btn) return;
+
+ const originalHTML = btn.innerHTML;
+ btn.disabled = true;
+ btn.innerHTML = '
';
+
+ try {
+ const result = await api.post('/api/rss/summarize', {});
+
+ // Create a new note with the summary
+ const newNote = await api.post('/api/notes', {
+ title: `📰 Résumé RSS - ${new Date().toLocaleDateString('fr-FR')}`,
+ content: result.summary
+ });
+
+ alert('Résumé généré et sauvegardé dans une nouvelle note !');
+ await loadNotes();
+
+ // Expand the new note
+ state.expandedNoteId = newNote.id;
+ renderNotes();
+ } catch (error) {
+ console.error('Erreur génération résumé RSS:', error);
+ if (error.message && error.message.includes('400')) {
+ alert('Veuillez configurer votre clé API OpenRouter dans l\'administration');
+ } else {
+ alert('Erreur lors de la génération du résumé RSS');
+ }
+ } finally {
+ btn.disabled = false;
+ btn.innerHTML = originalHTML;
+ }
+}
+
+// ==================== OPENROUTER ====================
+let allModels = [];
+
+async function loadOpenRouterSettings() {
+ try {
+ const settings = await api.get('/api/settings');
+ const models = await api.get('/api/rss/models');
+
+ allModels = models;
+
+ // Populate form
+ const apiKeyInput = document.getElementById('openrouterApiKey');
+ const modelSelect = document.getElementById('openrouterModel');
+ const summaryEnabled = document.getElementById('rssSummaryEnabled');
+ const summaryPrompt = document.getElementById('rssSummaryPrompt');
+
+ if (apiKeyInput) {
+ apiKeyInput.value = settings.openrouter_api_key || '';
+ }
+
+ if (summaryEnabled) {
+ summaryEnabled.checked = settings.rss_summary_enabled === 'true' || settings.rss_summary_enabled === '1';
+ }
+
+ if (summaryPrompt) {
+ summaryPrompt.value = settings.rss_summary_prompt || `Tu es un assistant spécialisé dans la synthèse d'actualités. Analyse les articles suivants et crée un résumé structuré et informatif.
+
+Pour chaque article, identifie:
+- Le sujet principal
+- Les points clés
+- L'importance de l'information
+
+Ensuite, génère un résumé global qui:
+1. Regroupe les thèmes communs
+2. Hiérarchise les informations par importance
+3. Présente une vue d'ensemble claire et concise
+4. Utilise un style professionnel mais accessible
+
+Format de sortie en Markdown avec des sections claires.`;
+ }
+
+ // Populate model selector
+ renderModelSelect(models, settings.openrouter_model);
+
+ } catch (error) {
+ console.error('Erreur chargement paramètres OpenRouter:', error);
+ }
+}
+
+function renderModelSelect(models, selectedModel) {
+ const select = document.getElementById('openrouterModel');
+ if (!select) return;
+
+ select.innerHTML = models.map(model => `
+
+ `).join('');
+}
+
+function filterModels() {
+ const searchInput = document.getElementById('modelSearch');
+ const select = document.getElementById('openrouterModel');
+
+ if (!searchInput || !select) return;
+
+ const query = searchInput.value.toLowerCase();
+
+ if (!query) {
+ renderModelSelect(allModels, select.value);
+ return;
+ }
+
+ const filtered = allModels.filter(model =>
+ model.name.toLowerCase().includes(query) ||
+ model.provider.toLowerCase().includes(query) ||
+ model.id.toLowerCase().includes(query)
+ );
+
+ renderModelSelect(filtered, select.value);
+}
+
+async function saveOpenRouterSettings() {
+ const apiKeyInput = document.getElementById('openrouterApiKey');
+ const modelSelect = document.getElementById('openrouterModel');
+ const summaryEnabled = document.getElementById('rssSummaryEnabled');
+ const summaryPrompt = document.getElementById('rssSummaryPrompt');
+
+ try {
+ // Save all settings
+ await api.put('/api/settings/openrouter_api_key', { value: apiKeyInput.value });
+ await api.put('/api/settings/openrouter_model', { value: modelSelect.value });
+ await api.put('/api/settings/rss_summary_enabled', { value: summaryEnabled.checked ? '1' : '0' });
+ await api.put('/api/settings/rss_summary_prompt', { value: summaryPrompt.value });
+
+ alert('Paramètres OpenRouter sauvegardés avec succès');
+ } catch (error) {
+ console.error('Erreur sauvegarde paramètres OpenRouter:', error);
+ alert('Erreur lors de la sauvegarde des paramètres');
+ }
+}
+
// ==================== INIT ====================
async function init() {
// Vérifier l'authentification
await initAuth();
// Charger les données
- await Promise.all([loadNotes(), loadTodos()]);
+ await Promise.all([loadNotes(), loadTodos(), loadRssArticles()]);
// Setup search
setupSearch();
@@ -1584,10 +1942,110 @@ async function init() {
collapseNote();
} else {
closeNoteModal();
- document.getElementById('adminModal').style.display = 'none';
+ closeAdminModal();
+ closePasswordChangeModal();
}
}
});
+
+ // ==================== ADMIN TAB SWITCHING ====================
+ document.querySelectorAll('.admin-tab').forEach(tab => {
+ tab.addEventListener('click', () => {
+ switchAdminTab(tab.dataset.tab);
+ });
+ });
+
+ // ==================== PASSWORD CHANGE MODAL ====================
+ const closePasswordModal = document.getElementById('closeChangePasswordModal');
+ if (closePasswordModal) {
+ closePasswordModal.addEventListener('click', closePasswordChangeModal);
+ }
+
+ const cancelPasswordChange = document.getElementById('cancelChangePassword');
+ if (cancelPasswordChange) {
+ cancelPasswordChange.addEventListener('click', closePasswordChangeModal);
+ }
+
+ const confirmPasswordBtn = document.getElementById('confirmChangePassword');
+ if (confirmPasswordBtn) {
+ confirmPasswordBtn.addEventListener('click', confirmPasswordChange);
+ }
+
+ // Enter key to confirm password change
+ const newPasswordInput = document.getElementById('newPassword');
+ const confirmPasswordInput = document.getElementById('confirmPassword');
+ if (newPasswordInput && confirmPasswordInput) {
+ [newPasswordInput, confirmPasswordInput].forEach(input => {
+ input.addEventListener('keypress', (e) => {
+ if (e.key === 'Enter') confirmPasswordChange();
+ });
+ });
+ }
+
+ // ==================== RSS FEEDS ====================
+ const addRssFeedBtn = document.getElementById('addRssFeedBtn');
+ if (addRssFeedBtn) {
+ addRssFeedBtn.addEventListener('click', addRssFeed);
+ }
+
+ const rssUrlInput = document.getElementById('rssUrlInput');
+ if (rssUrlInput) {
+ rssUrlInput.addEventListener('keypress', (e) => {
+ if (e.key === 'Enter') addRssFeed();
+ });
+ }
+
+ const fetchRssBtn = document.getElementById('fetchRssBtn');
+ if (fetchRssBtn) {
+ fetchRssBtn.addEventListener('click', fetchRssArticles);
+ }
+
+ // Event delegation for RSS feeds list
+ const rssFeedsList = document.getElementById('rssFeedsList');
+ if (rssFeedsList) {
+ rssFeedsList.addEventListener('change', (e) => {
+ if (e.target.type === 'checkbox' && e.target.dataset.feedId) {
+ const feedId = parseInt(e.target.dataset.feedId);
+ toggleRssFeed(feedId, e.target.checked);
+ }
+ });
+
+ rssFeedsList.addEventListener('click', (e) => {
+ const deleteBtn = e.target.closest('.btn-delete-feed');
+ if (deleteBtn) {
+ const feedId = parseInt(deleteBtn.dataset.feedId);
+ deleteRssFeed(feedId);
+ }
+ });
+ }
+
+ // RSS articles click to open in new tab
+ const rssArticlesList = document.getElementById('rssArticlesList');
+ if (rssArticlesList) {
+ rssArticlesList.addEventListener('click', (e) => {
+ const article = e.target.closest('.rss-article');
+ if (article && article.dataset.link) {
+ window.open(article.dataset.link, '_blank');
+ }
+ });
+ }
+
+ // RSS summarize button
+ const summarizeRssBtn = document.getElementById('summarizeRssBtn');
+ if (summarizeRssBtn) {
+ summarizeRssBtn.addEventListener('click', summarizeRss);
+ }
+
+ // ==================== OPENROUTER ====================
+ const modelSearch = document.getElementById('modelSearch');
+ if (modelSearch) {
+ modelSearch.addEventListener('input', utils.debounce(filterModels, 300));
+ }
+
+ const saveOpenRouterBtn = document.getElementById('saveOpenRouterSettings');
+ if (saveOpenRouterBtn) {
+ saveOpenRouterBtn.addEventListener('click', saveOpenRouterSettings);
+ }
}
// Démarrer l'application
diff --git a/routes/rss.routes.js b/routes/rss.routes.js
new file mode 100644
index 0000000..a882668
--- /dev/null
+++ b/routes/rss.routes.js
@@ -0,0 +1,324 @@
+// Routes de gestion des flux RSS
+const express = require('express');
+const router = express.Router();
+const Parser = require('rss-parser');
+const axios = require('axios');
+const { getAll, getOne, runQuery } = require('../config/database');
+const { authenticateToken, requireAdmin } = require('../middleware/auth');
+const logger = require('../config/logger');
+
+const parser = new Parser();
+
+// Routes admin (gestion des flux)
+router.use(authenticateToken);
+
+/**
+ * GET /api/rss/feeds
+ * Liste tous les flux RSS
+ */
+router.get('/feeds', requireAdmin, async (req, res) => {
+ try {
+ const feeds = await getAll('SELECT * FROM rss_feeds ORDER BY created_at DESC');
+ res.json(feeds || []);
+ } catch (error) {
+ logger.error('Erreur lors de la récupération des flux RSS:', error);
+ res.status(500).json({ error: 'Erreur serveur' });
+ }
+});
+
+/**
+ * POST /api/rss/feeds
+ * Ajouter un nouveau flux RSS
+ */
+router.post('/feeds', requireAdmin, async (req, res) => {
+ try {
+ const { url } = req.body;
+
+ if (!url) {
+ return res.status(400).json({ error: 'URL requise' });
+ }
+
+ // Vérifier si le flux existe déjà
+ const existing = await getOne('SELECT id FROM rss_feeds WHERE url = ?', [url]);
+ if (existing) {
+ return res.status(409).json({ error: 'Ce flux existe déjà' });
+ }
+
+ // Tester le flux
+ try {
+ const feed = await parser.parseURL(url);
+
+ // Ajouter le flux
+ const result = await runQuery(
+ 'INSERT INTO rss_feeds (url, title, description) VALUES (?, ?, ?)',
+ [url, feed.title || url, feed.description || '']
+ );
+
+ logger.info(`Flux RSS ajouté: ${feed.title} (${url})`);
+
+ res.json({
+ id: result.id,
+ url,
+ title: feed.title || url,
+ description: feed.description || '',
+ enabled: 1
+ });
+ } catch (parseError) {
+ logger.error('Erreur lors du parsing du flux RSS:', parseError);
+ return res.status(400).json({ error: 'Impossible de parser ce flux RSS. Vérifiez l\'URL.' });
+ }
+ } catch (error) {
+ logger.error('Erreur lors de l\'ajout du flux RSS:', error);
+ res.status(500).json({ error: 'Erreur serveur' });
+ }
+});
+
+/**
+ * PUT /api/rss/feeds/:id
+ * Mettre à jour un flux RSS (activer/désactiver)
+ */
+router.put('/feeds/:id', requireAdmin, async (req, res) => {
+ try {
+ const { enabled } = req.body;
+
+ await runQuery(
+ 'UPDATE rss_feeds SET enabled = ? WHERE id = ?',
+ [enabled ? 1 : 0, req.params.id]
+ );
+
+ logger.info(`Flux RSS ${enabled ? 'activé' : 'désactivé'}: ${req.params.id}`);
+ res.json({ message: 'Flux mis à jour avec succès' });
+ } catch (error) {
+ logger.error('Erreur lors de la mise à jour du flux RSS:', error);
+ res.status(500).json({ error: 'Erreur serveur' });
+ }
+});
+
+/**
+ * DELETE /api/rss/feeds/:id
+ * Supprimer un flux RSS
+ */
+router.delete('/feeds/:id', requireAdmin, async (req, res) => {
+ try {
+ await runQuery('DELETE FROM rss_feeds WHERE id = ?', [req.params.id]);
+
+ logger.info(`Flux RSS supprimé: ${req.params.id}`);
+ res.json({ message: 'Flux supprimé avec succès' });
+ } catch (error) {
+ logger.error('Erreur lors de la suppression du flux RSS:', error);
+ res.status(500).json({ error: 'Erreur serveur' });
+ }
+});
+
+/**
+ * POST /api/rss/fetch
+ * Récupérer tous les articles des flux actifs
+ */
+router.post('/fetch', requireAdmin, async (req, res) => {
+ try {
+ const feeds = await getAll('SELECT * FROM rss_feeds WHERE enabled = 1');
+
+ let totalArticles = 0;
+
+ for (const feed of feeds) {
+ try {
+ const parsedFeed = await parser.parseURL(feed.url);
+
+ // Mettre à jour les infos du flux
+ await runQuery(
+ 'UPDATE rss_feeds SET title = ?, description = ?, last_fetched_at = CURRENT_TIMESTAMP WHERE id = ?',
+ [parsedFeed.title || feed.url, parsedFeed.description || '', feed.id]
+ );
+
+ // Ajouter les articles
+ for (const item of parsedFeed.items) {
+ try {
+ // Vérifier si l'article existe déjà
+ const existing = await getOne('SELECT id FROM rss_articles WHERE link = ?', [item.link]);
+
+ if (!existing) {
+ await runQuery(
+ 'INSERT INTO rss_articles (feed_id, title, link, description, pub_date, content) VALUES (?, ?, ?, ?, ?, ?)',
+ [
+ feed.id,
+ item.title || '',
+ item.link || '',
+ item.contentSnippet || item.description || '',
+ item.pubDate || item.isoDate || new Date().toISOString(),
+ item.content || item['content:encoded'] || ''
+ ]
+ );
+ totalArticles++;
+ }
+ } catch (articleError) {
+ // Ignorer les articles en double ou invalides
+ logger.warn(`Erreur lors de l'ajout d'un article: ${articleError.message}`);
+ }
+ }
+ } catch (feedError) {
+ logger.error(`Erreur lors du fetch du flux ${feed.url}:`, feedError);
+ }
+ }
+
+ logger.info(`${totalArticles} nouveaux articles récupérés`);
+ res.json({ message: `${totalArticles} nouveaux articles récupérés` });
+ } catch (error) {
+ logger.error('Erreur lors du fetch des flux RSS:', error);
+ res.status(500).json({ error: 'Erreur serveur' });
+ }
+});
+
+/**
+ * GET /api/rss/articles
+ * Récupérer les 10 derniers articles
+ */
+router.get('/articles', async (req, res) => {
+ try {
+ const articles = await getAll(`
+ SELECT
+ a.id, a.title, a.link, a.description, a.pub_date, a.content,
+ f.title as feed_title, f.url as feed_url
+ FROM rss_articles a
+ JOIN rss_feeds f ON a.feed_id = f.id
+ ORDER BY a.pub_date DESC
+ LIMIT 10
+ `);
+
+ res.json(articles || []);
+ } catch (error) {
+ logger.error('Erreur lors de la récupération des articles RSS:', error);
+ res.status(500).json({ error: 'Erreur serveur' });
+ }
+});
+
+/**
+ * POST /api/rss/summarize
+ * Générer un résumé des 10 derniers articles avec OpenRouter
+ */
+router.post('/summarize', requireAdmin, async (req, res) => {
+ try {
+ // Récupérer les paramètres
+ const apiKey = await getOne('SELECT value FROM settings WHERE key = ?', ['openrouter_api_key']);
+ const model = await getOne('SELECT value FROM settings WHERE key = ?', ['openrouter_model']);
+ const prompt = await getOne('SELECT value FROM settings WHERE key = ?', ['rss_summary_prompt']);
+
+ if (!apiKey || !apiKey.value) {
+ return res.status(400).json({ error: 'Clé API OpenRouter non configurée' });
+ }
+
+ // Récupérer les 10 derniers articles
+ const articles = await getAll(`
+ SELECT
+ a.title, a.description, a.link, a.pub_date,
+ f.title as feed_title
+ FROM rss_articles a
+ JOIN rss_feeds f ON a.feed_id = f.id
+ ORDER BY a.pub_date DESC
+ LIMIT 10
+ `);
+
+ if (articles.length === 0) {
+ return res.status(400).json({ error: 'Aucun article à résumer' });
+ }
+
+ // Construire le prompt
+ const defaultPrompt = prompt?.value || `Tu es un assistant spécialisé dans la synthèse d'actualités. Analyse les articles suivants et crée un résumé structuré et informatif.
+
+Pour chaque article, identifie:
+- Le sujet principal
+- Les points clés
+- L'importance de l'information
+
+Ensuite, génère un résumé global qui:
+1. Regroupe les thèmes communs
+2. Hiérarchise les informations par importance
+3. Présente une vue d'ensemble claire et concise
+4. Utilise un style professionnel mais accessible
+
+Format de sortie en Markdown avec des sections claires.`;
+
+ const articlesText = articles.map((a, i) =>
+ `## Article ${i + 1}: ${a.title}\n**Source**: ${a.feed_title}\n**Date**: ${new Date(a.pub_date).toLocaleDateString('fr-FR')}\n**Description**: ${a.description}\n**Lien**: ${a.link}\n`
+ ).join('\n---\n');
+
+ const fullPrompt = `${defaultPrompt}\n\n# Articles à résumer:\n\n${articlesText}`;
+
+ // Appeler OpenRouter
+ const selectedModel = model?.value || 'openai/gpt-3.5-turbo';
+
+ logger.info(`Génération du résumé avec le modèle ${selectedModel}...`);
+
+ const response = await axios.post(
+ 'https://openrouter.ai/api/v1/chat/completions',
+ {
+ model: selectedModel,
+ messages: [
+ {
+ role: 'user',
+ content: fullPrompt
+ }
+ ]
+ },
+ {
+ headers: {
+ 'Authorization': `Bearer ${apiKey.value}`,
+ 'HTTP-Referer': 'https://noteflow.app',
+ 'X-Title': 'NoteFlow RSS Summarizer',
+ 'Content-Type': 'application/json'
+ },
+ timeout: 60000
+ }
+ );
+
+ const summary = response.data.choices[0].message.content;
+
+ logger.info('Résumé généré avec succès');
+
+ res.json({
+ summary,
+ model: selectedModel,
+ articles_count: articles.length
+ });
+ } catch (error) {
+ logger.error('Erreur lors de la génération du résumé:', error);
+
+ if (error.response) {
+ logger.error('Réponse OpenRouter:', error.response.data);
+ return res.status(error.response.status).json({
+ error: 'Erreur API OpenRouter',
+ details: error.response.data
+ });
+ }
+
+ res.status(500).json({ error: 'Erreur serveur' });
+ }
+});
+
+/**
+ * GET /api/rss/models
+ * Récupérer la liste des modèles OpenRouter
+ */
+router.get('/models', requireAdmin, async (req, res) => {
+ try {
+ // Liste des modèles populaires pour le résumé
+ const models = [
+ { id: 'openai/gpt-4-turbo', name: 'GPT-4 Turbo', provider: 'OpenAI' },
+ { id: 'openai/gpt-4', name: 'GPT-4', provider: 'OpenAI' },
+ { id: 'openai/gpt-3.5-turbo', name: 'GPT-3.5 Turbo', provider: 'OpenAI' },
+ { id: 'anthropic/claude-3-opus', name: 'Claude 3 Opus', provider: 'Anthropic' },
+ { id: 'anthropic/claude-3-sonnet', name: 'Claude 3 Sonnet', provider: 'Anthropic' },
+ { id: 'anthropic/claude-3-haiku', name: 'Claude 3 Haiku', provider: 'Anthropic' },
+ { id: 'google/gemini-pro', name: 'Gemini Pro', provider: 'Google' },
+ { id: 'meta-llama/llama-3-70b-instruct', name: 'Llama 3 70B', provider: 'Meta' },
+ { id: 'mistralai/mistral-large', name: 'Mistral Large', provider: 'Mistral AI' },
+ { id: 'mistralai/mixtral-8x7b-instruct', name: 'Mixtral 8x7B', provider: 'Mistral AI' }
+ ];
+
+ res.json(models);
+ } catch (error) {
+ logger.error('Erreur lors de la récupération des modèles:', error);
+ res.status(500).json({ error: 'Erreur serveur' });
+ }
+});
+
+module.exports = router;
diff --git a/routes/settings.routes.js b/routes/settings.routes.js
new file mode 100644
index 0000000..e3e9e2e
--- /dev/null
+++ b/routes/settings.routes.js
@@ -0,0 +1,99 @@
+// Routes de gestion des paramètres
+const express = require('express');
+const router = express.Router();
+const { getAll, getOne, runQuery } = require('../config/database');
+const { authenticateToken, requireAdmin } = require('../middleware/auth');
+const logger = require('../config/logger');
+
+// Toutes les routes nécessitent authentification admin
+router.use(authenticateToken);
+router.use(requireAdmin);
+
+/**
+ * GET /api/settings
+ * Récupérer tous les paramètres
+ */
+router.get('/', async (req, res) => {
+ try {
+ const settings = await getAll('SELECT key, value FROM settings');
+
+ // Convertir en objet key-value
+ const settingsObj = {};
+ settings.forEach(setting => {
+ settingsObj[setting.key] = setting.value;
+ });
+
+ res.json(settingsObj);
+ } catch (error) {
+ logger.error('Erreur lors de la récupération des paramètres:', error);
+ res.status(500).json({ error: 'Erreur serveur' });
+ }
+});
+
+/**
+ * GET /api/settings/:key
+ * Récupérer un paramètre spécifique
+ */
+router.get('/:key', async (req, res) => {
+ try {
+ const setting = await getOne('SELECT value FROM settings WHERE key = ?', [req.params.key]);
+
+ if (!setting) {
+ return res.status(404).json({ error: 'Paramètre non trouvé' });
+ }
+
+ res.json({ key: req.params.key, value: setting.value });
+ } catch (error) {
+ logger.error('Erreur lors de la récupération du paramètre:', error);
+ res.status(500).json({ error: 'Erreur serveur' });
+ }
+});
+
+/**
+ * PUT /api/settings/:key
+ * Mettre à jour un paramètre
+ */
+router.put('/:key', async (req, res) => {
+ try {
+ const { value } = req.body;
+
+ // Vérifier si le paramètre existe
+ const existing = await getOne('SELECT id FROM settings WHERE key = ?', [req.params.key]);
+
+ if (existing) {
+ await runQuery(
+ 'UPDATE settings SET value = ?, updated_at = CURRENT_TIMESTAMP WHERE key = ?',
+ [value, req.params.key]
+ );
+ } else {
+ await runQuery(
+ 'INSERT INTO settings (key, value) VALUES (?, ?)',
+ [req.params.key, value]
+ );
+ }
+
+ logger.info(`Paramètre mis à jour: ${req.params.key}`);
+ res.json({ key: req.params.key, value });
+ } catch (error) {
+ logger.error('Erreur lors de la mise à jour du paramètre:', error);
+ res.status(500).json({ error: 'Erreur serveur' });
+ }
+});
+
+/**
+ * DELETE /api/settings/:key
+ * Supprimer un paramètre
+ */
+router.delete('/:key', async (req, res) => {
+ try {
+ await runQuery('DELETE FROM settings WHERE key = ?', [req.params.key]);
+
+ logger.info(`Paramètre supprimé: ${req.params.key}`);
+ res.json({ message: 'Paramètre supprimé avec succès' });
+ } catch (error) {
+ logger.error('Erreur lors de la suppression du paramètre:', error);
+ res.status(500).json({ error: 'Erreur serveur' });
+ }
+});
+
+module.exports = router;
diff --git a/server.js b/server.js
index fbd545e..54c23be 100644
--- a/server.js
+++ b/server.js
@@ -82,6 +82,8 @@ app.use('/api/auth', require('./routes/auth.routes'));
app.use('/api/users', require('./routes/users.routes'));
app.use('/api/notes', require('./routes/notes.routes'));
app.use('/api/todos', require('./routes/todos.routes'));
+app.use('/api/settings', require('./routes/settings.routes'));
+app.use('/api/rss', require('./routes/rss.routes'));
// Route de recherche
app.get('/api/search', require('./routes/notes.routes').searchNotes);