diff --git a/backend/classes/webhook-manager.js b/backend/classes/webhook-manager.js index 233f2cc..0212c01 100644 --- a/backend/classes/webhook-manager.js +++ b/backend/classes/webhook-manager.js @@ -19,8 +19,12 @@ class WebhookManager { await this.triggerEventWebhooks('playback_started', data); }); - this.eventEmitter.on('user_login', async (data) => { - await this.triggerEventWebhooks('user_login', data); + this.eventEmitter.on('playback_ended', async (data) => { + await this.triggerEventWebhooks('playback_ended', data); + }); + + this.eventEmitter.on('media_recently_added', async (data) => { + await this.triggerEventWebhooks('media_recently_added', data); }); // If needed, add more event listeners here @@ -40,11 +44,33 @@ class WebhookManager { ).then(res => res.rows); } - async triggerEventWebhooks(eventType, data) { - const webhooks = await this.getWebhooksByEventType(eventType); - - for (const webhook of webhooks) { - await this.executeWebhook(webhook, data); + async triggerEventWebhooks(eventType, data = {}) { + try { + const webhooks = await this.getWebhooksByEventType(eventType); + + if (webhooks.length === 0) { + console.log(`[WEBHOOK] No webhooks registered for event: ${eventType}`); + return; + } + + console.log(`[WEBHOOK] Triggering ${webhooks.length} webhooks for event: ${eventType}`); + + const enrichedData = { + ...data, + event: eventType, + triggeredAt: new Date().toISOString() + }; + + const promises = webhooks.map(webhook => { + return this.executeWebhook(webhook, enrichedData); + }); + + await Promise.all(promises); + + return true; + } catch (error) { + console.error(`[WEBHOOK] Error triggering webhooks for event ${eventType}:`, error); + return false; } } @@ -135,6 +161,31 @@ class WebhookManager { return template; } + async triggerEvent(eventType, eventData = {}) { + try { + const webhooks = this.eventWebhooks?.[eventType] || []; + + if (webhooks.length === 0) { + console.log(`[WEBHOOK] No webhooks registered for event: ${eventType}`); + return; + } + + console.log(`[WEBHOOK] Triggering ${webhooks.length} webhooks for event: ${eventType}`); + + const promises = webhooks.map(webhook => { + return this.webhookManager.executeWebhook(webhook, { + ...eventData, + event: eventType, + triggeredAt: new Date().toISOString() + }); + }); + + await Promise.all(promises); + } catch (error) { + console.error(`[WEBHOOK] Error triggering webhooks for event ${eventType}:`, error); + } + } + emitEvent(eventType, data) { this.eventEmitter.emit(eventType, data); } @@ -340,6 +391,28 @@ class WebhookManager { return false; } } + + async executeDiscordWebhook(webhook, data) { + try { + console.log(`Execution of discord webhook: ${webhook.name}`); + + const response = await axios.post(webhook.url, data, { + headers: { + 'Content-Type': 'application/json' + } + }); + + console.log(`[WEBHOOK] Discord response: ${response.status}`); + return response.status >= 200 && response.status < 300; + } catch (error) { + console.error(`[WEBHOOK] Error with Discord webhook ${webhook.name}:`, error.message); + if (error.response) { + console.error('[WEBHOOK] Response status:', error.response.status); + console.error('[WEBHOOK] Response data:', error.response.data); + } + return false; + } + } } module.exports = WebhookManager; \ No newline at end of file diff --git a/backend/classes/webhook-scheduler.js b/backend/classes/webhook-scheduler.js index d1fddc3..4340217 100644 --- a/backend/classes/webhook-scheduler.js +++ b/backend/classes/webhook-scheduler.js @@ -35,6 +35,54 @@ class WebhookScheduler { } } + async loadEventWebhooks() { + try { + const eventWebhooks = await this.webhookManager.getEventWebhooks(); + if (eventWebhooks && eventWebhooks.length > 0) { + this.eventWebhooks = {}; + + eventWebhooks.forEach(webhook => { + if (!this.eventWebhooks[webhook.eventType]) { + this.eventWebhooks[webhook.eventType] = []; + } + this.eventWebhooks[webhook.eventType].push(webhook); + }); + + console.log(`[WEBHOOK] Loaded ${eventWebhooks.length} event-based webhooks`); + } else { + console.log('[WEBHOOK] No event-based webhooks found'); + this.eventWebhooks = {}; + } + } catch (error) { + console.error('[WEBHOOK] Failed to load event-based webhooks:', error); + } + } + + async triggerEvent(eventType, eventData = {}) { + try { + const webhooks = this.eventWebhooks[eventType] || []; + + if (webhooks.length === 0) { + console.log(`[WEBHOOK] No webhooks registered for event: ${eventType}`); + return; + } + + console.log(`[WEBHOOK] Triggering ${webhooks.length} webhooks for event: ${eventType}`); + + const promises = webhooks.map(webhook => { + return this.webhookManager.executeWebhook(webhook, { + event: eventType, + data: eventData, + triggeredAt: new Date().toISOString() + }); + }); + + await Promise.all(promises); + } catch (error) { + console.error(`[WEBHOOK] Error triggering webhooks for event ${eventType}:`, error); + } + } + scheduleWebhook(webhook) { try { this.cronJobs[webhook.id] = cron.schedule(webhook.schedule, async () => { @@ -50,6 +98,7 @@ class WebhookScheduler { async refreshSchedule() { await this.loadScheduledWebhooks(); + await this.loadEventWebhooks(); } } diff --git a/backend/routes/sync.js b/backend/routes/sync.js index 4f811ce..ac69d29 100644 --- a/backend/routes/sync.js +++ b/backend/routes/sync.js @@ -824,6 +824,8 @@ async function partialSync(triggertype) { const config = await new configClass().getConfig(); const uuid = randomUUID(); + + const newItems = []; // Array to track newly added items during the sync process syncTask = { loggedData: [], uuid: uuid, wsKey: "PartialSyncTask", taskName: taskName.partialsync }; try { @@ -833,7 +835,7 @@ async function partialSync(triggertype) { if (config.error) { syncTask.loggedData.push({ Message: config.error }); await logging.updateLog(syncTask.uuid, syncTask.loggedData, taskstate.FAILED); - return; + return { success: false, error: config.error }; } const libraries = await API.getLibraries(); @@ -842,7 +844,7 @@ async function partialSync(triggertype) { syncTask.loggedData.push({ Message: "Error: No Libararies found to sync." }); await logging.updateLog(syncTask.uuid, syncTask.loggedData, taskstate.FAILED); sendUpdate(syncTask.wsKey, { type: "Success", message: triggertype + " " + taskName.fullsync + " Completed" }); - return; + return { success: false, error: "No libraries found" }; } const excluded_libraries = config.settings.ExcludedLibraries || []; @@ -850,10 +852,10 @@ async function partialSync(triggertype) { const filtered_libraries = libraries.filter((library) => !excluded_libraries.includes(library.Id)); const existing_excluded_libraries = libraries.filter((library) => excluded_libraries.includes(library.Id)); - // //syncUserData + // syncUserData await syncUserData(); - // //syncLibraryFolders + // syncLibraryFolders await syncLibraryFolders(filtered_libraries, existing_excluded_libraries); //item sync counters @@ -956,7 +958,7 @@ async function partialSync(triggertype) { insertEpisodeInfoCount += Number(infoCount.insertEpisodeInfoCount); updateEpisodeInfoCount += Number(infoCount.updateEpisodeInfoCount); - //clear data from memory as its no longer needed + //clear data from memory as it's no longer needed library_items = null; seasons = null; episodes = null; @@ -1023,10 +1025,22 @@ async function partialSync(triggertype) { await logging.updateLog(syncTask.uuid, syncTask.loggedData, taskstate.SUCCESS); sendUpdate(syncTask.wsKey, { type: "Success", message: triggertype + " Sync Completed" }); + + return { + success: true, + newItems: newItems, + stats: { + itemsAdded: insertedItemsCount, + episodesAdded: insertedEpisodeCount, + seasonsAdded: insertedSeasonsCount + } + }; } catch (error) { syncTask.loggedData.push({ color: "red", Message: getErrorLineNumber(error) + ": Error: " + error }); await logging.updateLog(syncTask.uuid, syncTask.loggedData, taskstate.FAILED); sendUpdate(syncTask.wsKey, { type: "Error", message: triggertype + " Sync Halted with Errors" }); + + return { success: false, error: error.message }; } } diff --git a/backend/routes/webhooks.js b/backend/routes/webhooks.js index 67a6370..1995969 100644 --- a/backend/routes/webhooks.js +++ b/backend/routes/webhooks.js @@ -185,18 +185,129 @@ router.post('/:id/test', async (req, res) => { } const webhook = result.rows[0]; - const testData = req.body || {}; + let testData = req.body || {}; + let success = false; - const success = await webhookManager.executeWebhook(webhook, testData); + // Traitement spécial pour les webhooks Discord + if (webhook.url.includes('discord.com/api/webhooks')) { + console.log('Discord webhook détecté, préparation du payload spécifique'); + + // Format spécifique pour Discord + testData = { + content: "Test de webhook depuis Jellystat", + embeds: [{ + title: "Test de notification Discord", + description: "Ceci est un test de notification via webhook Discord", + color: 3447003, // Bleu + fields: [ + { + name: "Type de webhook", + value: webhook.trigger_type || "Non spécifié", + inline: true + }, + { + name: "ID", + value: webhook.id, + inline: true + } + ], + timestamp: new Date().toISOString() + }] + }; + + // Bypass du traitement normal pour Discord + success = await webhookManager.executeDiscordWebhook(webhook, testData); + } + // Comportement existant pour les autres types de webhook + else if (webhook.trigger_type === 'event' && webhook.event_type) { + const eventType = webhook.event_type; + + let eventData = {}; + + switch (eventType) { + case 'playback_started': + eventData = { + sessionInfo: { + userId: "test-user-id", + deviceId: "test-device-id", + deviceName: "Test Device", + clientName: "Test Client", + isPaused: false, + mediaType: "Movie", + mediaName: "Test Movie", + startTime: new Date().toISOString() + }, + userData: { + username: "Test User", + userImageTag: "test-image-tag" + }, + mediaInfo: { + itemId: "test-item-id", + episodeId: null, + mediaName: "Test Movie", + seasonName: null, + seriesName: null + } + }; + success = await webhookManager.triggerEventWebhooks(eventType, eventData, [webhook.id]); + break; + + case 'playback_ended': + eventData = { + sessionInfo: { + userId: "test-user-id", + deviceId: "test-device-id", + deviceName: "Test Device", + clientName: "Test Client", + mediaType: "Movie", + mediaName: "Test Movie", + startTime: new Date(Date.now() - 3600000).toISOString(), + endTime: new Date().toISOString(), + playbackDuration: 3600 + }, + userData: { + username: "Test User", + userImageTag: "test-image-tag" + }, + mediaInfo: { + itemId: "test-item-id", + episodeId: null, + mediaName: "Test Movie", + seasonName: null, + seriesName: null + } + }; + success = await webhookManager.triggerEventWebhooks(eventType, eventData, [webhook.id]); + break; + + case 'media_recently_added': + eventData = { + mediaItem: { + id: "test-item-id", + name: "Test Media", + type: "Movie", + overview: "This is a test movie for webhook testing", + addedDate: new Date().toISOString() + } + }; + success = await webhookManager.triggerEventWebhooks(eventType, eventData, [webhook.id]); + break; + + default: + success = await webhookManager.executeWebhook(webhook, testData); + } + } else { + success = await webhookManager.executeWebhook(webhook, testData); + } if (success) { - res.json({ message: 'Webhook executed successfully' }); + res.json({ message: 'Webhook exécuté avec succès' }); } else { - res.status(500).json({ error: 'Webhook execution failed' }); + res.status(500).json({ error: 'Échec de l\'exécution du webhook' }); } } catch (error) { console.error('Error testing webhook:', error); - res.status(500).json({ error: 'Failed to test webhook' }); + res.status(500).json({ error: 'Failed to test webhook: ' + error.message }); } }); @@ -205,10 +316,110 @@ router.post('/:id/trigger-monthly', async (req, res) => { const success = await webhookManager.triggerMonthlySummaryWebhook(req.params.id); if (success) { - res.status(200).json({ message: "Rapport mensuel envoyé avec succès" }); + res.status(200).json({ message: "Monthly report sent successfully" }); } else { - res.status(500).json({ message: "Échec de l'envoi du rapport mensuel" }); + res.status(500).json({ message: "Failed to send monthly report" }); } }); -module.exports = router; \ No newline at end of file +// Get status of event webhooks +router.get('/event-status', authMiddleware, async (req, res) => { + try { + const eventTypes = ['playback_started', 'playback_ended', 'media_recently_added']; + const result = {}; + + for (const eventType of eventTypes) { + const webhooks = await dbInstance.query( + 'SELECT id, name, enabled FROM webhooks WHERE trigger_type = $1 AND event_type = $2', + ['event', eventType] + ); + + result[eventType] = { + exists: webhooks.rows.length > 0, + enabled: webhooks.rows.some(webhook => webhook.enabled), + webhooks: webhooks.rows + }; + } + + res.json(result); + } catch (error) { + console.error('Error fetching webhook status:', error); + res.status(500).json({ error: 'Failed to fetch webhook status' }); + } +}); + +// Toggle all webhooks of a specific event type +router.post('/toggle-event/:eventType', async (req, res) => { + try { + const { eventType } = req.params; + const { enabled } = req.body; + + if (!['playback_started', 'playback_ended', 'media_recently_added'].includes(eventType)) { + return res.status(400).json({ error: 'Invalid event type' }); + } + + if (typeof enabled !== 'boolean') { + return res.status(400).json({ error: 'Enabled parameter must be a boolean' }); + } + + // Mettre à jour tous les webhooks de ce type d'événement + const result = await dbInstance.query( + 'UPDATE webhooks SET enabled = $1 WHERE trigger_type = $2 AND event_type = $3 RETURNING id', + [enabled, 'event', eventType] + ); + + // Si aucun webhook n'existe pour ce type, en créer un de base + if (result.rows.length === 0 && enabled) { + const defaultWebhook = { + name: `Webhook pour ${eventType}`, + url: req.body.url || '', + method: 'POST', + trigger_type: 'event', + event_type: eventType, + enabled: true, + headers: '{}', + payload: JSON.stringify({ + event: `{{event}}`, + data: `{{data}}`, + timestamp: `{{triggeredAt}}` + }) + }; + + if (!defaultWebhook.url) { + return res.status(400).json({ + error: 'URL parameter is required when creating a new webhook', + needsUrl: true + }); + } + + await dbInstance.query( + `INSERT INTO webhooks (name, url, method, trigger_type, event_type, enabled, headers, payload) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`, + [ + defaultWebhook.name, + defaultWebhook.url, + defaultWebhook.method, + defaultWebhook.trigger_type, + defaultWebhook.event_type, + defaultWebhook.enabled, + defaultWebhook.headers, + defaultWebhook.payload + ] + ); + } + + // Rafraîchir le planificateur de webhooks + await webhookScheduler.refreshSchedule(); + + res.json({ + success: true, + message: `Webhooks for ${eventType} ${enabled ? 'enabled' : 'disabled'}`, + affectedCount: result.rows.length + }); + } catch (error) { + console.error('Error toggling webhooks:', error); + res.status(500).json({ error: 'Failed to toggle webhooks' }); + } +}); + +module.exports = router; diff --git a/backend/tasks/ActivityMonitor.js b/backend/tasks/ActivityMonitor.js index 43f1969..6479a2d 100644 --- a/backend/tasks/ActivityMonitor.js +++ b/backend/tasks/ActivityMonitor.js @@ -7,10 +7,14 @@ const configClass = require("../classes/config"); const API = require("../classes/api-loader"); const { sendUpdate } = require("../ws"); const { isNumber } = require("@mui/x-data-grid/internals"); +const WebhookManager = require("../classes/webhook-manager"); + const MINIMUM_SECONDS_TO_INCLUDE_PLAYBACK = process.env.MINIMUM_SECONDS_TO_INCLUDE_PLAYBACK ? Number(process.env.MINIMUM_SECONDS_TO_INCLUDE_PLAYBACK) : 1; +const webhookManager = new WebhookManager(); + async function getSessionsInWatchDog(SessionData, WatchdogData) { let existingData = await WatchdogData.filter((wdData) => { return SessionData.some((sessionData) => { @@ -146,6 +150,42 @@ async function ActivityMonitor(interval) { //filter fix if table is empty if (WatchdogDataToInsert.length > 0) { + for (const session of WatchdogDataToInsert) { + let userData = {}; + try { + const userInfo = await API.getUserById(session.UserId); + if (userInfo) { + userData = { + username: userInfo.Name, + userImageTag: userInfo.PrimaryImageTag + }; + } + } catch (error) { + console.error(`[WEBHOOK] Error fetching user data: ${error.message}`); + } + + await webhookManager.triggerEventWebhooks('playback_started', { + sessionInfo: { + userId: session.UserId, + deviceId: session.DeviceId, + deviceName: session.DeviceName, + clientName: session.ClientName, + isPaused: session.IsPaused, + mediaType: session.MediaType, + mediaName: session.NowPlayingItemName, + startTime: session.ActivityDateInserted + }, + userData, + mediaInfo: { + itemId: session.NowPlayingItemId, + episodeId: session.EpisodeId, + mediaName: session.NowPlayingItemName, + seasonName: session.SeasonName, + seriesName: session.SeriesName + } + }); + } + //insert new rows where not existing items // console.log("Inserted " + WatchdogDataToInsert.length + " wd playback records"); db.insertBulk("jf_activity_watchdog", WatchdogDataToInsert, jf_activity_watchdog_columns); @@ -158,11 +198,46 @@ async function ActivityMonitor(interval) { console.log("Existing Data Updated: ", WatchdogDataToUpdate.length); } + if (dataToRemove.length > 0) { + for (const session of dataToRemove) { + let userData = {}; + try { + const userInfo = await API.getUserById(session.UserId); + if (userInfo) { + userData = { + username: userInfo.Name, + userImageTag: userInfo.PrimaryImageTag + }; + } + } catch (error) { + console.error(`[WEBHOOK] Error fetching user data: ${error.message}`); + } + + await webhookManager.triggerEventWebhooks('playback_ended', { + sessionInfo: { + userId: session.UserId, + deviceId: session.DeviceId, + deviceName: session.DeviceName, + clientName: session.ClientName, + playbackDuration: session.PlaybackDuration, + endTime: session.ActivityDateInserted + }, + userData, + mediaInfo: { + itemId: session.NowPlayingItemId, + episodeId: session.EpisodeId, + mediaName: session.NowPlayingItemName, + seasonName: session.SeasonName, + seriesName: session.SeriesName + } + }); + } + + const toDeleteIds = dataToRemove.map((row) => row.ActivityId); + //delete from db no longer in session data and insert into stats db //Bulk delete from db thats no longer on api - const toDeleteIds = dataToRemove.map((row) => row.ActivityId); - let playbackToInsert = dataToRemove; if (playbackToInsert.length == 0 && toDeleteIds.length == 0) { @@ -248,7 +323,9 @@ async function ActivityMonitor(interval) { } /////////////////////////// - } catch (error) { + } + } + catch (error) { if (error?.code === "ECONNREFUSED") { console.error("Error: Unable to connect to API"); //TO-DO Change this to correct API name } else if (error?.code === "ERR_BAD_RESPONSE") { diff --git a/backend/tasks/RecentlyAddedItemsSyncTask.js b/backend/tasks/RecentlyAddedItemsSyncTask.js index 85f0676..c688c1e 100644 --- a/backend/tasks/RecentlyAddedItemsSyncTask.js +++ b/backend/tasks/RecentlyAddedItemsSyncTask.js @@ -1,6 +1,7 @@ const { parentPort } = require("worker_threads"); const triggertype = require("../logging/triggertype"); const sync = require("../routes/sync"); +const WebhookManager = require("../classes/webhook-manager"); async function runPartialSyncTask(triggerType = triggertype.Automatic) { try { @@ -17,12 +18,25 @@ async function runPartialSyncTask(triggerType = triggertype.Automatic) { }); parentPort.postMessage({ type: "log", message: formattedArgs.join(" ") }); }; - await sync.partialSync(triggerType); + + const syncResults = await sync.partialSync(triggerType); + + const webhookManager = new WebhookManager(); + + const newMediaCount = syncResults?.newItems?.length || 0; + + if (newMediaCount > 0) { + await webhookManager.triggerEventWebhooks('media_recently_added', { + count: newMediaCount, + items: syncResults.newItems, + syncDate: new Date().toISOString(), + triggerType: triggerType + }); + } parentPort.postMessage({ status: "complete" }); } catch (error) { parentPort.postMessage({ status: "error", message: error.message }); - console.log(error); return []; } diff --git a/package-lock.json b/package-lock.json index e3f19fc..7eba186 100644 --- a/package-lock.json +++ b/package-lock.json @@ -6,7 +6,7 @@ "packages": { "": { "name": "jfstat", - "version": "1.1.5", + "version": "1.1.6", "dependencies": { "@emotion/react": "^11.14.0", "@emotion/styled": "^11.14.0", diff --git a/public/locales/en-UK/translation.json b/public/locales/en-UK/translation.json index 58ce159..83cae4b 100644 --- a/public/locales/en-UK/translation.json +++ b/public/locales/en-UK/translation.json @@ -226,7 +226,12 @@ "URL": "URL", "TYPE": "Type", "TRIGGER": "Trigger", - "STATUS": "Status" + "STATUS": "Status", + "EVENT_WEBHOOKS": "Event notifications", + "EVENT_WEBHOOKS_TOOLTIP": "Enable or disable event notifications", + "PLAYBACK_STARTED": "Playback Started", + "PLAYBACK_ENDED": "Playback Stopped", + "MEDIA_ADDED": "Media Added" }, "TASK_TYPE": { "JOB": "Job", diff --git a/public/locales/fr-FR/translation.json b/public/locales/fr-FR/translation.json index 78929ef..389f6c8 100644 --- a/public/locales/fr-FR/translation.json +++ b/public/locales/fr-FR/translation.json @@ -213,7 +213,25 @@ }, "SELECT_LIBRARIES_TO_IMPORT": "Sélectionner les médiathèques à importer", "SELECT_LIBRARIES_TO_IMPORT_TOOLTIP": "L'activité du contenu de ces médiathèques est toujours suivie, même s'ils ne sont pas importés.", - "DATE_ADDED": "Date d'ajout" + "DATE_ADDED": "Date d'ajout", + "WEBHOOKS": "Webhooks", + "WEBHOOK_TYPE": "Type de webhook", + "TEST_NOW": "Tester maintenant", + "WEBHOOKS_CONFIGURATION": "Configuration des webhooks", + "WEBHOOKS_TOOLTIP": "L'URL des webhooks utiliser pour envoyer des notifications à Discord ou à d'autres services", + "WEBHOOK_SAVED": "Webhook sauvegardé", + "WEBHOOK_NAME": "Nom du webhook", + "DISCORD_WEBHOOK_URL": "URL du webhook Discord", + "ENABLE_WEBHOOK": "Activer le webhook", + "URL": "URL", + "TYPE": "Type", + "TRIGGER": "Déclencheur", + "STATUS": "Status", + "EVENT_WEBHOOKS": "Notifications d'événements", + "EVENT_WEBHOOKS_TOOLTIP": "Activez ou désactivez les notifications pour différents événements du système", + "PLAYBACK_STARTED": "Lecture commencée", + "PLAYBACK_ENDED": "Lecture arrêtée", + "MEDIA_ADDED": "Média ajouté" }, "TASK_TYPE": { "JOB": "Job", diff --git a/src/pages/components/settings/webhooks.jsx b/src/pages/components/settings/webhooks.jsx index 4b08657..7427890 100644 --- a/src/pages/components/settings/webhooks.jsx +++ b/src/pages/components/settings/webhooks.jsx @@ -3,6 +3,7 @@ import axios from "../../../lib/axios_instance"; import { Form, Row, Col, Button, Spinner, Alert } from "react-bootstrap"; import InformationLineIcon from "remixicon-react/InformationLineIcon"; import { Tooltip } from "@mui/material"; +import PropTypes from 'prop-types'; import Table from '@mui/material/Table'; import TableBody from '@mui/material/TableBody'; @@ -17,6 +18,7 @@ import ErrorBoundary from "../general/ErrorBoundary"; const token = localStorage.getItem('token'); +// Modification du composant WebhookRow pour passer l'objet webhook complet function WebhookRow(props) { const { webhook, onEdit, onTest } = props; @@ -28,16 +30,16 @@ function WebhookRow(props) { {webhook.webhook_type || 'generic'} {webhook.trigger_type} - - {webhook.enabled ? : } - + + {webhook.enabled ? : } +
-
@@ -47,6 +49,19 @@ function WebhookRow(props) { ); } +WebhookRow.propTypes = { + webhook: PropTypes.shape({ + id: PropTypes.string.isRequired, + name: PropTypes.string.isRequired, + url: PropTypes.string.isRequired, + webhook_type: PropTypes.string, + trigger_type: PropTypes.string.isRequired, + enabled: PropTypes.bool.isRequired + }).isRequired, + onEdit: PropTypes.func.isRequired, + onTest: PropTypes.func.isRequired +}; + function WebhooksSettings() { const [webhooks, setWebhooks] = useState([]); const [loading, setLoading] = useState(true); @@ -63,6 +78,12 @@ function WebhooksSettings() { webhook_type: 'discord' }); + const [eventWebhooks, setEventWebhooks] = useState({ + playback_started: { exists: false, enabled: false }, + playback_ended: { exists: false, enabled: false }, + media_recently_added: { exists: false, enabled: false } + }); + useEffect(() => { const fetchWebhooks = async () => { try { @@ -73,18 +94,19 @@ function WebhooksSettings() { }, }); - if (response.data != webhooks) { + if (response.data !== webhooks) { setWebhooks(response.data); - } - - if (loading) { + await loadEventWebhooks(); + } + + if (loading) { setLoading(false); - } + } } catch (err) { console.error("Error loading webhooks:", err); if (loading) { setLoading(false); - } + } } }; @@ -92,7 +114,7 @@ function WebhooksSettings() { const intervalId = setInterval(fetchWebhooks, 1000 * 10); return () => clearInterval(intervalId); - }, []); + }, [webhooks.length]); const handleInputChange = (e) => { const { name, value } = e.target; @@ -111,7 +133,13 @@ function WebhooksSettings() { setSuccess(false); if (!currentWebhook.url) { - setError("Discord webhook URL is required"); + setError("Webhook URL is required"); + setSaving(false); + return; + } + + if (currentWebhook.trigger_type === 'event' && !currentWebhook.event_type) { + setError("Event type is required for an event based webhook"); setSaving(false); return; } @@ -134,6 +162,17 @@ function WebhooksSettings() { }); } + const webhooksResponse = await axios.get('/webhooks', { + headers: { + Authorization: `Bearer ${token}`, + "Content-Type": "application/json", + }, + }); + + setWebhooks(webhooksResponse.data); + + await loadEventWebhooks(); + setCurrentWebhook({ name: 'New Webhook', url: '', @@ -143,10 +182,11 @@ function WebhooksSettings() { method: 'POST', webhook_type: 'discord' }); + setSuccess("Webhook saved successfully!"); setSaving(false); } catch (err) { - setError("Error during webhook saving: " + (err.response?.data?.error || err.message)); + setError("Error while saving webhook " + (err.response?.data?.error || err.message)); setSaving(false); } }; @@ -155,9 +195,10 @@ function WebhooksSettings() { setCurrentWebhook(webhook); }; - const handleTest = async (webhookId) => { - if (!webhookId) { - setError("Impossible to test the webhook: no ID provided"); + const handleTest = async (webhook) => { + if (!webhook || !webhook.id) { + setError("Impossible to test the webhook: no webhook provided"); + setLoading(false); return; } @@ -165,14 +206,20 @@ function WebhooksSettings() { setLoading(true); setError(null); - await axios.post(`/webhooks/${webhookId}/trigger-monthly`, {}, { + let endpoint = `/webhooks/${webhook.id}/test`; + + if (webhook.trigger_type === 'scheduled' && webhook.schedule && webhook.schedule.includes('1 * *')) { + endpoint = `/webhooks/${webhook.id}/trigger-monthly`; + } + + await axios.post(endpoint, {}, { headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", } }); - setSuccess("Webhook test triggered successfully!"); + setSuccess(`Webhook ${webhook.name} test triggered successfully!`); setLoading(false); } catch (err) { setError("Error during the test of the webhook: " + (err.response?.data?.message || err.message)); @@ -180,6 +227,107 @@ function WebhooksSettings() { } }; + const getEventWebhookStatus = (eventType) => { + return eventWebhooks[eventType]?.enabled || false; + }; + + const loadEventWebhooks = async () => { + try { + const eventTypes = ['playback_started', 'playback_ended', 'media_recently_added']; + const status = {}; + + eventTypes.forEach(eventType => { + const matchingWebhooks = webhooks.filter( + webhook => webhook.trigger_type === 'event' && webhook.event_type === eventType + ); + + status[eventType] = { + exists: matchingWebhooks.length > 0, + enabled: matchingWebhooks.some(webhook => webhook.enabled) + }; + }); + + setEventWebhooks(status); + } catch (error) { + console.error('Error loading event webhook status:', error); + } + }; + + const toggleEventWebhook = async (eventType) => { + try { + setLoading(true); + setError(null); + + const isCurrentlyEnabled = getEventWebhookStatus(eventType); + const matchingWebhooks = webhooks.filter( + webhook => webhook.trigger_type === 'event' && webhook.event_type === eventType + ); + + if (matchingWebhooks.length === 0 && !isCurrentlyEnabled) { + const newWebhook = { + name: `Notification - ${getEventDisplayName(eventType)}`, + url: '', + enabled: true, + trigger_type: 'event', + event_type: eventType, + method: 'POST', + webhook_type: 'discord' + }; + + setCurrentWebhook(newWebhook); + setLoading(false); + return; + } + + for (const webhook of matchingWebhooks) { + await axios.put(`/webhooks/${webhook.id}`, + { ...webhook, enabled: !isCurrentlyEnabled }, + { + headers: { + Authorization: `Bearer ${token}`, + "Content-Type": "application/json", + } + } + ); + } + + setEventWebhooks(prev => ({ + ...prev, + [eventType]: { + ...prev[eventType], + enabled: !isCurrentlyEnabled + } + })); + + const response = await axios.get('/webhooks', { + headers: { + Authorization: `Bearer ${token}`, + "Content-Type": "application/json", + }, + }); + + setWebhooks(response.data); + setLoading(false); + setSuccess(`Webhook for ${getEventDisplayName(eventType)} ${!isCurrentlyEnabled ? 'enabled' : 'disabled'} with success!`); + } catch (error) { + setError("Error while editing webhook: " + (error.response?.data?.error || error.message)); + setLoading(false); + } + }; + + const getEventDisplayName = (eventType) => { + switch(eventType) { + case 'playback_started': + return 'Playback started'; + case 'playback_ended': + return 'Playback ended'; + case 'media_recently_added': + return 'New media added'; + default: + return eventType; + } + }; + if (loading && !webhooks.length) { return ; } @@ -273,7 +421,72 @@ function WebhooksSettings() { - + + {/* Ajout de la section pour les webhooks événementiels */} +
+

+ + }> + + + + +

+ + + +
+
+
+ toggleEventWebhook('playback_started')} + /> +
+

+ Send a webhook notification when a user starts watching a media +

+
+ + + +
+
+
+ toggleEventWebhook('playback_ended')} + /> +
+

+ Send a webhook notification when a user finishes watching a media +

+
+ + + +
+
+
+ toggleEventWebhook('media_recently_added')} + /> +
+

+ Send a webhook notification when new media is added to the library +

+
+ + +
+ @@ -305,7 +518,7 @@ function WebhooksSettings() {
- + );