coursewatcher 1.0.0

package/public/js/player.js

@@ -0,0 +1,316 @@
+/**
+ * Video Player Controls
+ * 
+ * Handles keyboard shortcuts, playback controls, and progress auto-save.
+ */
+
+(function () {
+    'use strict';
+
+    // Constants
+    const SPEED_STEP = 0.25;
+    const MIN_SPEED = 0.25;
+    const MAX_SPEED = 4.0;
+    const SEEK_SHORT = 5;
+    const SEEK_MEDIUM = 10;
+    const SEEK_LONG = 30;
+    const SAVE_INTERVAL = 5000; // Save progress every 5 seconds
+
+    // Elements
+    const video = document.getElementById('videoPlayer');
+    const speedDisplay = document.getElementById('speedDisplay');
+    const speedDown = document.getElementById('speedDown');
+    const speedUp = document.getElementById('speedUp');
+    const seekBack5 = document.getElementById('seekBack5');
+    const seekForward5 = document.getElementById('seekForward5');
+    const seekForward10 = document.getElementById('seekForward10');
+    const statusButtons = document.querySelectorAll('.status-btn');
+    const notesEditor = document.getElementById('notesEditor');
+    const saveNotesBtn = document.getElementById('saveNotes');
+    const notesSaveStatus = document.getElementById('notesSaveStatus');
+
+    if (!video) return;
+
+    const videoId = video.dataset.videoId;
+    const savedPosition = parseFloat(video.dataset.savedPosition) || 0;
+
+    let saveTimeout = null;
+    let lastSavedPosition = savedPosition;
+
+    // ==========================================
+    // Initialization
+    // ==========================================
+
+    /**
+     * Initialize player
+     */
+    function init() {
+        // Restore saved position
+        video.addEventListener('loadedmetadata', () => {
+            if (savedPosition > 0 && savedPosition < video.duration) {
+                video.currentTime = savedPosition;
+            }
+            updateSpeedDisplay();
+        });
+
+        // Set up event listeners
+        setupPlaybackControls();
+        setupStatusControls();
+        setupKeyboardShortcuts();
+        setupNotesControls();
+        setupProgressAutoSave();
+    }
+
+    // ==========================================
+    // Playback Controls
+    // ==========================================
+
+    function setupPlaybackControls() {
+        speedDown?.addEventListener('click', () => changeSpeed(-SPEED_STEP));
+        speedUp?.addEventListener('click', () => changeSpeed(SPEED_STEP));
+        seekBack5?.addEventListener('click', () => seek(-SEEK_SHORT));
+        seekForward5?.addEventListener('click', () => seek(SEEK_SHORT));
+        seekForward10?.addEventListener('click', () => seek(SEEK_MEDIUM));
+    }
+
+    function changeSpeed(delta) {
+        let newSpeed = video.playbackRate + delta;
+        newSpeed = Math.max(MIN_SPEED, Math.min(MAX_SPEED, newSpeed));
+        newSpeed = Math.round(newSpeed * 100) / 100; // Fix floating point
+        video.playbackRate = newSpeed;
+        updateSpeedDisplay();
+    }
+
+    function updateSpeedDisplay() {
+        if (speedDisplay) {
+            speedDisplay.textContent = video.playbackRate.toFixed(2) + 'x';
+        }
+    }
+
+    function seek(seconds) {
+        video.currentTime = Math.max(0, Math.min(video.duration, video.currentTime + seconds));
+    }
+
+    // ==========================================
+    // Status Controls
+    // ==========================================
+
+    function setupStatusControls() {
+        statusButtons.forEach(btn => {
+            btn.addEventListener('click', () => {
+                const status = btn.dataset.status;
+                updateStatus(status);
+            });
+        });
+    }
+
+    async function updateStatus(status) {
+        try {
+            const response = await fetch(`/api/videos/${videoId}/status`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ status }),
+            });
+
+            if (response.ok) {
+                // Update UI
+                statusButtons.forEach(btn => {
+                    btn.classList.toggle('active', btn.dataset.status === status);
+                });
+            }
+        } catch (err) {
+            console.error('Failed to update status:', err);
+        }
+    }
+
+    // ==========================================
+    // Keyboard Shortcuts
+    // ==========================================
+
+    function setupKeyboardShortcuts() {
+        document.addEventListener('keydown', (e) => {
+            // Ignore if typing in notes
+            if (e.target.tagName === 'TEXTAREA' || e.target.tagName === 'INPUT') {
+                return;
+            }
+
+            switch (e.key.toLowerCase()) {
+                case ' ':
+                    e.preventDefault();
+                    video.paused ? video.play() : video.pause();
+                    break;
+                case 'w':
+                    changeSpeed(-SPEED_STEP);
+                    break;
+                case 'e':
+                    changeSpeed(SPEED_STEP);
+                    break;
+                case 'j':
+                    seek(e.shiftKey ? -SEEK_LONG : -SEEK_SHORT);
+                    break;
+                case 'k':
+                    seek(SEEK_SHORT);
+                    break;
+                case 'l':
+                    seek(e.shiftKey ? SEEK_LONG : SEEK_MEDIUM);
+                    break;
+                case 'arrowleft':
+                    seek(-SEEK_SHORT);
+                    break;
+                case 'arrowright':
+                    seek(SEEK_SHORT);
+                    break;
+                case 'arrowup':
+                    e.preventDefault();
+                    video.volume = Math.min(1, video.volume + 0.1);
+                    break;
+                case 'arrowdown':
+                    e.preventDefault();
+                    video.volume = Math.max(0, video.volume - 0.1);
+                    break;
+                case 'm':
+                    video.muted = !video.muted;
+                    break;
+                case 'f':
+                    toggleFullscreen();
+                    break;
+            }
+        });
+    }
+
+    function toggleFullscreen() {
+        if (document.fullscreenElement) {
+            document.exitFullscreen();
+        } else {
+            video.requestFullscreen?.() || video.webkitRequestFullscreen?.();
+        }
+    }
+
+    // ==========================================
+    // Progress Auto-Save
+    // ==========================================
+
+    function setupProgressAutoSave() {
+        // Save on pause
+        video.addEventListener('pause', saveProgress);
+
+        // Save on video end
+        video.addEventListener('ended', () => {
+            saveProgress();
+            updateStatus('completed');
+        });
+
+        // Periodic save during playback
+        video.addEventListener('timeupdate', () => {
+            const currentPos = Math.floor(video.currentTime);
+
+            // Only save every 5 seconds of playback
+            if (Math.abs(currentPos - lastSavedPosition) >= 5) {
+                scheduleProgressSave();
+            }
+        });
+
+        // Save before page unload
+        window.addEventListener('beforeunload', () => {
+            saveProgressSync();
+        });
+    }
+
+    function scheduleProgressSave() {
+        if (saveTimeout) return;
+
+        saveTimeout = setTimeout(() => {
+            saveProgress();
+            saveTimeout = null;
+        }, 1000);
+    }
+
+    async function saveProgress() {
+        const position = video.currentTime;
+        const duration = video.duration;
+
+        if (isNaN(position) || isNaN(duration)) return;
+
+        try {
+            await fetch(`/api/videos/${videoId}/progress`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ position, duration }),
+            });
+            lastSavedPosition = position;
+        } catch (err) {
+            console.error('Failed to save progress:', err);
+        }
+    }
+
+    function saveProgressSync() {
+        const position = video.currentTime;
+        const duration = video.duration;
+
+        if (isNaN(position) || isNaN(duration)) return;
+
+        // Use sendBeacon for reliable delivery on page unload
+        navigator.sendBeacon(
+            `/api/videos/${videoId}/progress`,
+            new Blob([JSON.stringify({ position, duration })], { type: 'application/json' })
+        );
+    }
+
+    // ==========================================
+    // Notes Controls
+    // ==========================================
+
+    function setupNotesControls() {
+        if (!saveNotesBtn || !notesEditor) return;
+
+        saveNotesBtn.addEventListener('click', saveNotes);
+
+        // Auto-save notes on blur
+        notesEditor.addEventListener('blur', saveNotes);
+
+        // Ctrl+S to save notes
+        notesEditor.addEventListener('keydown', (e) => {
+            if ((e.ctrlKey || e.metaKey) && e.key === 's') {
+                e.preventDefault();
+                saveNotes();
+            }
+        });
+    }
+
+    async function saveNotes() {
+        const content = notesEditor.value;
+
+        try {
+            const response = await fetch(`/api/videos/${videoId}/notes`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ content }),
+            });
+
+            if (response.ok) {
+                showSaveStatus('✓ Saved');
+            } else {
+                showSaveStatus('✗ Error saving');
+            }
+        } catch (err) {
+            console.error('Failed to save notes:', err);
+            showSaveStatus('✗ Error saving');
+        }
+    }
+
+    function showSaveStatus(message) {
+        if (!notesSaveStatus) return;
+
+        notesSaveStatus.textContent = message;
+        setTimeout(() => {
+            notesSaveStatus.textContent = '';
+        }, 2000);
+    }
+
+    // Initialize when DOM is ready
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+})();

package/src/controllers/video-controller.js

@@ -0,0 +1,173 @@
+/**
+ * Video Controller
+ * 
+ * Route handlers for video-related pages and API endpoints.
+ * 
+ * @module controllers/video-controller
+ */
+
+const path = require('path');
+const express = require('express');
+const { NotFoundError } = require('../utils/errors');
+
+/**
+ * Create video routes
+ * @param {Object} services - Service instances
+ * @returns {express.Router} Express router
+ */
+function createVideoRoutes(services) {
+    const router = express.Router();
+    const { videoService, progressService, notesService } = services;
+
+    // ============================================
+    // Page Routes
+    // ============================================
+
+    /**
+     * Home page - List all modules and videos
+     */
+    router.get('/', (req, res) => {
+        const sortBy = req.query.sort || 'name';
+        const modules = videoService.getAllModulesWithVideos(sortBy);
+        const stats = videoService.getStats();
+
+        res.render('pages/index', {
+            title: 'CourseWatcher',
+            modules,
+            stats,
+            currentSort: sortBy,
+        });
+    });
+
+    /**
+     * Video player page
+     */
+    router.get('/video/:id', (req, res, next) => {
+        try {
+            const videoId = parseInt(req.params.id, 10);
+            const video = videoService.getVideoById(videoId);
+            const adjacent = videoService.getAdjacentVideos(videoId);
+            const notes = notesService.getNotes(videoId);
+
+            res.render('pages/player', {
+                title: video.title,
+                video,
+                adjacent,
+                notes,
+            });
+        } catch (err) {
+            next(err);
+        }
+    });
+
+    /**
+     * Search page
+     */
+    router.get('/search', (req, res) => {
+        const query = req.query.q || '';
+        const results = query ? videoService.searchVideos(query) : [];
+
+        res.render('pages/search', {
+            title: 'Search',
+            query,
+            results,
+        });
+    });
+
+    // ============================================
+    // API Routes
+    // ============================================
+
+    /**
+     * Stream video file
+     */
+    router.get('/api/videos/:id/stream', (req, res, next) => {
+        try {
+            const videoId = parseInt(req.params.id, 10);
+            const video = videoService.getVideoById(videoId);
+
+            res.sendFile(video.path);
+        } catch (err) {
+            next(err);
+        }
+    });
+
+    /**
+     * Update video progress (position)
+     */
+    router.post('/api/videos/:id/progress', express.json(), (req, res, next) => {
+        try {
+            const videoId = parseInt(req.params.id, 10);
+            const { position, duration } = req.body;
+
+            const updated = progressService.updatePosition(videoId, position, duration);
+            res.json({ success: true, video: updated });
+        } catch (err) {
+            next(err);
+        }
+    });
+
+    /**
+     * Update video status
+     */
+    router.post('/api/videos/:id/status', express.json(), (req, res, next) => {
+        try {
+            const videoId = parseInt(req.params.id, 10);
+            const { status } = req.body;
+
+            const updated = progressService.updateStatus(videoId, status);
+            res.json({ success: true, video: updated });
+        } catch (err) {
+            next(err);
+        }
+    });
+
+    /**
+     * Get video notes
+     */
+    router.get('/api/videos/:id/notes', (req, res, next) => {
+        try {
+            const videoId = parseInt(req.params.id, 10);
+            const notes = notesService.getNotes(videoId);
+            res.json(notes);
+        } catch (err) {
+            next(err);
+        }
+    });
+
+    /**
+     * Save video notes
+     */
+    router.post('/api/videos/:id/notes', express.json(), (req, res, next) => {
+        try {
+            const videoId = parseInt(req.params.id, 10);
+            const { content } = req.body;
+
+            const notes = notesService.saveNotes(videoId, content);
+            res.json({ success: true, notes });
+        } catch (err) {
+            next(err);
+        }
+    });
+
+    /**
+     * Search API endpoint
+     */
+    router.get('/api/search', (req, res) => {
+        const query = req.query.q || '';
+        const results = query ? videoService.searchVideos(query) : [];
+        res.json(results);
+    });
+
+    /**
+     * Get course stats
+     */
+    router.get('/api/stats', (req, res) => {
+        const stats = videoService.getStats();
+        res.json(stats);
+    });
+
+    return router;
+}
+
+module.exports = { createVideoRoutes };

package/src/models/database.js

@@ -0,0 +1,169 @@
+/**
+ * Database Module
+ * 
+ * SQLite database connection manager using better-sqlite3.
+ * Handles schema creation and provides query methods.
+ * 
+ * @module models/database
+ */
+
+const Database = require('better-sqlite3');
+const path = require('path');
+const fs = require('fs');
+const { getDbPath, getDataFolder } = require('../utils/config');
+const { DatabaseError } = require('../utils/errors');
+
+/**
+ * Database manager class
+ */
+class DatabaseManager {
+    /**
+     * Create a new DatabaseManager
+     * @param {string} coursePath - Path to the course directory
+     */
+    constructor(coursePath) {
+        this._coursePath = coursePath;
+        this._db = null;
+    }
+
+    /**
+     * Initialize the database connection and create schema
+     * @returns {DatabaseManager} This instance for chaining
+     */
+    initialize() {
+        try {
+            // Ensure .coursewatcher folder exists
+            const dataFolder = getDataFolder(this._coursePath);
+            if (!fs.existsSync(dataFolder)) {
+                fs.mkdirSync(dataFolder, { recursive: true });
+            }
+
+            // Open database connection
+            const dbPath = getDbPath(this._coursePath);
+            this._db = new Database(dbPath);
+
+            // Enable foreign keys
+            this._db.pragma('foreign_keys = ON');
+
+            // Create schema
+            this._createSchema();
+
+            return this;
+        } catch (err) {
+            throw new DatabaseError(`Failed to initialize database: ${err.message}`);
+        }
+    }
+
+    /**
+     * Create database schema
+     * @private
+     */
+    _createSchema() {
+        // Modules table
+        this._db.exec(`
+      CREATE TABLE IF NOT EXISTS modules (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        path TEXT NOT NULL UNIQUE,
+        sort_order INTEGER DEFAULT 0,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+
+        // Videos table
+        this._db.exec(`
+      CREATE TABLE IF NOT EXISTS videos (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        path TEXT NOT NULL UNIQUE,
+        filename TEXT NOT NULL,
+        title TEXT NOT NULL,
+        duration REAL DEFAULT 0,
+        position REAL DEFAULT 0,
+        status TEXT CHECK(status IN ('unwatched', 'in-progress', 'completed')) DEFAULT 'unwatched',
+        module_id INTEGER,
+        sort_order INTEGER DEFAULT 0,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (module_id) REFERENCES modules(id) ON DELETE SET NULL
+      )
+    `);
+
+        // Notes table
+        this._db.exec(`
+      CREATE TABLE IF NOT EXISTS notes (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        video_id INTEGER NOT NULL UNIQUE,
+        content TEXT DEFAULT '',
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (video_id) REFERENCES videos(id) ON DELETE CASCADE
+      )
+    `);
+
+        // Create indexes
+        this._db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_videos_module ON videos(module_id);
+      CREATE INDEX IF NOT EXISTS idx_videos_status ON videos(status);
+      CREATE INDEX IF NOT EXISTS idx_videos_path ON videos(path);
+    `);
+    }
+
+    /**
+     * Get a single row from a query
+     * @param {string} sql - SQL query
+     * @param {Array} params - Query parameters
+     * @returns {Object|undefined} The row or undefined
+     */
+    get(sql, params = []) {
+        return this._db.prepare(sql).get(...params);
+    }
+
+    /**
+     * Get all rows from a query
+     * @param {string} sql - SQL query
+     * @param {Array} params - Query parameters
+     * @returns {Array} Array of rows
+     */
+    all(sql, params = []) {
+        return this._db.prepare(sql).all(...params);
+    }
+
+    /**
+     * Run an insert/update/delete query
+     * @param {string} sql - SQL query
+     * @param {Array} params - Query parameters
+     * @returns {Object} Result with changes and lastInsertRowid
+     */
+    run(sql, params = []) {
+        return this._db.prepare(sql).run(...params);
+    }
+
+    /**
+     * Run multiple statements in a transaction
+     * @param {Function} fn - Function containing database operations
+     * @returns {*} Result of the transaction function
+     */
+    transaction(fn) {
+        return this._db.transaction(fn)();
+    }
+
+    /**
+     * Close the database connection
+     */
+    close() {
+        if (this._db) {
+            this._db.close();
+            this._db = null;
+        }
+    }
+
+    /**
+     * Get the course path
+     * @returns {string} The course path
+     */
+    getCoursePath() {
+        return this._coursePath;
+    }
+}
+
+module.exports = { DatabaseManager };