coursewatcher 1.0.0

package/src/server.js

@@ -0,0 +1,152 @@
+/**
+ * Express Server
+ * 
+ * Main server configuration and startup.
+ * 
+ * @module server
+ */
+
+const express = require('express');
+const path = require('path');
+const open = require('open');
+
+const { DatabaseManager } = require('./models/database');
+const { VideoService } = require('./services/video-service');
+const { ProgressService } = require('./services/progress-service');
+const { NotesService } = require('./services/notes-service');
+const { createVideoRoutes } = require('./controllers/video-controller');
+const { log, success, error } = require('./utils/logger');
+const chalk = require('chalk');
+
+/**
+ * Start the CourseWatcher server
+ * @param {Object} options - Server options
+ * @param {string} options.coursePath - Path to course directory
+ * @param {number} options.port - Server port
+ * @param {boolean} options.openBrowser - Whether to open browser
+ * @returns {Promise<Object>} Server instance and services
+ */
+async function startServer(options) {
+    const { coursePath, port, openBrowser } = options;
+
+    // Initialize database
+    log('Initializing database...');
+    const database = new DatabaseManager(coursePath);
+    database.initialize();
+
+    // Create services
+    const videoService = new VideoService(database);
+    const progressService = new ProgressService(database);
+    const notesService = new NotesService(database);
+
+    // Scan for videos
+    log('Scanning for video files...');
+    const scanResult = videoService.scanVideos();
+    success(`Found ${scanResult.total} videos (${scanResult.added} new, ${scanResult.existing} existing)`);
+
+    // Create Express app
+    const app = express();
+
+    // Configure EJS
+    app.set('view engine', 'ejs');
+    app.set('views', path.join(__dirname, '..', 'views'));
+
+    // Static files
+    app.use('/static', express.static(path.join(__dirname, '..', 'public')));
+
+    // Routes
+    app.use('/', createVideoRoutes({
+        videoService,
+        progressService,
+        notesService,
+    }));
+
+    // Error handling middleware
+    app.use((err, req, res, next) => {
+        const statusCode = err.statusCode || 500;
+        const message = err.message || 'Internal Server Error';
+
+        // Log error in development
+        if (process.env.NODE_ENV !== 'production') {
+            error(`${err.name}: ${message}`);
+            if (err.stack) {
+                console.error(err.stack);
+            }
+        }
+
+        // API errors return JSON
+        if (req.path.startsWith('/api/')) {
+            return res.status(statusCode).json({
+                error: true,
+                message,
+            });
+        }
+
+        // Page errors render error page
+        res.status(statusCode).render('pages/error', {
+            title: 'Error',
+            statusCode,
+            message,
+        });
+    });
+
+    // Start server
+    return new Promise((resolve, reject) => {
+        const server = app.listen(port, () => {
+            const url = `http://localhost:${port}`;
+            success(`Server running at ${chalk.cyan(url)}`);
+
+            // Open browser if requested
+            if (openBrowser) {
+                log('Opening browser...');
+                open(url).catch(() => {
+                    // Ignore browser open errors
+                });
+            }
+
+            // Handle graceful shutdown
+            let isShuttingDown = false;
+            const shutdown = async (signal) => {
+                if (isShuttingDown) return;
+                isShuttingDown = true;
+
+                log(`\nShutting down... (${signal})`);
+
+                // Force exit after timeout if graceful shutdown fails
+                const forceExitTimeout = setTimeout(() => {
+                    error('Forced shutdown after timeout');
+                    process.exit(1);
+                }, 5000);
+
+                database.close();
+                server.close(() => {
+                    clearTimeout(forceExitTimeout);
+                    success('Server closed');
+                    process.exit(0);
+                });
+            };
+
+            process.on('SIGINT', () => shutdown('SIGINT'));
+            process.on('SIGTERM', () => shutdown('SIGTERM'));
+
+            resolve({
+                server,
+                database,
+                services: {
+                    videoService,
+                    progressService,
+                    notesService,
+                },
+            });
+        });
+
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                error(`Port ${port} is already in use`);
+            }
+            reject(err);
+        });
+    });
+}
+
+module.exports = { startServer };

package/src/services/notes-service.js

@@ -0,0 +1,97 @@
+/**
+ * Notes Service
+ * 
+ * Handles per-video notes with Markdown support.
+ * 
+ * @module services/notes-service
+ */
+
+const { NotFoundError } = require('../utils/errors');
+
+/**
+ * Notes service class
+ */
+class NotesService {
+    /**
+     * Create a new NotesService
+     * @param {DatabaseManager} database - Database manager instance
+     */
+    constructor(database) {
+        this._db = database;
+    }
+
+    /**
+     * Get notes for a video
+     * @param {number} videoId - Video ID
+     * @returns {Object} Notes object
+     */
+    getNotes(videoId) {
+        // Verify video exists
+        const video = this._db.get('SELECT id FROM videos WHERE id = ?', [videoId]);
+        if (!video) {
+            throw new NotFoundError(`Video with id ${videoId}`);
+        }
+
+        const notes = this._db.get(
+            'SELECT * FROM notes WHERE video_id = ?',
+            [videoId]
+        );
+
+        return notes || { video_id: videoId, content: '' };
+    }
+
+    /**
+     * Save notes for a video
+     * @param {number} videoId - Video ID
+     * @param {string} content - Note content (Markdown)
+     * @returns {Object} Updated notes
+     */
+    saveNotes(videoId, content) {
+        // Verify video exists
+        const video = this._db.get('SELECT id FROM videos WHERE id = ?', [videoId]);
+        if (!video) {
+            throw new NotFoundError(`Video with id ${videoId}`);
+        }
+
+        // Upsert notes
+        this._db.run(
+            `INSERT INTO notes (video_id, content, updated_at)
+       VALUES (?, ?, CURRENT_TIMESTAMP)
+       ON CONFLICT(video_id) DO UPDATE SET
+         content = excluded.content,
+         updated_at = CURRENT_TIMESTAMP`,
+            [videoId, content]
+        );
+
+        return this.getNotes(videoId);
+    }
+
+    /**
+     * Delete notes for a video
+     * @param {number} videoId - Video ID
+     * @returns {boolean} True if deleted
+     */
+    deleteNotes(videoId) {
+        const result = this._db.run(
+            'DELETE FROM notes WHERE video_id = ?',
+            [videoId]
+        );
+        return result.changes > 0;
+    }
+
+    /**
+     * Get all videos with notes
+     * @returns {Array} Videos with notes
+     */
+    getVideosWithNotes() {
+        return this._db.all(
+            `SELECT v.*, n.content as notes_content
+       FROM videos v
+       INNER JOIN notes n ON v.id = n.video_id
+       WHERE n.content != ''
+       ORDER BY v.sort_order, v.filename`
+        );
+    }
+}
+
+module.exports = { NotesService };

package/src/services/progress-service.js

@@ -0,0 +1,148 @@
+/**
+ * Progress Service
+ * 
+ * Handles video playback progress tracking and status updates.
+ * 
+ * @module services/progress-service
+ */
+
+const { config } = require('../utils/config');
+const { NotFoundError, ValidationError } = require('../utils/errors');
+
+/**
+ * Progress service class
+ */
+class ProgressService {
+    /**
+     * Create a new ProgressService
+     * @param {DatabaseManager} database - Database manager instance
+     */
+    constructor(database) {
+        this._db = database;
+    }
+
+    /**
+     * Update the playback position for a video
+     * @param {number} videoId - Video ID
+     * @param {number} position - Current position in seconds
+     * @param {number} [duration] - Video duration in seconds
+     * @returns {Object} Updated video
+     */
+    updatePosition(videoId, position, duration = null) {
+        // Validate inputs
+        if (typeof position !== 'number' || position < 0) {
+            throw new ValidationError('Position must be a non-negative number');
+        }
+
+        // Get current video
+        const video = this._db.get('SELECT * FROM videos WHERE id = ?', [videoId]);
+        if (!video) {
+            throw new NotFoundError(`Video with id ${videoId}`);
+        }
+
+        // Determine new status based on position
+        let newStatus = video.status;
+        const videoDuration = duration || video.duration;
+
+        if (videoDuration > 0) {
+            const watchPercent = position / videoDuration;
+
+            if (watchPercent >= config.completionThreshold) {
+                newStatus = 'completed';
+            } else if (position > 0) {
+                newStatus = 'in-progress';
+            }
+        } else if (position > 0 && video.status === 'unwatched') {
+            newStatus = 'in-progress';
+        }
+
+        // Update database
+        this._db.run(
+            `UPDATE videos 
+       SET position = ?, 
+           duration = COALESCE(?, duration),
+           status = ?,
+           updated_at = CURRENT_TIMESTAMP
+       WHERE id = ?`,
+            [position, duration, newStatus, videoId]
+        );
+
+        return this._db.get('SELECT * FROM videos WHERE id = ?', [videoId]);
+    }
+
+    /**
+     * Update video status manually
+     * @param {number} videoId - Video ID
+     * @param {string} status - New status
+     * @returns {Object} Updated video
+     */
+    updateStatus(videoId, status) {
+        const validStatuses = ['unwatched', 'in-progress', 'completed'];
+
+        if (!validStatuses.includes(status)) {
+            throw new ValidationError(
+                `Invalid status. Must be one of: ${validStatuses.join(', ')}`
+            );
+        }
+
+        const video = this._db.get('SELECT * FROM videos WHERE id = ?', [videoId]);
+        if (!video) {
+            throw new NotFoundError(`Video with id ${videoId}`);
+        }
+
+        // Reset position if marking as unwatched
+        const newPosition = status === 'unwatched' ? 0 : video.position;
+
+        this._db.run(
+            `UPDATE videos 
+       SET status = ?, 
+           position = ?,
+           updated_at = CURRENT_TIMESTAMP
+       WHERE id = ?`,
+            [status, newPosition, videoId]
+        );
+
+        return this._db.get('SELECT * FROM videos WHERE id = ?', [videoId]);
+    }
+
+    /**
+     * Mark video as completed
+     * @param {number} videoId - Video ID
+     * @returns {Object} Updated video
+     */
+    markCompleted(videoId) {
+        return this.updateStatus(videoId, 'completed');
+    }
+
+    /**
+     * Mark video as unwatched (reset progress)
+     * @param {number} videoId - Video ID
+     * @returns {Object} Updated video
+     */
+    markUnwatched(videoId) {
+        return this.updateStatus(videoId, 'unwatched');
+    }
+
+    /**
+     * Get video progress info
+     * @param {number} videoId - Video ID
+     * @returns {Object} Progress info
+     */
+    getProgress(videoId) {
+        const video = this._db.get('SELECT * FROM videos WHERE id = ?', [videoId]);
+        if (!video) {
+            throw new NotFoundError(`Video with id ${videoId}`);
+        }
+
+        return {
+            position: video.position,
+            duration: video.duration,
+            status: video.status,
+            percentWatched: video.duration > 0
+                ? Math.round((video.position / video.duration) * 100)
+                : 0,
+        };
+    }
+}
+
+module.exports = { ProgressService };