Add webhook support

backend/classes/webhook-scheduler.js

@@ -0,0 +1,105 @@
+const cron = require('node-cron');
+const WebhookManager = require('./webhook-manager');
+const dbInstance = require('../db');
+
+class WebhookScheduler {
+    constructor() {
+        this.webhookManager = new WebhookManager();
+        this.cronJobs = {};
+        this.loadScheduledWebhooks();
+    }
+
+    async loadScheduledWebhooks() {
+        try {
+            const webhooks = await this.webhookManager.getScheduledWebhooks();
+            if (webhooks) {
+            // Clean existing tasks
+            Object.values(this.cronJobs).forEach(job => job.stop());
+            this.cronJobs = {};
+
+            // Create new tasks
+            webhooks.forEach(webhook => {
+                if (webhook.schedule && cron.validate(webhook.schedule)) {
+                    this.scheduleWebhook(webhook);
+                } else {
+                    console.error(`[WEBHOOK] Invalid cron schedule for webhook ${webhook.id}: ${webhook.schedule}`);
+                }
+            });
+
+            console.log(`[WEBHOOK] Scheduled ${Object.keys(this.cronJobs).length} webhooks`);
+            } else {
+                console.log('[WEBHOOK] No scheduled webhooks found');
+            }
+        } catch (error) {
+            console.error('[WEBHOOK] Failed to load scheduled webhooks:', error);
+        }
+    }
+
+    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 () => {
+                console.log(`[WEBHOOK] Executing scheduled webhook: ${webhook.name}`);
+                await this.webhookManager.executeWebhook(webhook);
+            });
+
+            console.log(`[WEBHOOK] Webhook ${webhook.name} scheduled with cron: ${webhook.schedule}`);
+        } catch (error) {
+            console.error(`[WEBHOOK] Error scheduling webhook ${webhook.id}:`, error);
+        }
+    }
+
+    async refreshSchedule() {
+        await this.loadScheduledWebhooks();
+        await this.loadEventWebhooks();
+    }
+}
+
+module.exports = WebhookScheduler;

backend/migrations/098_create_webhooks_table.js

@@ -0,0 +1,23 @@
+exports.up = function (knex) {
+  return knex.schema.createTable("webhooks", (table) => {
+    table.increments("id").primary();
+    table.string("name").notNullable();
+    table.string("url").notNullable();
+    table.text("headers").defaultTo("{}");
+    table.text("payload").defaultTo("{}");
+    table.string("method").defaultTo("POST");
+    table.string("trigger_type").notNullable();
+    table.string("webhook_type").defaultTo("generic");
+    table.string("schedule").nullable();
+    table.string("event_type").nullable();
+    table.boolean("enabled").defaultTo(true);
+    table.timestamp("last_triggered").nullable();
+    table.boolean("retry_on_failure").defaultTo(false);
+    table.integer("max_retries").defaultTo(3);
+    table.timestamps(true, true);
+  });
+};
+
+exports.down = function (knex) {
+  return knex.schema.dropTable("webhooks");
+};

backend/routes/sync.js

@@ -852,6 +852,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 {
@@ -861,7 +863,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();
@@ -870,18 +872,18 @@ 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 || [];
 
     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
@@ -984,7 +986,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;
@@ -1051,10 +1053,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 };
   }
 }