Add notification system with admin UI and backend

Introduces a full notification system with support for Discord and Pushover backends, event triggers, and message formatting. Adds backend services, processors, and API endpoints for managing notifications, as well as a new Notifications tab in the admin settings UI. Updates documentation, database schema, and tests to cover notification features and approval workflow improvements. Also changes project license from MIT to AGPL v3.

src/app/api/admin/notifications/[id]/route.ts

@@ -0,0 +1,226 @@
+/**
+ * Component: Notification Backend Individual API
+ * Documentation: documentation/backend/services/notifications.md
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import { requireAuth, requireAdmin, AuthenticatedRequest } from '@/lib/middleware/auth';
+import { prisma } from '@/lib/db';
+import { getNotificationService, NotificationBackendType } from '@/lib/services/notification.service';
+import { RMABLogger } from '@/lib/utils/logger';
+import { z } from 'zod';
+
+const logger = RMABLogger.create('API.Admin.Notifications.Id');
+
+const UpdateBackendSchema = z.object({
+  name: z.string().min(1).optional(),
+  config: z.record(z.any()).optional(),
+  events: z.array(z.enum(['request_pending_approval', 'request_approved', 'request_available', 'request_error'])).min(1).optional(),
+  enabled: z.boolean().optional(),
+});
+
+/**
+ * GET /api/admin/notifications/[id]
+ * Get single notification backend (sensitive values masked)
+ */
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  return requireAuth(request, async (req: AuthenticatedRequest) => {
+    return requireAdmin(req, async () => {
+      try {
+        const { id } = await params;
+
+        const backend = await prisma.notificationBackend.findUnique({
+          where: { id },
+        });
+
+        if (!backend) {
+          return NextResponse.json(
+            { error: 'NotFound', message: 'Notification backend not found' },
+            { status: 404 }
+          );
+        }
+
+        const notificationService = getNotificationService();
+
+        // Mask sensitive config values
+        return NextResponse.json({
+          success: true,
+          backend: {
+            ...backend,
+            config: notificationService.maskConfig(backend.type as NotificationBackendType, backend.config),
+          },
+        });
+      } catch (error) {
+        logger.error('Failed to fetch notification backend', {
+          error: error instanceof Error ? error.message : String(error),
+        });
+
+        return NextResponse.json(
+          {
+            error: 'FetchError',
+            message: 'Failed to fetch notification backend',
+          },
+          { status: 500 }
+        );
+      }
+    });
+  });
+}
+
+/**
+ * PUT /api/admin/notifications/[id]
+ * Update notification backend
+ */
+export async function PUT(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  return requireAuth(request, async (req: AuthenticatedRequest) => {
+    return requireAdmin(req, async () => {
+      try {
+        const { id } = await params;
+        const body = await request.json();
+        const updates = UpdateBackendSchema.parse(body);
+
+        // Get existing backend
+        const existing = await prisma.notificationBackend.findUnique({
+          where: { id },
+        });
+
+        if (!existing) {
+          return NextResponse.json(
+            { error: 'NotFound', message: 'Notification backend not found' },
+            { status: 404 }
+          );
+        }
+
+        const notificationService = getNotificationService();
+
+        // Handle config updates (preserve masked values, encrypt new values)
+        let finalConfig = existing.config;
+        if (updates.config) {
+          const existingConfig = existing.config as any;
+          const updatedConfig = updates.config as any;
+
+          // Check if masked values need to be preserved
+          Object.keys(updatedConfig).forEach((key) => {
+            if (updatedConfig[key] === '••••••••') {
+              // Preserve existing encrypted value
+              updatedConfig[key] = existingConfig[key];
+            }
+          });
+
+          // Encrypt new/changed values
+          finalConfig = notificationService.encryptConfig(existing.type as NotificationBackendType, updatedConfig);
+        }
+
+        // Update backend
+        const updateData: any = {};
+        if (updates.name) updateData.name = updates.name;
+        if (updates.config) updateData.config = finalConfig;
+        if (updates.events) updateData.events = updates.events;
+        if (updates.enabled !== undefined) updateData.enabled = updates.enabled;
+
+        const updated = await prisma.notificationBackend.update({
+          where: { id },
+          data: updateData,
+        });
+
+        logger.info(`Updated notification backend: ${updated.name}`, {
+          backendId: id,
+          adminId: req.user?.sub,
+        });
+
+        // Return with masked values
+        return NextResponse.json({
+          success: true,
+          backend: {
+            ...updated,
+            config: notificationService.maskConfig(updated.type as NotificationBackendType, updated.config),
+          },
+        });
+      } catch (error) {
+        logger.error('Failed to update notification backend', {
+          error: error instanceof Error ? error.message : String(error),
+        });
+
+        if (error instanceof z.ZodError) {
+          return NextResponse.json(
+            {
+              error: 'ValidationError',
+              details: error.errors,
+            },
+            { status: 400 }
+          );
+        }
+
+        return NextResponse.json(
+          {
+            error: 'UpdateError',
+            message: 'Failed to update notification backend',
+          },
+          { status: 500 }
+        );
+      }
+    });
+  });
+}
+
+/**
+ * DELETE /api/admin/notifications/[id]
+ * Delete notification backend
+ */
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  return requireAuth(request, async (req: AuthenticatedRequest) => {
+    return requireAdmin(req, async () => {
+      try {
+        const { id } = await params;
+
+        // Check if backend exists
+        const backend = await prisma.notificationBackend.findUnique({
+          where: { id },
+        });
+
+        if (!backend) {
+          return NextResponse.json(
+            { error: 'NotFound', message: 'Notification backend not found' },
+            { status: 404 }
+          );
+        }
+
+        // Delete backend
+        await prisma.notificationBackend.delete({
+          where: { id },
+        });
+
+        logger.info(`Deleted notification backend: ${backend.name}`, {
+          backendId: id,
+          adminId: req.user?.sub,
+        });
+
+        return NextResponse.json({
+          success: true,
+          message: 'Notification backend deleted',
+        });
+      } catch (error) {
+        logger.error('Failed to delete notification backend', {
+          error: error instanceof Error ? error.message : String(error),
+        });
+
+        return NextResponse.json(
+          {
+            error: 'DeleteError',
+            message: 'Failed to delete notification backend',
+          },
+          { status: 500 }
+        );
+      }
+    });
+  });
+}

src/app/api/admin/notifications/route.ts

@@ -0,0 +1,129 @@
+/**
+ * Component: Notification Backend API
+ * Documentation: documentation/backend/services/notifications.md
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import { requireAuth, requireAdmin, AuthenticatedRequest } from '@/lib/middleware/auth';
+import { prisma } from '@/lib/db';
+import { getNotificationService, NotificationBackendType } from '@/lib/services/notification.service';
+import { RMABLogger } from '@/lib/utils/logger';
+import { z } from 'zod';
+
+const logger = RMABLogger.create('API.Admin.Notifications');
+
+const CreateBackendSchema = z.object({
+  type: z.enum(['discord', 'pushover', 'email', 'slack', 'telegram', 'webhook']),
+  name: z.string().min(1),
+  config: z.record(z.any()),
+  events: z.array(z.enum(['request_pending_approval', 'request_approved', 'request_available', 'request_error'])).min(1),
+  enabled: z.boolean().default(true),
+});
+
+/**
+ * GET /api/admin/notifications
+ * List all notification backends (sensitive values masked)
+ */
+export async function GET(request: NextRequest) {
+  return requireAuth(request, async (req: AuthenticatedRequest) => {
+    return requireAdmin(req, async () => {
+      try {
+        const backends = await prisma.notificationBackend.findMany({
+          orderBy: { createdAt: 'desc' },
+        });
+
+        const notificationService = getNotificationService();
+
+        // Mask sensitive config values
+        const maskedBackends = backends.map((backend) => ({
+          ...backend,
+          config: notificationService.maskConfig(backend.type as NotificationBackendType, backend.config),
+        }));
+
+        return NextResponse.json({
+          success: true,
+          backends: maskedBackends,
+        });
+      } catch (error) {
+        logger.error('Failed to fetch notification backends', {
+          error: error instanceof Error ? error.message : String(error),
+        });
+
+        return NextResponse.json(
+          {
+            error: 'FetchError',
+            message: 'Failed to fetch notification backends',
+          },
+          { status: 500 }
+        );
+      }
+    });
+  });
+}
+
+/**
+ * POST /api/admin/notifications
+ * Create new notification backend
+ */
+export async function POST(request: NextRequest) {
+  return requireAuth(request, async (req: AuthenticatedRequest) => {
+    return requireAdmin(req, async () => {
+      try {
+        const body = await request.json();
+        const { type, name, config, events, enabled } = CreateBackendSchema.parse(body);
+
+        const notificationService = getNotificationService();
+
+        // Encrypt sensitive config values
+        const encryptedConfig = notificationService.encryptConfig(type, config);
+
+        // Create backend
+        const backend = await prisma.notificationBackend.create({
+          data: {
+            type,
+            name,
+            config: encryptedConfig,
+            events,
+            enabled,
+          },
+        });
+
+        logger.info(`Created notification backend: ${name} (${type})`, {
+          backendId: backend.id,
+          adminId: req.user?.sub,
+        });
+
+        // Return with masked values
+        return NextResponse.json({
+          success: true,
+          backend: {
+            ...backend,
+            config: notificationService.maskConfig(type, backend.config),
+          },
+        }, { status: 201 });
+      } catch (error) {
+        logger.error('Failed to create notification backend', {
+          error: error instanceof Error ? error.message : String(error),
+        });
+
+        if (error instanceof z.ZodError) {
+          return NextResponse.json(
+            {
+              error: 'ValidationError',
+              details: error.errors,
+            },
+            { status: 400 }
+          );
+        }
+
+        return NextResponse.json(
+          {
+            error: 'CreateError',
+            message: 'Failed to create notification backend',
+          },
+          { status: 500 }
+        );
+      }
+    });
+  });
+}

src/app/api/admin/notifications/test/route.ts

@@ -0,0 +1,97 @@
+/**
+ * Component: Notification Test API
+ * Documentation: documentation/backend/services/notifications.md
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import { requireAuth, requireAdmin, AuthenticatedRequest } from '@/lib/middleware/auth';
+import { getNotificationService, NotificationBackendType, NotificationPayload } from '@/lib/services/notification.service';
+import { RMABLogger } from '@/lib/utils/logger';
+import { z } from 'zod';
+
+const logger = RMABLogger.create('API.Admin.Notifications.Test');
+
+const TestNotificationSchema = z.object({
+  type: z.enum(['discord', 'pushover', 'email', 'slack', 'telegram', 'webhook']),
+  config: z.record(z.any()),
+});
+
+/**
+ * POST /api/admin/notifications/test
+ * Test notification with provided config (synchronous)
+ */
+export async function POST(request: NextRequest) {
+  return requireAuth(request, async (req: AuthenticatedRequest) => {
+    return requireAdmin(req, async () => {
+      try {
+        const body = await request.json();
+        const { type, config } = TestNotificationSchema.parse(body);
+
+        const notificationService = getNotificationService();
+
+        // Encrypt config values
+        const encryptedConfig = notificationService.encryptConfig(type, config);
+
+        // Create test payload
+        const testPayload: NotificationPayload = {
+          event: 'request_available',
+          requestId: 'test-request-id',
+          title: "The Hitchhiker's Guide to the Galaxy",
+          author: 'Douglas Adams',
+          userName: 'Test User',
+          timestamp: new Date(),
+        };
+
+        // Send test notification synchronously (not via job queue)
+        try {
+          // Call sendToBackend directly
+          await (notificationService as any).sendToBackend(type, encryptedConfig, testPayload);
+
+          logger.info(`Test notification sent successfully for ${type}`, {
+            adminId: req.user?.sub,
+          });
+
+          return NextResponse.json({
+            success: true,
+            message: 'Test notification sent successfully',
+          });
+        } catch (notificationError) {
+          logger.error(`Test notification failed for ${type}`, {
+            error: notificationError instanceof Error ? notificationError.message : String(notificationError),
+            adminId: req.user?.sub,
+          });
+
+          return NextResponse.json(
+            {
+              error: 'NotificationError',
+              message: notificationError instanceof Error ? notificationError.message : 'Failed to send test notification',
+            },
+            { status: 400 }
+          );
+        }
+      } catch (error) {
+        logger.error('Failed to test notification', {
+          error: error instanceof Error ? error.message : String(error),
+        });
+
+        if (error instanceof z.ZodError) {
+          return NextResponse.json(
+            {
+              error: 'ValidationError',
+              details: error.errors,
+            },
+            { status: 400 }
+          );
+        }
+
+        return NextResponse.json(
+          {
+            error: 'TestError',
+            message: 'Failed to test notification',
+          },
+          { status: 500 }
+        );
+      }
+    });
+  });
+}

src/app/api/admin/requests/[id]/approve/route.ts

@@ -75,42 +75,123 @@ export async function POST(
 
         // Update request based on action
         if (action === 'approve') {
-          // Approve: Change status to 'pending' and trigger search job
-          const updatedRequest = await prisma.request.update({
-            where: { id },
-            data: { status: 'pending' },
-            include: {
-              audiobook: true,
-              user: {
-                select: {
-                  id: true,
-                  plexUsername: true,
+          const jobQueue = getJobQueueService();
+
+          // Check if request has a pre-selected torrent (from interactive search)
+          if (existingRequest.selectedTorrent) {
+            // User pre-selected a specific torrent - download that torrent directly
+            logger.info(`Request ${id} has pre-selected torrent, starting download`, {
+              requestId: id,
+              userId: existingRequest.userId,
+              adminId: req.user.sub,
+            });
+
+            // Trigger download job with pre-selected torrent
+            await jobQueue.addDownloadJob(
+              existingRequest.id,
+              {
+                id: existingRequest.audiobook.id,
+                title: existingRequest.audiobook.title,
+                author: existingRequest.audiobook.author,
+              },
+              existingRequest.selectedTorrent as any
+            );
+
+            // Update status to 'downloading' and clear selectedTorrent
+            const updatedRequest = await prisma.request.update({
+              where: { id },
+              data: {
+                status: 'downloading',
+                selectedTorrent: null as any, // Clear after use
+              },
+              include: {
+                audiobook: true,
+                user: {
+                  select: {
+                    id: true,
+                    plexUsername: true,
+                  },
                 },
               },
-            },
-          });
+            });
 
-          // Trigger search job
-          const jobQueue = getJobQueueService();
-          await jobQueue.addSearchJob(updatedRequest.id, {
-            id: updatedRequest.audiobook.id,
-            title: updatedRequest.audiobook.title,
-            author: updatedRequest.audiobook.author,
-            asin: updatedRequest.audiobook.audibleAsin || undefined,
-          });
+            // Send notification for manual approval
+            await jobQueue.addNotificationJob(
+              'request_approved',
+              updatedRequest.id,
+              existingRequest.audiobook.title,
+              existingRequest.audiobook.author,
+              existingRequest.user.plexUsername || 'Unknown User'
+            ).catch((error) => {
+              logger.error('Failed to queue notification', { error: error instanceof Error ? error.message : String(error) });
+            });
 
-          logger.info(`Request ${id} approved by admin ${req.user.sub}`, {
-            requestId: id,
-            userId: updatedRequest.userId,
-            audiobookTitle: updatedRequest.audiobook.title,
-            adminId: req.user.sub,
-          });
+            logger.info(`Request ${id} approved by admin ${req.user.sub}, downloading pre-selected torrent`, {
+              requestId: id,
+              userId: updatedRequest.userId,
+              audiobookTitle: existingRequest.audiobook.title,
+              adminId: req.user.sub,
+            });
 
-          return NextResponse.json({
-            success: true,
-            message: 'Request approved and search job triggered',
-            request: updatedRequest,
-          });
+            return NextResponse.json({
+              success: true,
+              message: 'Request approved and download started with pre-selected torrent',
+              request: updatedRequest,
+            });
+          } else {
+            // No pre-selected torrent - use automatic search
+            logger.info(`Request ${id} using automatic search`, {
+              requestId: id,
+              userId: existingRequest.userId,
+              adminId: req.user.sub,
+            });
+
+            const updatedRequest = await prisma.request.update({
+              where: { id },
+              data: { status: 'pending' },
+              include: {
+                audiobook: true,
+                user: {
+                  select: {
+                    id: true,
+                    plexUsername: true,
+                  },
+                },
+              },
+            });
+
+            // Trigger search job
+            await jobQueue.addSearchJob(updatedRequest.id, {
+              id: updatedRequest.audiobook.id,
+              title: updatedRequest.audiobook.title,
+              author: updatedRequest.audiobook.author,
+              asin: updatedRequest.audiobook.audibleAsin || undefined,
+            });
+
+            // Send notification for manual approval
+            await jobQueue.addNotificationJob(
+              'request_approved',
+              updatedRequest.id,
+              updatedRequest.audiobook.title,
+              updatedRequest.audiobook.author,
+              updatedRequest.user.plexUsername || 'Unknown User'
+            ).catch((error) => {
+              logger.error('Failed to queue notification', { error: error instanceof Error ? error.message : String(error) });
+            });
+
+            logger.info(`Request ${id} approved by admin ${req.user.sub}`, {
+              requestId: id,
+              userId: updatedRequest.userId,
+              audiobookTitle: updatedRequest.audiobook.title,
+              adminId: req.user.sub,
+            });
+
+            return NextResponse.json({
+              success: true,
+              message: 'Request approved and search job triggered',
+              request: updatedRequest,
+            });
+          }
         } else {
           // Deny: Change status to 'denied'
           const updatedRequest = await prisma.request.update({

src/app/api/audiobooks/request-with-torrent/route.ts

@@ -193,43 +193,141 @@ export async function POST(request: NextRequest) {
         });
       }
 
-      // Create request with downloading status
-      const newRequest = await prisma.request.create({
-        data: {
-          userId: req.user.id,
-          audiobookId: audiobookRecord.id,
-          status: 'downloading',
-          progress: 0,
-        },
-        include: {
-          audiobook: true,
-          user: {
-            select: {
-              id: true,
-              plexUsername: true,
-            },
-          },
+      // Check if request needs approval
+      let needsApproval = false;
+
+      // Fetch user with autoApproveRequests setting
+      const user = await prisma.user.findUnique({
+        where: { id: req.user.id },
+        select: {
+          role: true,
+          autoApproveRequests: true,
+          plexUsername: true,
         },
       });
 
-      // Queue download job with the selected torrent
+      if (!user) {
+        return NextResponse.json(
+          { error: 'UserNotFound', message: 'User not found' },
+          { status: 404 }
+        );
+      }
+
+      // Determine if approval is needed
+      if (user.role === 'admin') {
+        // Admins always auto-approve
+        needsApproval = false;
+      } else {
+        // Check user's personal setting first
+        if (user.autoApproveRequests === true) {
+          needsApproval = false;
+        } else if (user.autoApproveRequests === false) {
+          needsApproval = true;
+        } else {
+          // User setting is null, check global setting
+          const globalConfig = await prisma.configuration.findUnique({
+            where: { key: 'auto_approve_requests' },
+          });
+          // Default to true if not configured (backward compatibility)
+          const globalAutoApprove = globalConfig === null ? true : globalConfig.value === 'true';
+          needsApproval = !globalAutoApprove;
+        }
+      }
+
       const jobQueue = getJobQueueService();
-      await jobQueue.addDownloadJob(
-        newRequest.id,
-        {
-          id: audiobookRecord.id,
-          title: audiobookRecord.title,
-          author: audiobookRecord.author,
-        },
-        torrent
-      );
 
-      logger.info(`Queued download monitor job for request ${newRequest.id}`);
+      if (needsApproval) {
+        // Create request with awaiting_approval status and store selected torrent
+        logger.info('Request requires approval, storing selected torrent', { userId: req.user.id });
 
-      return NextResponse.json({
-        success: true,
-        request: newRequest,
-      }, { status: 201 });
+        const newRequest = await prisma.request.create({
+          data: {
+            userId: req.user.id,
+            audiobookId: audiobookRecord.id,
+            status: 'awaiting_approval',
+            progress: 0,
+            selectedTorrent: torrent as any, // Store the selected torrent for later
+          },
+          include: {
+            audiobook: true,
+            user: {
+              select: {
+                id: true,
+                plexUsername: true,
+              },
+            },
+          },
+        });
+
+        // Send pending approval notification
+        await jobQueue.addNotificationJob(
+          'request_pending_approval',
+          newRequest.id,
+          audiobookRecord.title,
+          audiobookRecord.author,
+          user.plexUsername || 'Unknown User'
+        ).catch((error) => {
+          logger.error('Failed to queue notification', { error: error instanceof Error ? error.message : String(error) });
+        });
+
+        logger.info(`Request ${newRequest.id} created, awaiting admin approval`);
+
+        return NextResponse.json({
+          success: true,
+          request: newRequest,
+          message: 'Request submitted for admin approval',
+        }, { status: 201 });
+      } else {
+        // Auto-approved - create request with downloading status and start download
+        logger.info('Request auto-approved, starting download', { userId: req.user.id });
+
+        const newRequest = await prisma.request.create({
+          data: {
+            userId: req.user.id,
+            audiobookId: audiobookRecord.id,
+            status: 'downloading',
+            progress: 0,
+          },
+          include: {
+            audiobook: true,
+            user: {
+              select: {
+                id: true,
+                plexUsername: true,
+              },
+            },
+          },
+        });
+
+        // Queue download job with the selected torrent
+        await jobQueue.addDownloadJob(
+          newRequest.id,
+          {
+            id: audiobookRecord.id,
+            title: audiobookRecord.title,
+            author: audiobookRecord.author,
+          },
+          torrent
+        );
+
+        // Send approved notification
+        await jobQueue.addNotificationJob(
+          'request_approved',
+          newRequest.id,
+          audiobookRecord.title,
+          audiobookRecord.author,
+          user.plexUsername || 'Unknown User'
+        ).catch((error) => {
+          logger.error('Failed to queue notification', { error: error instanceof Error ? error.message : String(error) });
+        });
+
+        logger.info(`Request ${newRequest.id} auto-approved and download queued`);
+
+        return NextResponse.json({
+          success: true,
+          request: newRequest,
+        }, { status: 201 });
+      }
     } catch (error) {
       logger.error('Failed to create request with torrent', { error: error instanceof Error ? error.message : String(error) });
 

src/app/api/bookdate/swipe/route.ts

@@ -122,28 +122,97 @@ async function handler(req: AuthenticatedRequest) {
         });
 
         if (!existingRequest) {
+          // Check if request needs approval (same logic as POST /api/requests)
+          let needsApproval = false;
+
+          // Fetch user with autoApproveRequests setting
+          const user = await prisma.user.findUnique({
+            where: { id: userId },
+            select: {
+              role: true,
+              autoApproveRequests: true,
+              plexUsername: true,
+            },
+          });
+
+          if (!user) {
+            logger.error('User not found during request creation');
+            throw new Error('User not found');
+          }
+
+          // Determine if approval is needed
+          if (user.role === 'admin') {
+            // Admins always auto-approve
+            needsApproval = false;
+          } else {
+            // Check user's personal setting first
+            if (user.autoApproveRequests === true) {
+              needsApproval = false;
+            } else if (user.autoApproveRequests === false) {
+              needsApproval = true;
+            } else {
+              // User setting is null, check global setting
+              const globalConfig = await prisma.configuration.findUnique({
+                where: { key: 'auto_approve_requests' },
+              });
+              // Default to true if not configured (backward compatibility)
+              const globalAutoApprove = globalConfig === null ? true : globalConfig.value === 'true';
+              needsApproval = !globalAutoApprove;
+            }
+          }
+
+          // Determine initial status
+          const initialStatus = needsApproval ? 'awaiting_approval' : 'pending';
+
           const newRequest = await prisma.request.create({
             data: {
               userId,
               audiobookId: audiobook.id,
-              status: 'pending',
+              status: initialStatus,
               priority: 0,
             },
           });
 
-          logger.info(`Created request for "${recommendation.title}"`);
+          logger.info(`Created request for "${recommendation.title}" with status: ${initialStatus}`);
 
-          // Trigger search job (same as regular request creation)
+          // Import job queue service
           const { getJobQueueService } = await import('@/lib/services/job-queue.service');
           const jobQueue = getJobQueueService();
-          await jobQueue.addSearchJob(newRequest.id, {
-            id: audiobook.id,
-            title: audiobook.title,
-            author: audiobook.author,
-            asin: audiobook.audibleAsin || undefined,
-          });
 
-          logger.info(`Triggered search job for request ${newRequest.id}`);
+          // Send notification based on approval status
+          if (needsApproval) {
+            // Request needs approval - send pending notification
+            await jobQueue.addNotificationJob(
+              'request_pending_approval',
+              newRequest.id,
+              audiobook.title,
+              audiobook.author,
+              user.plexUsername || 'Unknown User'
+            ).catch((error) => {
+              logger.error('Failed to queue notification', { error: error instanceof Error ? error.message : String(error) });
+            });
+          } else {
+            // Request was auto-approved - send approved notification
+            await jobQueue.addNotificationJob(
+              'request_approved',
+              newRequest.id,
+              audiobook.title,
+              audiobook.author,
+              user.plexUsername || 'Unknown User'
+            ).catch((error) => {
+              logger.error('Failed to queue notification', { error: error instanceof Error ? error.message : String(error) });
+            });
+
+            // Trigger search job only if auto-approved
+            await jobQueue.addSearchJob(newRequest.id, {
+              id: audiobook.id,
+              title: audiobook.title,
+              author: audiobook.author,
+              asin: audiobook.audibleAsin || undefined,
+            });
+
+            logger.info(`Triggered search job for request ${newRequest.id}`);
+          }
         }
 
       } catch (error) {

src/app/api/requests/[id]/interactive-search/route.ts

@@ -63,6 +63,14 @@ export async function POST(
         );
       }
 
+      // Check if request is awaiting approval
+      if (requestRecord.status === 'awaiting_approval') {
+        return NextResponse.json(
+          { error: 'AwaitingApproval', message: 'This request is awaiting admin approval. You cannot search for torrents until it is approved.' },
+          { status: 403 }
+        );
+      }
+
       // Get enabled indexers from configuration
       const { getConfigService } = await import('@/lib/services/config.service');
       const configService = getConfigService();

src/app/api/requests/[id]/select-torrent/route.ts

@@ -62,10 +62,96 @@ export async function POST(
         );
       }
 
+      // Check if request is awaiting approval
+      if (requestRecord.status === 'awaiting_approval') {
+        return NextResponse.json(
+          { error: 'AwaitingApproval', message: 'This request is awaiting admin approval. You cannot download torrents until it is approved.' },
+          { status: 403 }
+        );
+      }
+
+      // Re-check if approval is needed based on CURRENT settings (security: settings may have changed)
+      const user = await prisma.user.findUnique({
+        where: { id: req.user.id },
+        select: {
+          role: true,
+          autoApproveRequests: true,
+          plexUsername: true,
+        },
+      });
+
+      if (!user) {
+        return NextResponse.json(
+          { error: 'UserNotFound', message: 'User not found' },
+          { status: 404 }
+        );
+      }
+
+      let needsApproval = false;
+
+      // Determine if approval is needed (same logic as request creation)
+      if (user.role === 'admin') {
+        // Admins always auto-approve
+        needsApproval = false;
+      } else {
+        // Check user's personal setting first
+        if (user.autoApproveRequests === true) {
+          needsApproval = false;
+        } else if (user.autoApproveRequests === false) {
+          needsApproval = true;
+        } else {
+          // User setting is null, check global setting
+          const globalConfig = await prisma.configuration.findUnique({
+            where: { key: 'auto_approve_requests' },
+          });
+          // Default to true if not configured (backward compatibility)
+          const globalAutoApprove = globalConfig === null ? true : globalConfig.value === 'true';
+          needsApproval = !globalAutoApprove;
+        }
+      }
+
+      const jobQueue = getJobQueueService();
+
+      // If approval is now needed, store torrent and wait for approval
+      if (needsApproval) {
+        logger.info(`Torrent selection requires approval`, { requestId: id, userId: req.user.id });
+
+        const updated = await prisma.request.update({
+          where: { id },
+          data: {
+            status: 'awaiting_approval',
+            selectedTorrent: torrent as any, // Store the selected torrent
+            updatedAt: new Date(),
+          },
+          include: {
+            audiobook: true,
+          },
+        });
+
+        // Send pending approval notification
+        await jobQueue.addNotificationJob(
+          'request_pending_approval',
+          updated.id,
+          requestRecord.audiobook.title,
+          requestRecord.audiobook.author,
+          user.plexUsername || 'Unknown User'
+        ).catch((error) => {
+          logger.error('Failed to queue notification', { error: error instanceof Error ? error.message : String(error) });
+        });
+
+        logger.info(`Request ${id} stored selected torrent and awaits admin approval`);
+
+        return NextResponse.json({
+          success: true,
+          request: updated,
+          message: 'Request submitted for admin approval',
+        });
+      }
+
+      // Auto-approved - start download immediately
       logger.info(`User selected torrent: ${torrent.title}`, { requestId: id });
 
       // Trigger download job with the selected torrent
-      const jobQueue = getJobQueueService();
       await jobQueue.addDownloadJob(
         id,
         {
@@ -76,6 +162,17 @@ export async function POST(
         torrent
       );
 
+      // Send approved notification (user has now committed to downloading)
+      await jobQueue.addNotificationJob(
+        'request_approved',
+        id,
+        requestRecord.audiobook.title,
+        requestRecord.audiobook.author,
+        user.plexUsername || 'Unknown User'
+      ).catch((error) => {
+        logger.error('Failed to queue notification', { error: error instanceof Error ? error.message : String(error) });
+      });
+
       // Update request status
       const updated = await prisma.request.update({
         where: { id },

src/app/api/requests/route.ts

@@ -252,9 +252,35 @@ export async function POST(request: NextRequest) {
         },
       });
 
+      const jobQueue = getJobQueueService();
+
+      // Send notification based on approval status
+      if (initialStatus === 'awaiting_approval') {
+        // Request needs approval - send pending notification
+        await jobQueue.addNotificationJob(
+          'request_pending_approval',
+          newRequest.id,
+          audiobookRecord.title,
+          audiobookRecord.author,
+          newRequest.user.plexUsername || 'Unknown User'
+        ).catch((error) => {
+          logger.error('Failed to queue notification', { error: error instanceof Error ? error.message : String(error) });
+        });
+      } else {
+        // Request was auto-approved (either automatic or interactive search) - send approved notification
+        await jobQueue.addNotificationJob(
+          'request_approved',
+          newRequest.id,
+          audiobookRecord.title,
+          audiobookRecord.author,
+          newRequest.user.plexUsername || 'Unknown User'
+        ).catch((error) => {
+          logger.error('Failed to queue notification', { error: error instanceof Error ? error.message : String(error) });
+        });
+      }
+
       // Trigger search job only if not skipped and not awaiting approval
       if (shouldTriggerSearch) {
-        const jobQueue = getJobQueueService();
         await jobQueue.addSearchJob(newRequest.id, {
           id: audiobookRecord.id,
           title: audiobookRecord.title,