Initial commit

src/lib/processors/match-plex.processor.ts

@@ -0,0 +1,191 @@
+/**
+ * Component: Match Library Job Processor
+ * Documentation: documentation/phase3/README.md
+ *
+ * DEPRECATED: This processor is deprecated. Matching is now handled by scan_library job.
+ * Kept for backwards compatibility but should not be used in new code.
+ */
+
+import { MatchPlexPayload } from '../services/job-queue.service';
+import { prisma } from '../db';
+import { getLibraryService } from '../services/library';
+import { compareTwoStrings } from 'string-similarity';
+import { getConfigService } from '../services/config.service';
+import { createJobLogger } from '../utils/job-logger';
+
+/**
+ * Process match library job (DEPRECATED - use scan_library instead)
+ * Fuzzy matches requested audiobook to library item and updates status
+ */
+export async function processMatchPlex(payload: MatchPlexPayload): Promise<any> {
+  const { requestId, audiobookId, title, author, jobId } = payload;
+
+  const logger = jobId ? createJobLogger(jobId, 'MatchLibrary') : null;
+
+  await logger?.warn('DEPRECATED: match_plex job is deprecated. Use scan_plex instead.');
+  await logger?.info(`Matching "${title}" by ${author} in library`);
+
+  try {
+    // Get library service and configuration
+    const configService = getConfigService();
+    const libraryService = await getLibraryService();
+    const backendMode = await configService.getBackendMode();
+
+    await logger?.info(`Backend mode: ${backendMode}`);
+
+    // Get configured library ID
+    const libraryId = backendMode === 'audiobookshelf'
+      ? await configService.get('audiobookshelf.library_id')
+      : (await configService.getPlexConfig()).libraryId;
+
+    if (!libraryId) {
+      throw new Error(`${backendMode} library not configured`);
+    }
+
+    // Search library using abstraction layer
+    const searchResults = await libraryService.searchItems(libraryId, title);
+
+    await logger?.info(`Found ${searchResults.length} results in library`);
+
+    if (searchResults.length === 0) {
+      await logger?.warn(`No matches found in library for "${title}"`);
+
+      // Mark as completed anyway - the file is there, library just needs time to scan
+      await prisma.request.update({
+        where: { id: requestId },
+        data: {
+          status: 'completed',
+          updatedAt: new Date(),
+          completedAt: new Date(),
+        },
+      });
+
+      return {
+        success: true,
+        message: 'No library match found yet, but request completed',
+        requestId,
+        matched: false,
+        note: 'Library may need time to scan the new files',
+      };
+    }
+
+    // Fuzzy match against results
+    const matches = searchResults.map((item) => {
+      const titleScore = compareTwoStrings(title.toLowerCase(), (item.title || '').toLowerCase());
+      const authorScore = author
+        ? compareTwoStrings(author.toLowerCase(), (item.author || '').toLowerCase())
+        : 0.5;
+
+      // Weighted average: title is more important
+      const overallScore = titleScore * 0.7 + authorScore * 0.3;
+
+      return {
+        item,
+        score: overallScore,
+        titleScore,
+        authorScore,
+      };
+    });
+
+    // Sort by score
+    matches.sort((a, b) => b.score - a.score);
+
+    const bestMatch = matches[0];
+
+    await logger?.info(`Best match: "${bestMatch.item.title}" by ${bestMatch.item.author || 'Unknown'}`, {
+      score: Math.round(bestMatch.score * 100),
+      titleScore: Math.round(bestMatch.titleScore * 100),
+      authorScore: Math.round(bestMatch.authorScore * 100),
+    });
+
+    // Accept match if score >= 70%
+    if (bestMatch.score >= 0.7) {
+      await logger?.info(`Match accepted!`);
+
+      // Update audiobook with library item ID
+      const updateData: any = {
+        completedAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      if (backendMode === 'audiobookshelf') {
+        updateData.absItemId = bestMatch.item.externalId;
+      } else {
+        updateData.plexGuid = bestMatch.item.externalId;
+      }
+
+      await prisma.audiobook.update({
+        where: { id: audiobookId },
+        data: updateData,
+      });
+
+      // Ensure request is marked as completed
+      await prisma.request.update({
+        where: { id: requestId },
+        data: {
+          status: 'completed',
+          updatedAt: new Date(),
+          completedAt: new Date(),
+        },
+      });
+
+      return {
+        success: true,
+        message: `Successfully matched audiobook in library (${backendMode})`,
+        backendMode,
+        requestId,
+        matched: true,
+        matchScore: bestMatch.score,
+        libraryItem: {
+          title: bestMatch.item.title,
+          author: bestMatch.item.author,
+          id: bestMatch.item.id,
+          externalId: bestMatch.item.externalId,
+        },
+      };
+    } else {
+      await logger?.warn(`Match score too low (${Math.round(bestMatch.score * 100)}%), but marking as completed anyway`);
+
+      // Mark as completed even if match is poor
+      await prisma.request.update({
+        where: { id: requestId },
+        data: {
+          status: 'completed',
+          updatedAt: new Date(),
+          completedAt: new Date(),
+        },
+      });
+
+      return {
+        success: true,
+        message: 'Request completed, but library match uncertain',
+        requestId,
+        matched: false,
+        matchScore: bestMatch.score,
+        note: `Low match score: ${Math.round(bestMatch.score * 100)}%`,
+      };
+    }
+  } catch (error) {
+    await logger?.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+
+    // Don't fail the request - the files are organized correctly
+    // Just log the error and mark as completed
+    await prisma.request.update({
+      where: { id: requestId },
+      data: {
+        status: 'completed',
+        errorMessage: `Library matching failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        updatedAt: new Date(),
+        completedAt: new Date(),
+      },
+    });
+
+    return {
+      success: false,
+      message: 'Request completed despite library matching error',
+      requestId,
+      matched: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    };
+  }
+}