Upload folder using huggingface_hub

.gitattributes

@@ -0,0 +1,2 @@
+backups/releases/release-2025-08-10T10-33-12-791Z/backend-a2c8b99.tar.gz filter=lfs diff=lfs merge=lfs -text
+backups/releases/release-2025-08-10T10-33-12-791Z/frontend-6d6d7c2.tar.gz filter=lfs diff=lfs merge=lfs -text

SECURITY_ENHANCEMENT_PLAN.md

@@ -0,0 +1,433 @@
+# 🔒 Security Enhancement Plan for Transcreation Sandbox
+
+## **1. Enhanced Authentication & Authorization**
+
+### **Current State:**
+- Simple token-based auth with `user_` and `visitor_` prefixes
+- Basic role-based access (admin/visitor)
+- No session management or token expiration
+
+### **Recommended Improvements:**
+
+#### **A. JWT Implementation**
+```javascript
+// Enhanced JWT with proper expiration and refresh tokens
+const jwt = require('jsonwebtoken');
+const refreshTokens = new Set();
+
+const generateTokens = (user) => {
+  const accessToken = jwt.sign(
+    { userId: user._id, role: user.role },
+    process.env.JWT_SECRET,
+    { expiresIn: '15m' }
+  );
+  
+  const refreshToken = jwt.sign(
+    { userId: user._id },
+    process.env.JWT_REFRESH_SECRET,
+    { expiresIn: '7d' }
+  );
+  
+  refreshTokens.add(refreshToken);
+  return { accessToken, refreshToken };
+};
+```
+
+#### **B. Role-Based Access Control (RBAC)**
+```javascript
+// Enhanced middleware with granular permissions
+const requireRole = (roles) => {
+  return (req, res, next) => {
+    if (!req.user || !roles.includes(req.user.role)) {
+      return res.status(403).json({
+        success: false,
+        message: 'Insufficient permissions'
+      });
+    }
+    next();
+  };
+};
+
+// Usage: requireRole(['admin', 'moderator'])
+```
+
+#### **C. API Rate Limiting Enhancement**
+```javascript
+// Per-user rate limiting
+const userRateLimit = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: (req) => {
+    if (req.user?.role === 'admin') return 1000;
+    if (req.user?.role === 'moderator') return 500;
+    return 100; // visitors
+  },
+  keyGenerator: (req) => req.user?.id || req.ip,
+  message: 'Too many requests from this user'
+});
+```
+
+### **2. Data Protection & Encryption**
+
+#### **A. Database Encryption**
+```javascript
+// MongoDB Atlas already provides encryption at rest
+// Additional field-level encryption for sensitive data
+const crypto = require('crypto');
+
+const encryptField = (text) => {
+  const cipher = crypto.createCipher('aes-256-cbc', process.env.ENCRYPTION_KEY);
+  let encrypted = cipher.update(text, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+  return encrypted;
+};
+
+const decryptField = (encryptedText) => {
+  const decipher = crypto.createDecipher('aes-256-cbc', process.env.ENCRYPTION_KEY);
+  let decrypted = decipher.update(encryptedText, 'hex', 'utf8');
+  decrypted += decipher.final('utf8');
+  return decrypted;
+};
+```
+
+#### **B. Input Validation & Sanitization**
+```javascript
+// Enhanced input validation
+const Joi = require('joi');
+
+const subtitleSchema = Joi.object({
+  segmentId: Joi.number().integer().min(1).max(100).required(),
+  startTime: Joi.string().pattern(/^\d{2}:\d{2}:\d{2},\d{3}$/).required(),
+  endTime: Joi.string().pattern(/^\d{2}:\d{2}:\d{2},\d{3}$/).required(),
+  englishText: Joi.string().max(500).required(),
+  chineseTranslation: Joi.string().max(500).optional()
+});
+
+const validateSubtitle = (data) => {
+  return subtitleSchema.validate(data);
+};
+```
+
+### **3. Content Protection System**
+
+#### **A. Enhanced Protection with Checksums**
+```javascript
+// Add checksums to detect unauthorized changes
+const crypto = require('crypto');
+
+const generateChecksum = (content) => {
+  return crypto.createHash('sha256').update(content).digest('hex');
+};
+
+// Enhanced Subtitle Schema
+const subtitleSchema = new mongoose.Schema({
+  // ... existing fields ...
+  contentChecksum: { type: String, required: true },
+  lastVerified: { type: Date, default: Date.now },
+  verificationHistory: [{
+    timestamp: Date,
+    checksum: String,
+    verifiedBy: String,
+    status: String
+  }]
+});
+
+// Verification method
+subtitleSchema.methods.verifyIntegrity = function() {
+  const currentChecksum = generateChecksum(this.englishText + this.startTime + this.endTime);
+  return currentChecksum === this.contentChecksum;
+};
+```
+
+#### **B. Watermarking System**
+```javascript
+// Add invisible watermarks to detect unauthorized copying
+const addWatermark = (text, userId) => {
+  const watermark = Buffer.from(userId).toString('base64').slice(0, 8);
+  return text + '\u200B' + watermark; // Zero-width space + watermark
+};
+
+const extractWatermark = (text) => {
+  const parts = text.split('\u200B');
+  return parts.length > 1 ? parts[1] : null;
+};
+```
+
+### **4. API Security**
+
+#### **A. Request Validation**
+```javascript
+// Enhanced request validation middleware
+const validateRequest = (schema) => {
+  return (req, res, next) => {
+    const { error } = schema.validate(req.body);
+    if (error) {
+      return res.status(400).json({
+        success: false,
+        message: 'Invalid request data',
+        details: error.details
+      });
+    }
+    next();
+  };
+};
+```
+
+#### **B. CORS Configuration**
+```javascript
+// Strict CORS configuration
+const corsOptions = {
+  origin: [
+    'https://linguabot-transcreation-frontend.hf.space',
+    'https://linguabot-transcreation-backend.hf.space'
+  ],
+  credentials: true,
+  methods: ['GET', 'POST', 'PUT', 'DELETE'],
+  allowedHeaders: ['Content-Type', 'Authorization', 'user-role'],
+  maxAge: 86400 // 24 hours
+};
+
+app.use(cors(corsOptions));
+```
+
+## **2. Backup & Version Control Strategy**
+
+### **A. Database Backup System**
+
+#### **Automated MongoDB Atlas Backups**
+```javascript
+// Enhanced backup system
+const backupSystem = {
+  // Daily automated backups (MongoDB Atlas handles this)
+  // Manual backup triggers
+  async createManualBackup() {
+    const timestamp = new Date().toISOString();
+    const backupName = `manual-backup-${timestamp}`;
+    
+    // Export all collections
+    const collections = ['subtitles', 'sourcetexts', 'submissions', 'users'];
+    const backupData = {};
+    
+    for (const collection of collections) {
+      const data = await mongoose.connection.db.collection(collection).find({}).toArray();
+      backupData[collection] = data;
+    }
+    
+    // Save to backup storage
+    await this.saveBackup(backupName, backupData);
+    return backupName;
+  },
+  
+  async restoreFromBackup(backupName) {
+    const backupData = await this.loadBackup(backupName);
+    
+    for (const [collection, data] of Object.entries(backupData)) {
+      await mongoose.connection.db.collection(collection).deleteMany({});
+      if (data.length > 0) {
+        await mongoose.connection.db.collection(collection).insertMany(data);
+      }
+    }
+  }
+};
+```
+
+#### **B. Git-Based Version Control for Content**
+
+```javascript
+// Content version control system
+const gitVersionControl = {
+  async commitContentChanges(collection, documentId, changes, userId) {
+    const commitMessage = `Update ${collection} ${documentId} by ${userId}`;
+    const timestamp = new Date().toISOString();
+    
+    // Create git commit for content changes
+    const gitData = {
+      collection,
+      documentId,
+      changes,
+      timestamp,
+      userId,
+      commitHash: await this.createGitCommit(commitMessage, changes)
+    };
+    
+    // Store in version control collection
+    await mongoose.connection.db.collection('versionControl').insertOne(gitData);
+    return gitData;
+  },
+  
+  async getContentHistory(documentId) {
+    return await mongoose.connection.db.collection('versionControl')
+      .find({ documentId })
+      .sort({ timestamp: -1 })
+      .toArray();
+  }
+};
+```
+
+### **C. Frontend State Management**
+
+#### **Redux/Zustand for State Persistence**
+```javascript
+// Enhanced state management with persistence
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+const useAppStore = create(
+  persist(
+    (set, get) => ({
+      // User state
+      user: null,
+      isAuthenticated: false,
+      
+      // Content state
+      subtitles: [],
+      sourceTexts: [],
+      submissions: [],
+      
+      // Protection state
+      protectedContent: new Set(),
+      
+      // Actions
+      setUser: (user) => set({ user, isAuthenticated: !!user }),
+      updateSubtitles: (subtitles) => set({ subtitles }),
+      markProtected: (contentId) => set((state) => ({
+        protectedContent: new Set([...state.protectedContent, contentId])
+      }))
+    }),
+    {
+      name: 'transcreation-sandbox-storage',
+      partialize: (state) => ({
+        user: state.user,
+        isAuthenticated: state.isAuthenticated
+      })
+    }
+  )
+);
+```
+
+## **3. Monitoring & Alerting**
+
+### **A. Security Monitoring**
+```javascript
+// Security event logging
+const securityLogger = {
+  logSecurityEvent(event, details) {
+    const logEntry = {
+      timestamp: new Date(),
+      event,
+      details,
+      ip: req.ip,
+      userAgent: req.get('User-Agent'),
+      userId: req.user?.id
+    };
+    
+    // Log to security collection
+    mongoose.connection.db.collection('securityLogs').insertOne(logEntry);
+    
+    // Alert on suspicious activities
+    if (this.isSuspiciousActivity(event, details)) {
+      this.sendSecurityAlert(logEntry);
+    }
+  },
+  
+  isSuspiciousActivity(event, details) {
+    const suspiciousPatterns = [
+      'multiple_failed_logins',
+      'unauthorized_access_attempt',
+      'data_export_attempt',
+      'bulk_deletion_attempt'
+    ];
+    
+    return suspiciousPatterns.some(pattern => event.includes(pattern));
+  }
+};
+```
+
+### **B. Performance Monitoring**
+```javascript
+// Performance monitoring middleware
+const performanceMonitor = (req, res, next) => {
+  const start = Date.now();
+  
+  res.on('finish', () => {
+    const duration = Date.now() - start;
+    const logEntry = {
+      timestamp: new Date(),
+      method: req.method,
+      path: req.path,
+      statusCode: res.statusCode,
+      duration,
+      userId: req.user?.id
+    };
+    
+    // Log slow requests
+    if (duration > 1000) {
+      console.warn('Slow request detected:', logEntry);
+    }
+    
+    // Store in performance logs
+    mongoose.connection.db.collection('performanceLogs').insertOne(logEntry);
+  });
+  
+  next();
+};
+```
+
+## **4. Implementation Priority**
+
+### **Phase 1 (Immediate - 1-2 weeks)**
+1. ✅ Enhanced rate limiting (already implemented)
+2. ✅ Input validation and sanitization
+3. ✅ Content protection with checksums
+4. ✅ Automated backup verification
+
+### **Phase 2 (Short-term - 2-4 weeks)**
+1. JWT implementation with refresh tokens
+2. Enhanced RBAC system
+3. Security monitoring and alerting
+4. Git-based version control for content
+
+### **Phase 3 (Medium-term - 1-2 months)**
+1. Field-level encryption for sensitive data
+2. Advanced watermarking system
+3. Comprehensive audit logging
+4. Automated security testing
+
+## **5. Recommended Tools & Services**
+
+### **Security Tools:**
+- **Helmet.js**: Security headers
+- **Joi**: Input validation
+- **Rate-limiter-flexible**: Advanced rate limiting
+- **Winston**: Structured logging
+
+### **Monitoring Tools:**
+- **MongoDB Atlas**: Built-in monitoring
+- **Sentry**: Error tracking
+- **LogRocket**: User session replay
+- **DataDog**: Application performance monitoring
+
+### **Backup Services:**
+- **MongoDB Atlas**: Automated backups
+- **AWS S3**: Additional backup storage
+- **GitHub**: Code and content version control
+
+## **6. Security Checklist**
+
+### **✅ Implemented:**
+- Basic authentication
+- Content protection flags
+- Rate limiting
+- CORS configuration
+
+### **🔄 In Progress:**
+- Enhanced input validation
+- Security monitoring
+
+### **📋 To Implement:**
+- JWT with refresh tokens
+- Field-level encryption
+- Comprehensive audit logging
+- Automated security testing
+- Advanced watermarking
+
+This comprehensive security plan will significantly enhance the protection of your transcreation sandbox while maintaining usability for legitimate users. 

backup-version-control.js

@@ -0,0 +1,364 @@
+const mongoose = require('mongoose');
+const fs = require('fs').promises;
+const path = require('path');
+
+// Atlas MongoDB connection string
+const MONGODB_URI = 'mongodb+srv://nothingyu:wSg3lbO1PkHiRMq9@sandbox.ecysggv.mongodb.net/test?retryWrites=true&w=majority&appName=sandbox';
+
+// Connect to MongoDB Atlas
+const connectDB = async () => {
+  try {
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to MongoDB Atlas');
+  } catch (error) {
+    console.error('❌ MongoDB connection error:', error);
+    process.exit(1);
+  }
+};
+
+// Backup and Version Control System
+const backupVersionControl = {
+  // Create comprehensive backup
+  async createBackup(customBackupName = null) {
+    try {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupName = customBackupName || `comprehensive-backup-${timestamp}`;
+      
+      console.log(`💾 Creating comprehensive backup: ${backupName}`);
+      
+      const collections = ['subtitles', 'sourcetexts', 'submissions', 'users', 'securitylogs'];
+      const backupData = {
+        metadata: {
+          backupName,
+          timestamp: new Date(),
+          collections: collections,
+          totalRecords: 0,
+          version: '1.0',
+          createdBy: 'system'
+        },
+        data: {}
+      };
+      
+      // Export all collections
+      for (const collection of collections) {
+        try {
+          const data = await mongoose.connection.db.collection(collection).find({}).toArray();
+          backupData.data[collection] = data;
+          backupData.metadata.totalRecords += data.length;
+          console.log(`  📦 Exported ${data.length} records from ${collection}`);
+        } catch (error) {
+          console.warn(`  ⚠️ Could not export ${collection}:`, error.message);
+        }
+      }
+      
+      // Save backup to file system
+      const backupDir = path.join(__dirname, 'backups');
+      await fs.mkdir(backupDir, { recursive: true });
+      
+      const backupPath = path.join(backupDir, `${backupName}.json`);
+      await fs.writeFile(backupPath, JSON.stringify(backupData, null, 2));
+      
+      // Create backup record in database
+      const backupRecord = {
+        backupName,
+        timestamp: new Date(),
+        collections: collections,
+        totalRecords: backupData.metadata.totalRecords,
+        filePath: backupPath,
+        status: 'created',
+        createdBy: 'system'
+      };
+      
+      // Save to backup collection
+      const backupCollection = mongoose.connection.db.collection('backups');
+      await backupCollection.insertOne(backupRecord);
+      
+      console.log(`✅ Backup created successfully: ${backupName}`);
+      console.log(`📊 Total records: ${backupData.metadata.totalRecords}`);
+      console.log(`💾 File saved: ${backupPath}`);
+      
+      return backupName;
+      
+    } catch (error) {
+      console.error('❌ Error creating backup:', error);
+      throw error;
+    }
+  },
+  
+  // Restore from backup
+  async restoreFromBackup(backupName) {
+    try {
+      console.log(`🔄 Restoring from backup: ${backupName}`);
+      
+      // Load backup file
+      const backupPath = path.join(__dirname, 'backups', `${backupName}.json`);
+      const backupData = JSON.parse(await fs.readFile(backupPath, 'utf8'));
+      
+      console.log(`📊 Backup metadata:`, backupData.metadata);
+      
+      // Confirm restoration
+      console.log('⚠️ This will overwrite existing data. Are you sure? (y/N)');
+      // In a real implementation, you'd get user confirmation here
+      
+      // Restore each collection
+      for (const [collection, data] of Object.entries(backupData.data)) {
+        try {
+          // Clear existing data
+          await mongoose.connection.db.collection(collection).deleteMany({});
+          
+          // Insert backup data
+          if (data.length > 0) {
+            await mongoose.connection.db.collection(collection).insertMany(data);
+          }
+          
+          console.log(`  ✅ Restored ${data.length} records to ${collection}`);
+        } catch (error) {
+          console.error(`  ❌ Error restoring ${collection}:`, error.message);
+        }
+      }
+      
+      console.log(`✅ Restoration completed: ${backupName}`);
+      
+    } catch (error) {
+      console.error('❌ Error restoring from backup:', error);
+      throw error;
+    }
+  },
+  
+  // List available backups
+  async listBackups() {
+    try {
+      console.log('📋 Available backups:');
+      
+      // List from database
+      const backupCollection = mongoose.connection.db.collection('backups');
+      const dbBackups = await backupCollection.find({}).sort({ timestamp: -1 }).toArray();
+      
+      if (dbBackups.length === 0) {
+        console.log('  No backups found in database');
+      } else {
+        console.log('  Database backups:');
+        dbBackups.forEach(backup => {
+          console.log(`    📦 ${backup.backupName} (${backup.totalRecords} records, ${new Date(backup.timestamp).toLocaleString()})`);
+        });
+      }
+      
+      // List from file system
+      const backupDir = path.join(__dirname, 'backups');
+      try {
+        const files = await fs.readdir(backupDir);
+        const backupFiles = files.filter(file => file.endsWith('.json'));
+        
+        if (backupFiles.length > 0) {
+          console.log('  File system backups:');
+          for (const file of backupFiles) {
+            const filePath = path.join(backupDir, file);
+            const stats = await fs.stat(filePath);
+            console.log(`    💾 ${file} (${(stats.size / 1024).toFixed(2)} KB, ${stats.mtime.toLocaleString()})`);
+          }
+        }
+      } catch (error) {
+        console.log('  No backup directory found');
+      }
+      
+    } catch (error) {
+      console.error('❌ Error listing backups:', error);
+    }
+  },
+  
+  // Version control for content changes
+  async createVersionControl() {
+    try {
+      console.log('📝 Creating version control system...');
+      
+      const versionControlSchema = new mongoose.Schema({
+        documentId: { type: String, required: true },
+        collection: { type: String, required: true },
+        version: { type: Number, required: true },
+        changes: mongoose.Schema.Types.Mixed,
+        timestamp: { type: Date, default: Date.now },
+        userId: String,
+        commitMessage: String,
+        previousVersion: Number,
+        checksum: String
+      });
+      
+      const VersionControl = mongoose.model('VersionControl', versionControlSchema);
+      
+      // Create indexes for efficient querying
+      await VersionControl.createIndexes();
+      
+      console.log('✅ Version control system created');
+      
+      return VersionControl;
+      
+    } catch (error) {
+      console.error('❌ Error creating version control:', error);
+    }
+  },
+  
+  // Track content changes
+  async trackChange(collection, documentId, changes, userId, commitMessage) {
+    try {
+      const VersionControl = mongoose.model('VersionControl');
+      
+      // Get current version
+      const latestVersion = await VersionControl.findOne({
+        documentId,
+        collection
+      }).sort({ version: -1 });
+      
+      const newVersion = (latestVersion?.version || 0) + 1;
+      
+      // Create version record
+      await VersionControl.create({
+        documentId,
+        collection,
+        version: newVersion,
+        changes,
+        userId,
+        commitMessage,
+        previousVersion: latestVersion?.version || null,
+        timestamp: new Date()
+      });
+      
+      console.log(`📝 Version ${newVersion} created for ${collection}/${documentId}`);
+      
+    } catch (error) {
+      console.error('❌ Error tracking change:', error);
+    }
+  },
+  
+  // Get content history
+  async getContentHistory(collection, documentId) {
+    try {
+      const VersionControl = mongoose.model('VersionControl');
+      
+      const history = await VersionControl.find({
+        documentId,
+        collection
+      }).sort({ version: -1 });
+      
+      console.log(`📋 Version history for ${collection}/${documentId}:`);
+      history.forEach(version => {
+        console.log(`  v${version.version} (${new Date(version.timestamp).toLocaleString()}) - ${version.commitMessage}`);
+      });
+      
+      return history;
+      
+    } catch (error) {
+      console.error('❌ Error getting content history:', error);
+    }
+  },
+  
+  // Automated backup scheduling
+  async scheduleBackups() {
+    try {
+      console.log('⏰ Setting up automated backup scheduling...');
+      
+      const scheduleSchema = new mongoose.Schema({
+        scheduleType: { type: String, enum: ['daily', 'weekly', 'monthly'], required: true },
+        lastBackup: Date,
+        nextBackup: Date,
+        isActive: { type: Boolean, default: true },
+        createdBy: String
+      });
+      
+      const Schedule = mongoose.model('Schedule', scheduleSchema);
+      
+      // Create default daily backup schedule
+      await Schedule.create({
+        scheduleType: 'daily',
+        lastBackup: null,
+        nextBackup: new Date(Date.now() + 24 * 60 * 60 * 1000), // Tomorrow
+        isActive: true,
+        createdBy: 'system'
+      });
+      
+      console.log('✅ Automated backup schedule created (daily)');
+      
+    } catch (error) {
+      console.error('❌ Error setting up backup scheduling:', error);
+    }
+  },
+  
+  // Verify backup integrity
+  async verifyBackupIntegrity(backupName) {
+    try {
+      console.log(`🔍 Verifying backup integrity: ${backupName}`);
+      
+      const backupPath = path.join(__dirname, 'backups', `${backupName}.json`);
+      const backupData = JSON.parse(await fs.readFile(backupPath, 'utf8'));
+      
+      let verifiedCount = 0;
+      let failedCount = 0;
+      
+      // Verify each collection
+      for (const [collection, data] of Object.entries(backupData.data)) {
+        try {
+          const currentCount = await mongoose.connection.db.collection(collection).countDocuments();
+          const backupCount = data.length;
+          
+          if (currentCount === backupCount) {
+            verifiedCount++;
+            console.log(`  ✅ ${collection}: ${backupCount} records verified`);
+          } else {
+            failedCount++;
+            console.log(`  ❌ ${collection}: ${backupCount} in backup, ${currentCount} in database`);
+          }
+        } catch (error) {
+          failedCount++;
+          console.log(`  ❌ ${collection}: verification failed`);
+        }
+      }
+      
+      console.log(`🔍 Integrity verification complete:`);
+      console.log(`  - Verified: ${verifiedCount} collections`);
+      console.log(`  - Failed: ${failedCount} collections`);
+      
+      return { verifiedCount, failedCount };
+      
+    } catch (error) {
+      console.error('❌ Error verifying backup integrity:', error);
+    }
+  }
+};
+
+// Main function
+const main = async () => {
+  try {
+    console.log('🚀 Starting backup and version control system...');
+    
+    // Create comprehensive backup
+    const backupName = await backupVersionControl.createBackup();
+    
+    // Create version control system
+    await backupVersionControl.createVersionControl();
+    
+    // Set up automated backups
+    await backupVersionControl.scheduleBackups();
+    
+    // List available backups
+    await backupVersionControl.listBackups();
+    
+    console.log('\n🎉 Backup and version control system ready!');
+    console.log('\n📋 Available functions:');
+    console.log('  - createBackup(): Create new backup');
+    console.log('  - restoreFromBackup(name): Restore from backup');
+    console.log('  - listBackups(): List available backups');
+    console.log('  - trackChange(): Track content changes');
+    console.log('  - getContentHistory(): Get version history');
+    console.log('  - verifyBackupIntegrity(): Verify backup integrity');
+    
+  } catch (error) {
+    console.error('❌ Error in backup and version control system:', error);
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+};
+
+// Run the system
+connectDB().then(() => {
+  main();
+}); 

backups/complete-backup-2025-08-10T07-59-20-407Z/code/backend/index.js

@@ -0,0 +1,252 @@
+const express = require('express');
+const cors = require('cors');
+const mongoose = require('mongoose');
+const dotenv = require('dotenv');
+const rateLimit = require('express-rate-limit');
+
+// Import routes
+const { router: authRoutes } = require('./routes/auth');
+const sourceTextRoutes = require('./routes/sourceTexts');
+const submissionRoutes = require('./routes/submissions');
+const searchRoutes = require('./routes/search');
+const subtitleRoutes = require('./routes/subtitles');
+const subtitleSubmissionRoutes = require('./routes/subtitleSubmissions');
+
+dotenv.config();
+
+// Global error handlers to prevent crashes
+process.on('uncaughtException', (error) => {
+  console.error('Uncaught Exception:', error);
+  // Don't exit immediately, try to log and continue
+  console.error('Stack trace:', error.stack);
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  // Don't exit immediately, try to log and continue
+  console.error('Stack trace:', reason?.stack);
+});
+
+// Memory leak prevention
+process.on('warning', (warning) => {
+  console.warn('Node.js warning:', warning.name, warning.message);
+});
+
+const app = express();
+const PORT = process.env.PORT || 5000;
+
+// Trust proxy for rate limiting
+app.set('trust proxy', 1);
+
+// Rate limiting - Increased limits to prevent 429 errors
+const limiter = rateLimit({
+  windowMs: 15 * 60 * 1000, // 15 minutes
+  max: 1000, // Increased from 100 to 1000 requests per windowMs
+  message: { error: 'Too many requests, please try again later.' },
+  standardHeaders: true,
+  legacyHeaders: false,
+  skip: (req) => {
+    // Skip rate limiting for health checks
+    return req.path === '/health' || req.path === '/api/health';
+  }
+});
+
+// Middleware
+app.use(cors());
+app.use(express.json({ limit: '10mb' }));
+app.use(limiter);
+
+// Database connection with better error handling
+mongoose.connect(process.env.MONGODB_URI || 'mongodb://localhost:27017/transcreation-sandbox', {
+  maxPoolSize: 10,
+  serverSelectionTimeoutMS: 5000,
+  socketTimeoutMS: 45000,
+})
+.then(() => {
+  console.log('Connected to MongoDB');
+})
+.catch(err => {
+  console.error('MongoDB connection error:', err);
+  // Don't exit immediately, try to reconnect
+  setTimeout(() => {
+    console.log('Attempting to reconnect to MongoDB...');
+    mongoose.connect(process.env.MONGODB_URI || 'mongodb://localhost:27017/transcreation-sandbox');
+  }, 5000);
+});
+
+// Handle MongoDB connection errors
+mongoose.connection.on('error', (err) => {
+  console.error('MongoDB connection error:', err);
+});
+
+mongoose.connection.on('disconnected', () => {
+  console.log('MongoDB disconnected');
+});
+
+// Routes
+app.use('/api/auth', authRoutes);
+app.use('/api/source-texts', sourceTextRoutes);
+app.use('/api/submissions', submissionRoutes);
+app.use('/api/search', searchRoutes);
+app.use('/api/subtitles', subtitleRoutes);
+app.use('/api/subtitle-submissions', subtitleSubmissionRoutes);
+
+// Health check endpoint
+app.get('/api/health', (req, res) => {
+  res.json({ status: 'OK', message: 'Transcreation Sandbox API is running - Auth middleware fixed for time code editing' });
+});
+
+// Simple health check for Hugging Face Spaces
+app.get('/health', (req, res) => {
+  res.status(200).send('OK');
+});
+
+// Error handling middleware
+app.use((err, req, res, next) => {
+  console.error(err.stack);
+  res.status(500).json({ error: 'Something went wrong!' });
+});
+
+app.listen(PORT, () => {
+  console.log(`Server running on port ${PORT}`);
+  
+  // Initialize week 1 tutorial tasks and weekly practice by default
+  const initializeWeek1 = async () => {
+    try {
+      const SourceText = require('./models/SourceText');
+      
+      // Check if week 1 tutorial tasks exist
+      const existingTutorialTasks = await SourceText.find({ 
+        category: 'tutorial', 
+        weekNumber: 1 
+      });
+      
+      if (existingTutorialTasks.length === 0) {
+        console.log('Initializing week 1 tutorial tasks...');
+        const tutorialTasks = [
+          {
+            title: 'Tutorial Task 1 - Introduction',
+            content: '欢迎来到我们的翻译课程。今天我们将学习如何翻译产品介绍。',
+            category: 'tutorial',
+            weekNumber: 1,
+            sourceLanguage: 'Chinese',
+            sourceCulture: 'Chinese',
+            translationBrief: 'You have been asked to translate the following for marketing the product in a country where your LOTE is spoken.'
+          },
+          {
+            title: 'Tutorial Task 2 - Development',
+            content: '这个产品具有独特的设计理念，融合了传统与现代元素。',
+            category: 'tutorial',
+            weekNumber: 1,
+            sourceLanguage: 'Chinese',
+            sourceCulture: 'Chinese',
+            translationBrief: 'You have been asked to translate the following for marketing the product in a country where your LOTE is spoken.'
+          },
+          {
+            title: 'Tutorial Task 3 - Conclusion',
+            content: '我们相信这个产品能够满足您的所有需求，为您提供最佳体验。',
+            category: 'tutorial',
+            weekNumber: 1,
+            sourceLanguage: 'Chinese',
+            sourceCulture: 'Chinese',
+            translationBrief: 'You have been asked to translate the following for marketing the product in a country where your LOTE is spoken.'
+          }
+        ];
+        await SourceText.insertMany(tutorialTasks);
+        console.log('Week 1 tutorial tasks initialized successfully');
+      }
+      
+      // Check if week 1 weekly practice exists
+      const existingWeeklyPractice = await SourceText.find({ 
+        category: 'weekly-practice', 
+        weekNumber: 1 
+      });
+      
+      if (existingWeeklyPractice.length === 0) {
+        console.log('Initializing week 1 weekly practice...');
+        const weeklyPractice = [
+          {
+            title: 'Chinese Pun 1',
+            content: '为什么睡前一定要吃夜宵？因为这样才不会做饿梦。',
+            category: 'weekly-practice',
+            weekNumber: 1,
+            sourceLanguage: 'Chinese',
+            sourceCulture: 'Chinese'
+          },
+          {
+            title: 'Chinese Pun 2',
+            content: '女娲用什么补天？强扭的瓜。',
+            category: 'weekly-practice',
+            weekNumber: 1,
+            sourceLanguage: 'Chinese',
+            sourceCulture: 'Chinese'
+          },
+          {
+            title: 'Chinese Pun 3',
+            content: '你知道如何区分真假大象吗？把他们仍进水中，真相会浮出水面的。',
+            category: 'weekly-practice',
+            weekNumber: 1,
+            sourceLanguage: 'Chinese',
+            sourceCulture: 'Chinese'
+          },
+          {
+            title: 'English Pun 1',
+            content: 'What if Soy milk is just regular milk introducing itself in Spanish.',
+            category: 'weekly-practice',
+            weekNumber: 1,
+            sourceLanguage: 'English',
+            sourceCulture: 'Western'
+          },
+          {
+            title: 'English Pun 2',
+            content: 'I can\'t believe I got fired from the calendar factory. All I did was take a day off.',
+            category: 'weekly-practice',
+            weekNumber: 1,
+            sourceLanguage: 'English',
+            sourceCulture: 'Western'
+          },
+          {
+            title: 'English Pun 3',
+            content: 'When life gives you melons, you might be dyslexic.',
+            category: 'weekly-practice',
+            weekNumber: 1,
+            sourceLanguage: 'English',
+            sourceCulture: 'Western'
+          }
+        ];
+        await SourceText.insertMany(weeklyPractice);
+        console.log('Week 1 weekly practice initialized successfully');
+      }
+    } catch (error) {
+      console.error('Error initializing week 1 data:', error);
+    }
+  };
+  
+  // Auto-initialization disabled to prevent overwriting definitive data
+  // initializeWeek1();
+});
+
+// Graceful shutdown
+process.on('SIGTERM', async () => {
+  console.log('SIGTERM received, shutting down gracefully');
+  try {
+    await mongoose.connection.close();
+    console.log('MongoDB connection closed');
+    process.exit(0);
+  } catch (error) {
+    console.error('Error closing MongoDB connection:', error);
+    process.exit(1);
+  }
+});
+
+process.on('SIGINT', async () => {
+  console.log('SIGINT received, shutting down gracefully');
+  try {
+    await mongoose.connection.close();
+    console.log('MongoDB connection closed');
+    process.exit(0);
+  } catch (error) {
+    console.error('Error closing MongoDB connection:', error);
+    process.exit(1);
+  }
+}); 

backups/complete-backup-2025-08-10T07-59-20-407Z/code/backend/models/SourceText.js

@@ -0,0 +1,75 @@
+const mongoose = require('mongoose');
+
+const culturalElementSchema = new mongoose.Schema({
+  element: { type: String, required: true },
+  description: { type: String, required: true },
+  significance: { type: String, required: true }
+});
+
+const sourceTextSchema = new mongoose.Schema({
+  title: { type: String, required: true },
+  content: { type: String, required: true },
+  sourceLanguage: { type: String, required: true },
+
+  sourceType: { 
+    type: String, 
+    enum: ['api', 'manual', 'practice', 'tutorial', 'weekly-practice'], 
+    default: 'manual' 
+  },
+  category: {
+    type: String,
+    enum: ['practice', 'tutorial', 'weekly-practice'],
+    required: true
+  },
+  weekNumber: {
+    type: Number,
+    required: function() { return this.category !== 'practice'; }
+  },
+  translationBrief: { type: String },
+  imageUrl: { type: String },
+  imageAlt: { type: String },
+  // Image-only configuration
+  imageSize: { type: Number, default: 200 },
+  imageAlignment: { type: String, enum: ['left', 'center', 'right'], default: 'center' },
+  culturalElements: [culturalElementSchema],
+  difficulty: { 
+    type: String, 
+    enum: ['beginner', 'intermediate', 'advanced'], 
+    default: 'intermediate' 
+  },
+  tags: [String],
+  targetCultures: [String],
+  isActive: { type: Boolean, default: true },
+  usageCount: { type: Number, default: 0 },
+  averageRating: { type: Number, default: 0 },
+  ratingCount: { type: Number, default: 0 },
+  
+  // Video subtitling specific fields
+  interfaceType: { type: String, enum: ['standard', 'video-subtitling'] },
+  videoSource: { type: String },
+  totalSegments: { type: Number },
+  segmentId: { type: Number },
+  startTime: { type: String },
+  endTime: { type: String },
+  duration: { type: String },
+  isCurrent: { type: Boolean, default: false },
+  parentTask: { type: String },
+  
+  // Configuration fields
+  configType: { type: String },
+  description: { type: String },
+  
+  // Protection fields
+  isProtected: { type: Boolean, default: false },
+  protectedReason: { type: String },
+  lastModified: { type: Date, default: Date.now },
+  modificationHistory: [{
+    action: { type: String, required: true },
+    timestamp: { type: Date, default: Date.now },
+    reason: { type: String }
+  }]
+}, {
+  timestamps: true
+});
+
+module.exports = mongoose.model('SourceText', sourceTextSchema); 

backups/complete-backup-2025-08-10T07-59-20-407Z/code/backend/models/Subtitle.js

@@ -0,0 +1,168 @@
+const mongoose = require('mongoose');
+
+const subtitleSchema = new mongoose.Schema({
+  segmentId: {
+    type: Number,
+    required: true,
+    unique: true
+  },
+  startTime: {
+    type: String,
+    required: true,
+    validate: {
+      validator: function(v) {
+        // Validate time format: HH:MM:SS,mmm
+        return /^\d{2}:\d{2}:\d{2},\d{3}$/.test(v);
+      },
+      message: 'Start time must be in format HH:MM:SS,mmm'
+    }
+  },
+  endTime: {
+    type: String,
+    required: true,
+    validate: {
+      validator: function(v) {
+        // Validate time format: HH:MM:SS,mmm
+        return /^\d{2}:\d{2}:\d{2},\d{3}$/.test(v);
+      },
+      message: 'End time must be in format HH:MM:SS,mmm'
+    }
+  },
+  duration: {
+    type: String,
+    required: true
+  },
+  englishText: {
+    type: String,
+    required: true,
+    trim: true
+  },
+  chineseTranslation: {
+    type: String,
+    default: '',
+    trim: true
+  },
+  isProtected: {
+    type: Boolean,
+    default: false
+  },
+  protectedReason: {
+    type: String
+  },
+  lastModified: {
+    type: Date,
+    default: Date.now
+  },
+  modificationHistory: [{
+    action: {
+      type: String,
+      required: true
+    },
+    timestamp: {
+      type: Date,
+      default: Date.now
+    },
+    reason: {
+      type: String
+    }
+  }]
+}, {
+  timestamps: true
+});
+
+// Index for efficient queries
+subtitleSchema.index({ segmentId: 1 });
+subtitleSchema.index({ startTime: 1 });
+subtitleSchema.index({ isProtected: 1 });
+
+// Virtual for calculating duration in seconds
+subtitleSchema.virtual('durationInSeconds').get(function() {
+  const start = this.parseTimeToSeconds(this.startTime);
+  const end = this.parseTimeToSeconds(this.endTime);
+  return end - start;
+});
+
+// Method to parse time string to seconds
+subtitleSchema.methods.parseTimeToSeconds = function(timeString) {
+  const parts = timeString.split(':');
+  const seconds = parseInt(parts[2].split(',')[0]);
+  const minutes = parseInt(parts[1]);
+  const hours = parseInt(parts[0]);
+  return hours * 3600 + minutes * 60 + seconds;
+};
+
+// Static method to get all subtitles ordered by segment ID
+subtitleSchema.statics.getAllOrdered = function() {
+  return this.find().sort({ segmentId: 1 });
+};
+
+// Static method to get protected subtitles
+subtitleSchema.statics.getProtected = function() {
+  return this.find({ isProtected: true });
+};
+
+// Static method to update subtitle safely
+subtitleSchema.statics.safeUpdate = function(segmentId, updateData) {
+  return this.findOneAndUpdate(
+    { segmentId: segmentId },
+    { 
+      ...updateData,
+      lastModified: new Date(),
+      $push: {
+        modificationHistory: {
+          action: 'update',
+          timestamp: new Date(),
+          reason: updateData.reason || 'Manual update'
+        }
+      }
+    },
+    { new: true, runValidators: true }
+  );
+};
+
+// Static method to protect subtitle
+subtitleSchema.statics.protectSubtitle = function(segmentId, reason) {
+  return this.findOneAndUpdate(
+    { segmentId: segmentId },
+    { 
+      isProtected: true,
+      protectedReason: reason,
+      lastModified: new Date(),
+      $push: {
+        modificationHistory: {
+          action: 'protect',
+          timestamp: new Date(),
+          reason: reason
+        }
+      }
+    },
+    { new: true }
+  );
+};
+
+// Static method to unlock subtitle
+subtitleSchema.statics.unlockSubtitle = function(segmentId, unlockKey) {
+  // In a real implementation, you'd verify the unlock key
+  if (unlockKey !== 'ADMIN_UNLOCK_KEY_2024') {
+    throw new Error('Invalid unlock key');
+  }
+  
+  return this.findOneAndUpdate(
+    { segmentId: segmentId },
+    { 
+      isProtected: false,
+      protectedReason: null,
+      lastModified: new Date(),
+      $push: {
+        modificationHistory: {
+          action: 'unlock',
+          timestamp: new Date(),
+          reason: 'Admin unlock'
+        }
+      }
+    },
+    { new: true }
+  );
+};
+
+module.exports = mongoose.model('Subtitle', subtitleSchema); 

backups/complete-backup-2025-08-10T07-59-20-407Z/code/backend/models/SubtitleSubmission.js

@@ -0,0 +1,102 @@
+const mongoose = require('mongoose');
+
+const subtitleSubmissionSchema = new mongoose.Schema({
+  userId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true
+  },
+  username: {
+    type: String,
+    required: true,
+    trim: true
+  },
+  segmentId: {
+    type: Number,
+    required: true,
+    min: 1,
+    max: 100
+  },
+  chineseTranslation: {
+    type: String,
+    required: true,
+    trim: true,
+    maxlength: 500
+  },
+  submissionDate: {
+    type: Date,
+    default: Date.now
+  },
+  isAnonymous: {
+    type: Boolean,
+    default: false
+  },
+  weekNumber: {
+    type: Number,
+    required: true,
+    default: 2 // Week 2 for Nike video
+  },
+  // For future features
+  status: {
+    type: String,
+    enum: ['submitted', 'reviewed', 'approved'],
+    default: 'submitted'
+  },
+  notes: {
+    type: String,
+    trim: true,
+    maxlength: 1000
+  }
+}, {
+  timestamps: true
+});
+
+// Indexes for efficient queries
+subtitleSubmissionSchema.index({ segmentId: 1, weekNumber: 1 });
+subtitleSubmissionSchema.index({ userId: 1, weekNumber: 1 });
+subtitleSubmissionSchema.index({ submissionDate: -1 });
+
+// Virtual for display name (anonymous or username)
+subtitleSubmissionSchema.virtual('displayName').get(function() {
+  return this.isAnonymous ? 'Anonymous' : this.username;
+});
+
+// Static method to get submissions for a specific segment
+subtitleSubmissionSchema.statics.getSubmissionsForSegment = function(segmentId, weekNumber = 2) {
+  return this.find({ segmentId, weekNumber })
+    .sort({ submissionDate: -1 })
+    .select('username chineseTranslation submissionDate isAnonymous status notes');
+};
+
+// Static method to get user's submissions for a week
+subtitleSubmissionSchema.statics.getUserSubmissions = function(userId, weekNumber = 2) {
+  return this.find({ userId, weekNumber })
+    .sort({ segmentId: 1, submissionDate: -1 });
+};
+
+// Static method to get submission count for a segment
+subtitleSubmissionSchema.statics.getSubmissionCount = function(segmentId, weekNumber = 2) {
+  return this.countDocuments({ segmentId, weekNumber });
+};
+
+// Method to check if user has already submitted for this segment
+subtitleSubmissionSchema.statics.hasUserSubmitted = function(userId, segmentId, weekNumber = 2) {
+  return this.exists({ userId, segmentId, weekNumber });
+};
+
+// Method to update existing submission
+subtitleSubmissionSchema.statics.updateSubmission = function(userId, segmentId, chineseTranslation, weekNumber = 2) {
+  return this.findOneAndUpdate(
+    { userId, segmentId, weekNumber },
+    { 
+      chineseTranslation,
+      submissionDate: new Date(),
+      isAnonymous: false // Reset to false on update
+    },
+    { new: true, upsert: true }
+  );
+};
+
+const SubtitleSubmission = mongoose.model('SubtitleSubmission', subtitleSubmissionSchema);
+
+module.exports = SubtitleSubmission; 

backups/complete-backup-2025-08-10T07-59-20-407Z/code/backend/routes/auth.js

@@ -0,0 +1,354 @@
+
+const express = require('express');
+const router = express.Router();
+
+// Pre-defined users
+const PREDEFINED_USERS = {
+  'mche0278@student.monash.edu': { name: 'Michelle Chen', email: 'mche0278@student.monash.edu', role: 'student' },
+  'zfan0011@student.monash.edu': { name: 'Fang Zhou', email: 'zfan0011@student.monash.edu', role: 'student' },
+  'yfuu0071@student.monash.edu': { name: 'Fu Yitong', email: 'yfuu0071@student.monash.edu', role: 'student' },
+  'hhan0022@student.monash.edu': { name: 'Han Heyang', email: 'hhan0022@student.monash.edu', role: 'student' },
+  'ylei0024@student.monash.edu': { name: 'Lei Yang', email: 'ylei0024@student.monash.edu', role: 'student' },
+  'wlii0217@student.monash.edu': { name: 'Li Wenhui', email: 'wlii0217@student.monash.edu', role: 'student' },
+  'zlia0091@student.monash.edu': { name: 'Liao Zhixin', email: 'zlia0091@student.monash.edu', role: 'student' },
+  'hmaa0054@student.monash.edu': { name: 'Ma Huachen', email: 'hmaa0054@student.monash.edu', role: 'student' },
+  'csun0059@student.monash.edu': { name: 'Sun Chongkai', email: 'csun0059@student.monash.edu', role: 'student' },
+  'pwon0030@student.monash.edu': { name: 'Wong Prisca Si-Heng', email: 'pwon0030@student.monash.edu', role: 'student' },
+  'zxia0017@student.monash.edu': { name: 'Xia Zechen', email: 'zxia0017@student.monash.edu', role: 'student' },
+  'lyou0021@student.monash.edu': { name: 'You Lianxiang', email: 'lyou0021@student.monash.edu', role: 'student' },
+  'wzhe0034@student.monash.edu': { name: 'Zheng Weijie', email: 'wzhe0034@student.monash.edu', role: 'student' },
+  'szhe0055@student.monash.edu': { name: 'Zheng Siyuan', email: 'szhe0055@student.monash.edu', role: 'student' },
+  'xzhe0055@student.monash.edu': { name: 'Zheng Xiang', email: 'xzhe0055@student.monash.edu', role: 'student' },
+  'hongchang.yu@monash.edu': { name: 'Tristan', email: 'hongchang.yu@monash.edu', role: 'admin' }
+};
+
+// Middleware to verify token (simplified)
+const authenticateToken = (req, res, next) => {
+  const authHeader = req.headers['authorization'];
+  const token = authHeader && authHeader.split(' ')[1];
+
+  if (!token) {
+    return res.status(401).json({ error: 'Access token required' });
+  }
+
+  // For our simplified system, just check if token exists and has the right format
+  if (token.startsWith('user_') || token.startsWith('visitor_')) {
+    req.user = { token };
+    next();
+  } else {
+    return res.status(403).json({ error: 'Invalid token' });
+  }
+};
+
+// Middleware to check if user is admin
+const requireAdmin = (req, res, next) => {
+  const userRole = req.headers['user-role'] || req.body.role;
+  if (userRole !== 'admin') {
+    return res.status(403).json({ error: 'Admin access required' });
+  }
+  next();
+};
+
+// Login endpoint (simplified)
+router.post('/login', async (req, res) => {
+  try {
+    const { email } = req.body;
+    const user = PREDEFINED_USERS[email];
+    if (user) {
+      const token = `user_${Date.now()}`;
+      res.json({ success: true, token, user: { name: user.name, email: user.email, role: user.role } });
+    } else {
+      const visitorUser = { name: 'Visitor', email, role: 'visitor' };
+      const token = `visitor_${Date.now()}`;
+      res.json({ success: true, token, user: visitorUser });
+    }
+  } catch (error) {
+    console.error('Login error:', error);
+    res.status(500).json({ error: 'Login failed' });
+  }
+});
+
+// Get user profile
+router.get('/profile', authenticateToken, async (req, res) => {
+  try {
+    res.json({ success: true, user: { name: 'User', email: 'user@example.com', role: 'student' } });
+  } catch (error) {
+    console.error('Profile error:', error);
+    res.status(500).json({ error: 'Failed to get profile' });
+  }
+});
+
+// Admin endpoints
+router.get('/admin/users', authenticateToken, async (req, res) => {
+  try {
+    const users = Object.values(PREDEFINED_USERS);
+    res.json({ success: true, users });
+  } catch (error) {
+    console.error('Get users error:', error);
+    res.status(500).json({ error: 'Failed to get users' });
+  }
+});
+
+router.get('/admin/stats', authenticateToken, async (req, res) => {
+  try {
+    const SourceText = require('../models/SourceText');
+    const Submission = require('../models/Submission');
+    const stats = {
+      totalUsers: Object.keys(PREDEFINED_USERS).length,
+      practiceExamples: await SourceText.countDocuments({ sourceType: 'practice' }),
+      totalSubmissions: await Submission.countDocuments(),
+      activeSessions: 1
+    };
+    res.json({ success: true, stats });
+  } catch (error) {
+    console.error('Get stats error:', error);
+    res.status(500).json({ error: 'Failed to get statistics' });
+  }
+});
+
+// Practice examples
+router.get('/admin/practice-examples', authenticateToken, async (req, res) => {
+  try {
+    const SourceText = require('../models/SourceText');
+    const examples = await SourceText.find({ sourceType: 'practice' }).sort({ createdAt: -1 });
+    res.json({ success: true, examples });
+  } catch (error) {
+    console.error('Get practice examples error:', error);
+    res.status(500).json({ error: 'Failed to get practice examples' });
+  }
+});
+
+router.post('/admin/practice-examples', authenticateToken, async (req, res) => {
+  try {
+    const SourceText = require('../models/SourceText');
+    const { title, content, sourceLanguage, culturalElements, difficulty } = req.body;
+    const newExample = new SourceText({ title, content, sourceLanguage, sourceType: 'practice', culturalElements: culturalElements || [], difficulty: difficulty || 'intermediate' });
+    await newExample.save();
+    res.status(201).json({ success: true, message: 'Practice example added successfully', example: newExample });
+  } catch (error) {
+    console.error('Add practice example error:', error);
+    res.status(500).json({ error: 'Failed to add practice example' });
+  }
+});
+
+router.put('/admin/practice-examples/:id', authenticateToken, async (req, res) => {
+  try {
+    const SourceText = require('../models/SourceText');
+    const { title, content, sourceLanguage, culturalElements, difficulty } = req.body;
+    const updatedExample = await SourceText.findByIdAndUpdate(req.params.id, { title, content, sourceLanguage, culturalElements: culturalElements || [], difficulty: difficulty || 'intermediate' }, { new: true, runValidators: true });
+    if (!updatedExample) return res.status(404).json({ error: 'Practice example not found' });
+    res.json({ success: true, message: 'Practice example updated successfully', example: updatedExample });
+  } catch (error) {
+    console.error('Update practice example error:', error);
+    res.status(500).json({ error: 'Failed to update practice example' });
+  }
+});
+
+router.delete('/admin/practice-examples/:id', authenticateToken, async (req, res) => {
+  try {
+    const SourceText = require('../models/SourceText');
+    const deletedExample = await SourceText.findByIdAndDelete(req.params.id);
+    if (!deletedExample) return res.status(404).json({ error: 'Practice example not found' });
+    res.json({ success: true, message: 'Practice example deleted successfully' });
+  } catch (error) {
+    console.error('Delete practice example error:', error);
+    res.status(500).json({ error: 'Failed to delete practice example' });
+  }
+});
+
+// ===== TUTORIAL TASKS MANAGEMENT =====
+router.get('/admin/tutorial-tasks', authenticateToken, async (req, res) => {
+  try {
+    const SourceText = require('../models/SourceText');
+    const tutorialTasks = await SourceText.find({ category: 'tutorial' }).sort({ weekNumber: 1, createdAt: -1 });
+    res.json({ success: true, tutorialTasks });
+  } catch (error) {
+    console.error('Get tutorial tasks error:', error);
+    res.status(500).json({ error: 'Failed to get tutorial tasks' });
+  }
+});
+
+router.post('/admin/tutorial-tasks', authenticateToken, requireAdmin, async (req, res) => {
+  try {
+    const SourceText = require('../models/SourceText');
+    const { content, weekNumber, category, imageUrl, imageAlt, imageSize, imageAlignment, translationBrief, title } = req.body;
+
+    if (!weekNumber) return res.status(400).json({ error: 'Week number is required' });
+    if (parseInt(weekNumber) >= 3) {
+      if ((!content || content.trim() === '') && !imageUrl) return res.status(400).json({ error: 'Either content or imageUrl is required' });
+    } else {
+      if (!content || content.trim() === '') return res.status(400).json({ error: 'Content is required' });
+    }
+
+    const newTask = new SourceText({
+      content: content || (imageUrl ? 'Image-based task' : ''),
+      weekNumber: parseInt(weekNumber),
+      category: category || 'tutorial',
+      title: title || `Tutorial Task Week ${weekNumber}`,
+      sourceLanguage: 'English',
+      sourceType: 'tutorial',
+      imageUrl,
+      imageAlt,
+      ...(imageUrl && (!content || content.trim() === '') && { imageSize: imageSize || 200 }),
+      ...(imageUrl && (!content || content.trim() === '') && { imageAlignment: imageAlignment || 'center' }),
+      translationBrief
+    });
+
+    const savedTask = await newTask.save();
+    res.status(201).json({ success: true, message: 'Tutorial task created successfully', task: savedTask });
+  } catch (error) {
+    console.error('Create tutorial task error:', error);
+    res.status(500).json({ error: 'Failed to create tutorial task' });
+  }
+});
+
+router.put('/admin/tutorial-tasks/:id', authenticateToken, requireAdmin, async (req, res) => {
+  try {
+    const SourceText = require('../models/SourceText');
+    const { content, translationBrief, weekNumber, imageUrl, imageAlt, imageSize, imageAlignment, title } = req.body;
+    const updateData = { content, translationBrief, weekNumber: parseInt(weekNumber), imageUrl, imageAlt, title };
+    if (imageUrl && (!content || content.trim() === '')) {
+      updateData.imageSize = imageSize;
+      updateData.imageAlignment = imageAlignment;
+    }
+    const updatedTask = await SourceText.findByIdAndUpdate(req.params.id, updateData, { new: true, runValidators: true });
+    if (!updatedTask) return res.status(404).json({ error: 'Tutorial task not found' });
+    res.json({ success: true, message: 'Tutorial task updated successfully', task: updatedTask });
+  } catch (error) {
+    console.error('Update tutorial task error:', error);
+    res.status(500).json({ error: 'Failed to update tutorial task' });
+  }
+});
+
+router.delete('/admin/tutorial-tasks/:id', authenticateToken, requireAdmin, async (req, res) => {
+  try {
+    const SourceText = require('../models/SourceText');
+    const deletedTask = await SourceText.findByIdAndDelete(req.params.id);
+    if (!deletedTask) return res.status(404).json({ error: 'Tutorial task not found' });
+    res.json({ success: true, message: 'Tutorial task deleted successfully' });
+  } catch (error) {
+    console.error('Delete tutorial task error:', error);
+    res.status(500).json({ error: 'Failed to delete tutorial task' });
+  }
+});
+
+// ===== WEEKLY PRACTICE MANAGEMENT =====
+router.get('/admin/weekly-practice', authenticateToken, async (req, res) => {
+  try {
+    const SourceText = require('../models/SourceText');
+    const weeklyPractice = await SourceText.find({ category: 'weekly-practice' }).sort({ weekNumber: 1, createdAt: -1 });
+    res.json({ success: true, weeklyPractice });
+  } catch (error) {
+    console.error('Get weekly practice error:', error);
+    res.status(500).json({ error: 'Failed to get weekly practice' });
+  }
+});
+
+router.post('/admin/weekly-practice', authenticateToken, requireAdmin, async (req, res) => {
+  try {
+    const SourceText = require('../models/SourceText');
+    const { content, weekNumber, category, imageUrl, imageAlt, imageSize, imageAlignment, translationBrief, title } = req.body;
+
+    if (!weekNumber) return res.status(400).json({ error: 'Week number is required' });
+    if (parseInt(weekNumber) >= 3) {
+      if ((!content || content.trim() === '') && !imageUrl) return res.status(400).json({ error: 'Either content or imageUrl is required' });
+    } else {
+      if (!content || content.trim() === '') return res.status(400).json({ error: 'Content is required' });
+    }
+
+    const newPractice = new SourceText({
+      content: content || (imageUrl ? 'Image-based practice' : ''),
+      weekNumber: parseInt(weekNumber),
+      category: category || 'weekly-practice',
+      title: title || `Weekly Practice Week ${weekNumber}`,
+      sourceLanguage: 'English',
+      sourceType: 'weekly-practice',
+      imageUrl,
+      imageAlt,
+      ...(imageUrl && (!content || content.trim() === '') && { imageSize: imageSize || 200 }),
+      ...(imageUrl && (!content || content.trim() === '') && { imageAlignment: imageAlignment || 'center' }),
+      translationBrief
+    });
+
+    const savedPractice = await newPractice.save();
+    res.status(201).json({ success: true, message: 'Weekly practice created successfully', practice: savedPractice });
+  } catch (error) {
+    console.error('Create weekly practice error:', error);
+    res.status(500).json({ error: 'Failed to create weekly practice' });
+  }
+});
+
+router.put('/admin/weekly-practice/:id', authenticateToken, requireAdmin, async (req, res) => {
+  try {
+    const SourceText = require('../models/SourceText');
+    const { title, content, sourceLanguage, sourceCulture, weekNumber, difficulty, culturalElements, imageUrl, imageAlt, imageSize, imageAlignment } = req.body;
+    const updateData = { title, content, sourceLanguage, weekNumber: parseInt(weekNumber), difficulty: difficulty || 'intermediate', culturalElements: culturalElements || [], imageUrl, imageAlt };
+    if (imageUrl && (!content || content.trim() === '')) {
+      updateData.imageSize = imageSize;
+      updateData.imageAlignment = imageAlignment;
+    }
+    const updatedPractice = await SourceText.findByIdAndUpdate(req.params.id, updateData, { new: true, runValidators: true });
+    if (!updatedPractice) return res.status(404).json({ error: 'Weekly practice not found' });
+    res.json({ success: true, message: 'Weekly practice updated successfully', weeklyPractice: updatedPractice });
+  } catch (error) {
+    console.error('Update weekly practice error:', error);
+    res.status(500).json({ error: 'Failed to update weekly practice' });
+  }
+});
+
+router.delete('/admin/weekly-practice/:id', authenticateToken, requireAdmin, async (req, res) => {
+  try {
+    const SourceText = require('../models/SourceText');
+    const deletedPractice = await SourceText.findByIdAndDelete(req.params.id);
+    if (!deletedPractice) return res.status(404).json({ error: 'Weekly practice not found' });
+    res.json({ success: true, message: 'Weekly practice deleted successfully' });
+  } catch (error) {
+    console.error('Delete weekly practice error:', error);
+    res.status(500).json({ error: 'Failed to delete weekly practice' });
+  }
+});
+
+// Translation brief helpers
+router.post('/admin/translation-brief', authenticateToken, requireAdmin, async (req, res) => {
+  try {
+    const SourceText = require('../models/SourceText');
+    const { weekNumber, translationBrief, type } = req.body;
+    if (!weekNumber || !translationBrief || !type) return res.status(400).json({ error: 'Week number, translation brief, and type are required' });
+    const result = await SourceText.updateMany({ category: type === 'tutorial' ? 'tutorial' : 'weekly-practice', weekNumber: parseInt(weekNumber) }, { translationBrief });
+    if (result.modifiedCount === 0) return res.status(404).json({ error: 'No tasks found for the specified week and type' });
+    res.json({ success: true, message: `Translation brief added successfully to ${result.modifiedCount} tasks`, modifiedCount: result.modifiedCount });
+  } catch (error) {
+    console.error('Add translation brief error:', error);
+    res.status(500).json({ error: 'Failed to add translation brief' });
+  }
+});
+
+router.put('/admin/tutorial-brief/:weekNumber', authenticateToken, requireAdmin, async (req, res) => {
+  try {
+    const SourceText = require('../models/SourceText');
+    const { translationBrief } = req.body;
+    const weekNumber = parseInt(req.params.weekNumber);
+    if (translationBrief === undefined || translationBrief === null) return res.status(400).json({ error: 'Translation brief is required' });
+    const result = await SourceText.updateMany({ category: 'tutorial', weekNumber }, { translationBrief });
+    res.json({ success: true, message: `Translation brief updated successfully for ${result.modifiedCount} tutorial tasks`, modifiedCount: result.modifiedCount });
+  } catch (error) {
+    console.error('Update tutorial brief error:', error);
+    res.status(500).json({ error: 'Failed to update translation brief' });
+  }
+});
+
+router.put('/admin/weekly-brief/:weekNumber', authenticateToken, requireAdmin, async (req, res) => {
+  try {
+    const SourceText = require('../models/SourceText');
+    const { translationBrief } = req.body;
+    const weekNumber = parseInt(req.params.weekNumber);
+    if (translationBrief === undefined || translationBrief === null) return res.status(400).json({ error: 'Translation brief is required' });
+    const result = await SourceText.updateMany({ category: 'weekly-practice', weekNumber }, { translationBrief });
+    res.json({ success: true, message: `Translation brief updated successfully for ${result.modifiedCount} weekly practice tasks`, modifiedCount: result.modifiedCount });
+  } catch (error) {
+    console.error('Update weekly practice brief error:', error);
+    res.status(500).json({ error: 'Failed to update translation brief' });
+  }
+});
+
+module.exports = { router, authenticateToken };

backups/complete-backup-2025-08-10T07-59-20-407Z/code/backend/routes/subtitleSubmissions.js

@@ -0,0 +1,287 @@
+const express = require('express');
+const router = express.Router();
+const mongoose = require('mongoose');
+const crypto = require('crypto');
+const SubtitleSubmission = require('../models/SubtitleSubmission');
+const auth = require('../middleware/auth');
+
+// GET submissions for a specific segment (public route)
+router.get('/segment/:segmentId', async (req, res) => {
+  try {
+    const segmentId = parseInt(req.params.segmentId);
+    const weekNumber = parseInt(req.query.week) || 2;
+    
+    if (!segmentId || segmentId < 1 || segmentId > 100) {
+      return res.status(400).json({
+        success: false,
+        message: 'Invalid segment ID'
+      });
+    }
+
+    const submissions = await SubtitleSubmission.getSubmissionsForSegment(segmentId, weekNumber);
+    
+    // Format submissions for frontend
+    const formattedSubmissions = submissions.map(submission => ({
+      _id: submission._id,
+      username: submission.username,
+      chineseTranslation: submission.chineseTranslation,
+      submissionDate: submission.submissionDate,
+      isAnonymous: submission.isAnonymous,
+      status: submission.status,
+      notes: submission.notes
+    }));
+
+    res.json({
+      success: true,
+      data: formattedSubmissions,
+      count: formattedSubmissions.length
+    });
+  } catch (error) {
+    console.error('Error fetching subtitle submissions:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Error fetching subtitle submissions',
+      error: error.message
+    });
+  }
+});
+
+// POST new subtitle submission (authenticated users)
+router.post('/submit', auth, async (req, res) => {
+  try {
+    const { segmentId, chineseTranslation, isAnonymous = false, weekNumber = 2, username: requestUsername } = req.body;
+    
+    if (!segmentId || !chineseTranslation) {
+      return res.status(400).json({
+        success: false,
+        message: 'Segment ID and Chinese translation are required'
+      });
+    }
+
+    if (segmentId < 1 || segmentId > 100) {
+      return res.status(400).json({
+        success: false,
+        message: 'Invalid segment ID'
+      });
+    }
+
+    // Get user info from auth middleware
+    const user = req.user?.userInfo || {};
+    // Use username from request body first, then fall back to user info
+    const displayUsername = requestUsername || user.username || 'Unknown User';
+    const userId = user._id || 'unknown';
+    
+    // Generate a valid ObjectId if userId is not a valid ObjectId
+    let validUserId;
+    try {
+      validUserId = mongoose.Types.ObjectId(userId);
+    } catch (error) {
+      // If userId is not a valid ObjectId, create a consistent one based on username
+      const usernameHash = crypto.createHash('md5').update(displayUsername).digest('hex');
+      validUserId = new mongoose.Types.ObjectId(usernameHash.substring(0, 24));
+    }
+
+    // Check if user already submitted for this segment
+    const existingSubmission = await SubtitleSubmission.findOne({
+      userId: validUserId,
+      segmentId,
+      weekNumber
+    });
+
+    let submission;
+    if (existingSubmission) {
+      // Update existing submission
+      existingSubmission.chineseTranslation = chineseTranslation;
+      existingSubmission.isAnonymous = isAnonymous;
+      existingSubmission.submissionDate = new Date();
+      submission = await existingSubmission.save();
+    } else {
+      // Create new submission
+      submission = new SubtitleSubmission({
+        userId: validUserId,
+        username: displayUsername,
+        segmentId,
+        chineseTranslation,
+        isAnonymous,
+        weekNumber
+      });
+      await submission.save();
+    }
+
+    res.status(201).json({
+      success: true,
+      message: existingSubmission ? 'Translation updated' : 'Translation submitted',
+      data: {
+        _id: submission._id,
+        username: submission.isAnonymous ? 'Anonymous' : submission.username,
+        chineseTranslation: submission.chineseTranslation,
+        submissionDate: submission.submissionDate,
+        isAnonymous: submission.isAnonymous
+      }
+    });
+  } catch (error) {
+    console.error('Error submitting subtitle translation:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Error submitting subtitle translation',
+      error: error.message
+    });
+  }
+});
+
+// GET user's submissions for a week (authenticated users)
+router.get('/user/:weekNumber', auth, async (req, res) => {
+  try {
+    const weekNumber = parseInt(req.params.weekNumber) || 2;
+    const user = req.user?.userInfo || {};
+    const userId = user._id || 'unknown';
+
+    const submissions = await SubtitleSubmission.getUserSubmissions(userId, weekNumber);
+    
+    const formattedSubmissions = submissions.map(submission => ({
+      _id: submission._id,
+      segmentId: submission.segmentId,
+      chineseTranslation: submission.chineseTranslation,
+      submissionDate: submission.submissionDate,
+      isAnonymous: submission.isAnonymous,
+      status: submission.status
+    }));
+
+    res.json({
+      success: true,
+      data: formattedSubmissions,
+      count: formattedSubmissions.length
+    });
+  } catch (error) {
+    console.error('Error fetching user submissions:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Error fetching user submissions',
+      error: error.message
+    });
+  }
+});
+
+// GET submission count for a segment (public route)
+router.get('/count/:segmentId', async (req, res) => {
+  try {
+    const segmentId = parseInt(req.params.segmentId);
+    const weekNumber = parseInt(req.query.week) || 2;
+    
+    if (!segmentId || segmentId < 1 || segmentId > 100) {
+      return res.status(400).json({
+        success: false,
+        message: 'Invalid segment ID'
+      });
+    }
+
+    const count = await SubtitleSubmission.getSubmissionCount(segmentId, weekNumber);
+    
+    res.json({
+      success: true,
+      count
+    });
+  } catch (error) {
+    console.error('Error getting submission count:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Error getting submission count',
+      error: error.message
+    });
+  }
+});
+
+// DELETE user's submission (authenticated users)
+router.delete('/:submissionId', auth, async (req, res) => {
+  try {
+    const submissionId = req.params.submissionId;
+    const userInfo = req.user?.userInfo || {};
+    const userId = userInfo._id || 'unknown';
+    const isAdmin = userInfo.role === 'admin';
+
+    const submission = await SubtitleSubmission.findById(submissionId);
+    
+    if (!submission) {
+      return res.status(404).json({
+        success: false,
+        message: 'Submission not found'
+      });
+    }
+
+    // Check if user owns this submission or is admin
+    if (!isAdmin && submission.userId.toString() !== userId) {
+      return res.status(403).json({
+        success: false,
+        message: 'You can only delete your own submissions'
+      });
+    }
+
+    await SubtitleSubmission.findByIdAndDelete(submissionId);
+    
+    res.json({
+      success: true,
+      message: 'Submission deleted successfully'
+    });
+  } catch (error) {
+    console.error('Error deleting submission:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Error deleting submission',
+      error: error.message
+    });
+  }
+});
+
+// PUT update user's submission (authenticated users)
+router.put('/:submissionId', auth, async (req, res) => {
+  try {
+    const submissionId = req.params.submissionId;
+    const { chineseTranslation, isAnonymous } = req.body;
+    const user = JSON.parse(req.headers['user-info'] || '{}');
+    const userId = user._id || 'unknown';
+
+    const submission = await SubtitleSubmission.findById(submissionId);
+    
+    if (!submission) {
+      return res.status(404).json({
+        success: false,
+        message: 'Submission not found'
+      });
+    }
+
+    // Check if user owns this submission
+    if (submission.userId.toString() !== userId) {
+      return res.status(403).json({
+        success: false,
+        message: 'You can only update your own submissions'
+      });
+    }
+
+    submission.chineseTranslation = chineseTranslation;
+    submission.isAnonymous = isAnonymous || false;
+    submission.submissionDate = new Date();
+    
+    const updatedSubmission = await submission.save();
+    
+    res.json({
+      success: true,
+      message: 'Submission updated successfully',
+      data: {
+        _id: updatedSubmission._id,
+        username: updatedSubmission.isAnonymous ? 'Anonymous' : updatedSubmission.username,
+        chineseTranslation: updatedSubmission.chineseTranslation,
+        submissionDate: updatedSubmission.submissionDate,
+        isAnonymous: updatedSubmission.isAnonymous
+      }
+    });
+  } catch (error) {
+    console.error('Error updating submission:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Error updating submission',
+      error: error.message
+    });
+  }
+});
+
+module.exports = router; 

backups/complete-backup-2025-08-10T07-59-20-407Z/code/backend/routes/subtitles.js

@@ -0,0 +1,343 @@
+const express = require('express');
+const router = express.Router();
+const Subtitle = require('../models/Subtitle');
+const auth = require('../middleware/auth');
+
+// GET all subtitles (ordered by segment ID) - Public route
+router.get('/all', async (req, res) => {
+  try {
+    const subtitles = await Subtitle.getAllOrdered();
+    res.json({
+      success: true,
+      count: subtitles.length,
+      data: subtitles
+    });
+  } catch (error) {
+    console.error('Error fetching subtitles:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Error fetching subtitles',
+      error: error.message
+    });
+  }
+});
+
+// GET subtitle by segment ID - Public route
+router.get('/segment/:segmentId', async (req, res) => {
+  try {
+    const segmentId = parseInt(req.params.segmentId);
+    const subtitle = await Subtitle.findOne({ segmentId });
+    
+    if (!subtitle) {
+      return res.status(404).json({
+        success: false,
+        message: 'Subtitle not found'
+      });
+    }
+    
+    res.json({
+      success: true,
+      data: subtitle
+    });
+  } catch (error) {
+    console.error('Error fetching subtitle:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Error fetching subtitle',
+      error: error.message
+    });
+  }
+});
+
+// POST new subtitle (admin only)
+router.post('/create', auth, async (req, res) => {
+  try {
+    // Check if user is admin
+    if (req.user.role !== 'admin') {
+      return res.status(403).json({
+        success: false,
+        message: 'Admin access required'
+      });
+    }
+
+    const subtitle = new Subtitle(req.body);
+    await subtitle.save();
+    
+    res.status(201).json({
+      success: true,
+      message: 'Subtitle created successfully',
+      data: subtitle
+    });
+  } catch (error) {
+    console.error('Error creating subtitle:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Error creating subtitle',
+      error: error.message
+    });
+  }
+});
+
+// PUT update subtitle (admin only)
+router.put('/update/:segmentId', auth, async (req, res) => {
+  try {
+    // Check if user is admin
+    if (req.user.role !== 'admin') {
+      return res.status(403).json({
+        success: false,
+        message: 'Admin access required'
+      });
+    }
+
+    const segmentId = parseInt(req.params.segmentId);
+    const subtitle = await Subtitle.findOne({ segmentId });
+    
+    if (!subtitle) {
+      return res.status(404).json({
+        success: false,
+        message: 'Subtitle not found'
+      });
+    }
+
+    // Check if subtitle is protected
+    if (subtitle.isProtected) {
+      return res.status(403).json({
+        success: false,
+        message: 'Cannot update protected subtitle',
+        reason: subtitle.protectedReason
+      });
+    }
+
+    const updatedSubtitle = await Subtitle.safeUpdate(segmentId, {
+      ...req.body,
+      reason: req.body.reason || 'Manual update'
+    });
+    
+    res.json({
+      success: true,
+      message: 'Subtitle updated successfully',
+      data: updatedSubtitle
+    });
+  } catch (error) {
+    console.error('Error updating subtitle:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Error updating subtitle',
+      error: error.message
+    });
+  }
+});
+
+// PUT update Chinese translation (any authenticated user)
+router.put('/translate/:segmentId', auth, async (req, res) => {
+  try {
+    const segmentId = parseInt(req.params.segmentId);
+    const { chineseTranslation } = req.body;
+    
+    if (!chineseTranslation) {
+      return res.status(400).json({
+        success: false,
+        message: 'Chinese translation is required'
+      });
+    }
+
+    const subtitle = await Subtitle.findOne({ segmentId });
+    
+    if (!subtitle) {
+      return res.status(404).json({
+        success: false,
+        message: 'Subtitle not found'
+      });
+    }
+
+    // Check if subtitle is protected
+    if (subtitle.isProtected) {
+      return res.status(403).json({
+        success: false,
+        message: 'Cannot update protected subtitle',
+        reason: subtitle.protectedReason
+      });
+    }
+
+    const updatedSubtitle = await Subtitle.safeUpdate(segmentId, {
+      chineseTranslation,
+      reason: 'Translation update'
+    });
+    
+    res.json({
+      success: true,
+      message: 'Translation updated successfully',
+      data: updatedSubtitle
+    });
+  } catch (error) {
+    console.error('Error updating translation:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Error updating translation',
+      error: error.message
+    });
+  }
+});
+
+// POST protect subtitle (admin only)
+router.post('/protect/:segmentId', auth, async (req, res) => {
+  try {
+    // Check if user is admin
+    if (req.user.role !== 'admin') {
+      return res.status(403).json({
+        success: false,
+        message: 'Admin access required'
+      });
+    }
+
+    const segmentId = parseInt(req.params.segmentId);
+    const { reason } = req.body;
+    
+    const subtitle = await Subtitle.findOne({ segmentId });
+    
+    if (!subtitle) {
+      return res.status(404).json({
+        success: false,
+        message: 'Subtitle not found'
+      });
+    }
+
+    const protectedSubtitle = await Subtitle.protectSubtitle(segmentId, reason);
+    
+    res.json({
+      success: true,
+      message: 'Subtitle protected successfully',
+      data: protectedSubtitle
+    });
+  } catch (error) {
+    console.error('Error protecting subtitle:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Error protecting subtitle',
+      error: error.message
+    });
+  }
+});
+
+// POST unlock subtitle (admin only)
+router.post('/unlock/:segmentId', auth, async (req, res) => {
+  try {
+    // Check if user is admin
+    if (req.user.role !== 'admin') {
+      return res.status(403).json({
+        success: false,
+        message: 'Admin access required'
+      });
+    }
+
+    const segmentId = parseInt(req.params.segmentId);
+    const { unlockKey } = req.body;
+    
+    if (!unlockKey) {
+      return res.status(400).json({
+        success: false,
+        message: 'Unlock key is required'
+      });
+    }
+
+    const subtitle = await Subtitle.findOne({ segmentId });
+    
+    if (!subtitle) {
+      return res.status(404).json({
+        success: false,
+        message: 'Subtitle not found'
+      });
+    }
+
+    const unlockedSubtitle = await Subtitle.unlockSubtitle(segmentId, unlockKey);
+    
+    res.json({
+      success: true,
+      message: 'Subtitle unlocked successfully',
+      data: unlockedSubtitle
+    });
+  } catch (error) {
+    console.error('Error unlocking subtitle:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Error unlocking subtitle',
+      error: error.message
+    });
+  }
+});
+
+// GET protected subtitles
+router.get('/protected', auth, async (req, res) => {
+  try {
+    // Check if user is admin
+    if (req.user.role !== 'admin') {
+      return res.status(403).json({
+        success: false,
+        message: 'Admin access required'
+      });
+    }
+
+    const protectedSubtitles = await Subtitle.getProtected();
+    
+    res.json({
+      success: true,
+      count: protectedSubtitles.length,
+      data: protectedSubtitles
+    });
+  } catch (error) {
+    console.error('Error fetching protected subtitles:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Error fetching protected subtitles',
+      error: error.message
+    });
+  }
+});
+
+// DELETE subtitle (admin only)
+router.delete('/delete/:segmentId', auth, async (req, res) => {
+  try {
+    // Check if user is admin
+    if (req.user.role !== 'admin') {
+      return res.status(403).json({
+        success: false,
+        message: 'Admin access required'
+      });
+    }
+
+    const segmentId = parseInt(req.params.segmentId);
+    const subtitle = await Subtitle.findOne({ segmentId });
+    
+    if (!subtitle) {
+      return res.status(404).json({
+        success: false,
+        message: 'Subtitle not found'
+      });
+    }
+
+    // Check if subtitle is protected
+    if (subtitle.isProtected) {
+      return res.status(403).json({
+        success: false,
+        message: 'Cannot delete protected subtitle',
+        reason: subtitle.protectedReason
+      });
+    }
+
+    await Subtitle.deleteOne({ segmentId });
+    
+    res.json({
+      success: true,
+      message: 'Subtitle deleted successfully'
+    });
+  } catch (error) {
+    console.error('Error deleting subtitle:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Error deleting subtitle',
+      error: error.message
+    });
+  }
+});
+
+module.exports = router; 

backups/complete-backup-2025-08-10T07-59-20-407Z/code/backend/seed-atlas-subtitles.js

@@ -0,0 +1,87 @@
+const mongoose = require('mongoose');
+const Subtitle = require('./models/Subtitle');
+
+// Atlas MongoDB connection string
+const MONGODB_URI = 'mongodb+srv://nothingyu:wSg3lbO1PkHiRMq9@sandbox.ecysggv.mongodb.net/test?retryWrites=true&w=majority&appName=sandbox';
+
+// Nike video subtitle data
+const subtitleData = [
+  { segmentId: 1, startTime: '00:00:00,640', endTime: '00:00:02,400', duration: '1s 760ms', englishText: 'Am I a bad person?' },
+  { segmentId: 2, startTime: '00:00:06,320', endTime: '00:00:07,860', duration: '1s 540ms', englishText: 'Tell me. Am I?' },
+  { segmentId: 3, startTime: '00:00:08,480', endTime: '00:00:09,740', duration: '1s 260ms', englishText: 'I\'m single minded.' },
+  { segmentId: 4, startTime: '00:00:10,570', endTime: '00:00:11,780', duration: '1s 210ms', englishText: 'I\'m deceptive.' },
+  { segmentId: 5, startTime: '00:00:12,050', endTime: '00:00:13,490', duration: '1s 440ms', englishText: 'I\'m obsessive.' },
+  { segmentId: 6, startTime: '00:00:13,780', endTime: '00:00:14,910', duration: '1s 130ms', englishText: 'I\'m selfish.' },
+  { segmentId: 7, startTime: '00:00:15,120', endTime: '00:00:17,200', duration: '2s 80ms', englishText: 'Does that make me a bad person?' },
+  { segmentId: 8, startTime: '00:00:18,010', endTime: '00:00:19,660', duration: '1s 650ms', englishText: 'Am I a bad person?' },
+  { segmentId: 9, startTime: '00:00:20,870', endTime: '00:00:21,870', duration: '1s 0ms', englishText: 'Am I?' },
+  { segmentId: 10, startTime: '00:00:23,120', endTime: '00:00:24,390', duration: '1s 270ms', englishText: 'I have no empathy.' },
+  { segmentId: 11, startTime: '00:00:25,540', endTime: '00:00:27,170', duration: '1s 630ms', englishText: 'I don\'t respect you.' },
+  { segmentId: 12, startTime: '00:00:28,550', endTime: '00:00:29,880', duration: '1s 330ms', englishText: 'I\'m never satisfied.' },
+  { segmentId: 13, startTime: '00:00:30,440', endTime: '00:00:33,180', duration: '2s 740ms', englishText: 'I have an obsession with power.' },
+  { segmentId: 14, startTime: '00:00:37,850', endTime: '00:00:38,950', duration: '1s 100ms', englishText: 'I\'m irrational.' },
+  { segmentId: 15, startTime: '00:00:39,930', endTime: '00:00:41,520', duration: '1s 590ms', englishText: 'I have zero remorse.' },
+  { segmentId: 16, startTime: '00:00:41,770', endTime: '00:00:43,900', duration: '2s 130ms', englishText: 'I have no sense of compassion.' },
+  { segmentId: 17, startTime: '00:00:44,480', endTime: '00:00:46,650', duration: '2s 170ms', englishText: 'I\'m delusional. I\'m maniacal.' },
+  { segmentId: 18, startTime: '00:00:46,960', endTime: '00:00:48,980', duration: '2s 20ms', englishText: 'You think I\'m a bad person?' },
+  { segmentId: 19, startTime: '00:00:49,320', endTime: '00:00:52,700', duration: '3s 380ms', englishText: 'Tell me. Tell me. Tell me.\nTell me. Am I?' },
+  { segmentId: 20, startTime: '00:00:52,990', endTime: '00:00:55,136', duration: '2s 146ms', englishText: 'I think I\'m better than everyone else.' },
+  { segmentId: 21, startTime: '00:00:55,170', endTime: '00:00:57,820', duration: '2s 650ms', englishText: 'I want to take what\'s yours and never give it back.' },
+  { segmentId: 22, startTime: '00:00:57,840', endTime: '00:01:00,640', duration: '2s 800ms', englishText: 'What\'s mine is mine and what\'s yours is mine.' },
+  { segmentId: 23, startTime: '00:01:06,920', endTime: '00:01:08,290', duration: '1s 370ms', englishText: 'Am I a bad person?' },
+  { segmentId: 24, startTime: '00:01:08,840', endTime: '00:01:10,420', duration: '1s 580ms', englishText: 'Tell me. Am I?' },
+  { segmentId: 25, startTime: '00:01:21,500', endTime: '00:01:23,650', duration: '2s 150ms', englishText: 'Does that make me a bad person?' },
+  { segmentId: 26, startTime: '00:01:25,060', endTime: '00:01:26,900', duration: '1s 840ms', englishText: 'Tell me. Does it?' }
+];
+
+async function seedAtlasSubtitles() {
+  try {
+    console.log('🔗 Connecting to Atlas MongoDB...');
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to Atlas MongoDB');
+    console.log('📊 Database:', mongoose.connection.db.databaseName);
+
+    // Check if subtitles collection exists
+    const collections = await mongoose.connection.db.listCollections().toArray();
+    const subtitleExists = collections.some(col => col.name === 'subtitles');
+    console.log('📋 Existing collections:', collections.map(col => col.name));
+    console.log('✅ Subtitles collection exists:', subtitleExists);
+
+    if (subtitleExists) {
+      // Clear existing subtitles
+      console.log('🗑️ Clearing existing subtitle data...');
+      await Subtitle.deleteMany({});
+      console.log('✅ Cleared existing subtitle data');
+    }
+
+    // Insert new subtitle data
+    console.log('📝 Inserting subtitle data...');
+    const result = await Subtitle.insertMany(subtitleData);
+    console.log(`✅ Successfully inserted ${result.length} subtitle segments`);
+
+    // Verify the data
+    console.log('🔍 Verifying data...');
+    const count = await Subtitle.countDocuments();
+    console.log(`📊 Total subtitle segments in Atlas: ${count}`);
+
+    // Show sample data
+    const sample = await Subtitle.findOne().sort({ segmentId: 1 });
+    console.log('📋 Sample subtitle data:');
+    console.log(JSON.stringify(sample, null, 2));
+
+    console.log('🎉 Atlas subtitle seeding completed successfully!');
+    
+  } catch (error) {
+    console.error('❌ Error seeding Atlas subtitles:', error);
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from Atlas MongoDB');
+  }
+}
+
+// Run the seeding function
+if (require.main === module) {
+  seedAtlasSubtitles();
+}
+
+module.exports = { seedAtlasSubtitles, subtitleData }; 

backups/complete-backup-2025-08-10T07-59-20-407Z/code/backend/seed-subtitle-submissions.js

@@ -0,0 +1,178 @@
+const mongoose = require('mongoose');
+const SubtitleSubmission = require('./models/SubtitleSubmission');
+
+const MONGODB_URI = 'mongodb+srv://nothingyu:wSg3lbO1PkHiRMq9@sandbox.ecysggv.mongodb.net/test?retryWrites=true&w=majority&appName=sandbox';
+
+// Generate valid ObjectIds for users
+const generateUserId = () => new mongoose.Types.ObjectId();
+
+const sampleSubmissions = [
+  // Segment 1 submissions
+  {
+    userId: generateUserId(),
+    username: 'Student A',
+    segmentId: 1,
+    chineseTranslation: '我是不是一个坏人？',
+    submissionDate: new Date(Date.now() - 2 * 60 * 60 * 1000), // 2 hours ago
+    isAnonymous: false,
+    weekNumber: 2
+  },
+  {
+    userId: generateUserId(),
+    username: 'Student B',
+    segmentId: 1,
+    chineseTranslation: '我是否是一个坏人？',
+    submissionDate: new Date(Date.now() - 1 * 60 * 60 * 1000), // 1 hour ago
+    isAnonymous: false,
+    weekNumber: 2
+  },
+  {
+    userId: generateUserId(),
+    username: 'Student C',
+    segmentId: 1,
+    chineseTranslation: '我是否是个坏人？',
+    submissionDate: new Date(Date.now() - 30 * 60 * 1000), // 30 minutes ago
+    isAnonymous: false,
+    weekNumber: 2
+  },
+  
+  // Segment 7 submissions (longer text)
+  {
+    userId: generateUserId(),
+    username: 'Student D',
+    segmentId: 7,
+    chineseTranslation: '这让我成为一个坏人吗？',
+    submissionDate: new Date(Date.now() - 3 * 60 * 60 * 1000), // 3 hours ago
+    isAnonymous: false,
+    weekNumber: 2
+  },
+  {
+    userId: generateUserId(),
+    username: 'Student E',
+    segmentId: 7,
+    chineseTranslation: '这是否使我成为一个坏人？',
+    submissionDate: new Date(Date.now() - 45 * 60 * 1000), // 45 minutes ago
+    isAnonymous: false,
+    weekNumber: 2
+  },
+  
+  // Segment 13 submissions (very long text)
+  {
+    userId: generateUserId(),
+    username: 'Student F',
+    segmentId: 13,
+    chineseTranslation: '我对权力有一种执念。',
+    submissionDate: new Date(Date.now() - 4 * 60 * 60 * 1000), // 4 hours ago
+    isAnonymous: false,
+    weekNumber: 2
+  },
+  {
+    userId: generateUserId(),
+    username: 'Student G',
+    segmentId: 13,
+    chineseTranslation: '我对权力有着执念。',
+    submissionDate: new Date(Date.now() - 20 * 60 * 1000), // 20 minutes ago
+    isAnonymous: false,
+    weekNumber: 2
+  },
+  
+  // Segment 19 submissions (multiple lines)
+  {
+    userId: generateUserId(),
+    username: 'Student H',
+    segmentId: 19,
+    chineseTranslation: '告诉我。告诉我。告诉我。\n告诉我。我是吗？',
+    submissionDate: new Date(Date.now() - 1.5 * 60 * 60 * 1000), // 1.5 hours ago
+    isAnonymous: false,
+    weekNumber: 2
+  },
+  {
+    userId: generateUserId(),
+    username: 'Student I',
+    segmentId: 19,
+    chineseTranslation: '告诉我。告诉我。告诉我。告诉我。我是吗？',
+    submissionDate: new Date(Date.now() - 15 * 60 * 1000), // 15 minutes ago
+    isAnonymous: false,
+    weekNumber: 2
+  },
+  
+  // Segment 26 submissions (final segment)
+  {
+    userId: generateUserId(),
+    username: 'Student J',
+    segmentId: 26,
+    chineseTranslation: '告诉我。是吗？',
+    submissionDate: new Date(Date.now() - 5 * 60 * 60 * 1000), // 5 hours ago
+    isAnonymous: false,
+    weekNumber: 2
+  },
+  {
+    userId: generateUserId(),
+    username: 'Student K',
+    segmentId: 26,
+    chineseTranslation: '告诉我。是这样吗？',
+    submissionDate: new Date(Date.now() - 10 * 60 * 1000), // 10 minutes ago
+    isAnonymous: false,
+    weekNumber: 2
+  },
+  
+  // Additional submissions with real usernames
+  {
+    userId: generateUserId(),
+    username: 'Student L',
+    segmentId: 1,
+    chineseTranslation: '我是否是一个坏人呢？',
+    submissionDate: new Date(Date.now() - 25 * 60 * 1000), // 25 minutes ago
+    isAnonymous: false,
+    weekNumber: 2
+  },
+  {
+    userId: generateUserId(),
+    username: 'Student M',
+    segmentId: 7,
+    chineseTranslation: '这让我成为坏人吗？',
+    submissionDate: new Date(Date.now() - 35 * 60 * 1000), // 35 minutes ago
+    isAnonymous: false,
+    weekNumber: 2
+  }
+];
+
+const seedSubmissions = async () => {
+  try {
+    console.log('🔧 Connecting to MongoDB...');
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to MongoDB');
+    
+    // Clear existing submissions
+    console.log('🧹 Clearing existing subtitle submissions...');
+    await SubtitleSubmission.deleteMany({});
+    console.log('✅ Cleared existing submissions');
+    
+    // Insert sample submissions
+    console.log('📝 Inserting sample subtitle submissions...');
+    const result = await SubtitleSubmission.insertMany(sampleSubmissions);
+    console.log(`✅ Inserted ${result.length} sample submissions`);
+    
+    // Display summary
+    console.log('\n📊 Submission Summary:');
+    const segmentCounts = await SubtitleSubmission.aggregate([
+      { $group: { _id: '$segmentId', count: { $sum: 1 } } },
+      { $sort: { _id: 1 } }
+    ]);
+    
+    segmentCounts.forEach(({ _id, count }) => {
+      console.log(`  Segment ${_id}: ${count} submission${count !== 1 ? 's' : ''}`);
+    });
+    
+    console.log('\n🎉 Sample subtitle submissions seeded successfully!');
+    
+  } catch (error) {
+    console.error('❌ Error seeding subtitle submissions:', error);
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+};
+
+// Run the seeding
+seedSubmissions(); 

backups/complete-backup-2025-08-10T07-59-20-407Z/code/frontend/Layout.tsx

@@ -0,0 +1,191 @@
+import React, { useState, useEffect, useRef } from 'react';
+import { Link, useLocation } from 'react-router-dom';
+import { 
+  HomeIcon, 
+  AcademicCapIcon,
+  BookOpenIcon,
+  HandThumbUpIcon,
+  UserIcon,
+  ArrowRightOnRectangleIcon
+} from '@heroicons/react/24/outline';
+
+interface User {
+  name: string;
+  email: string;
+  role: string;
+}
+
+const Layout: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+  const location = useLocation();
+  const [isTransitioning, setIsTransitioning] = useState(false);
+  const previousPathRef = useRef(location.pathname);
+  const userData = localStorage.getItem('user');
+  const user: User | null = userData ? JSON.parse(userData) : null;
+
+    // Handle page transitions
+  useEffect(() => {
+    // Only trigger transition if path actually changed
+    if (location.pathname !== previousPathRef.current) {
+      setIsTransitioning(true);
+      previousPathRef.current = location.pathname;
+      
+      // Reset week selection to Week 1 when navigating between pages
+      const previousPath = previousPathRef.current;
+      if (location.pathname === '/tutorial-tasks' && 
+          previousPath && 
+          !previousPath.includes('/tutorial-tasks')) {
+        // Use URL parameter to force Week 1
+        window.history.replaceState(null, '', '/tutorial-tasks?week=1');
+        localStorage.setItem('selectedTutorialWeek', '1');
+      } else if (location.pathname === '/weekly-practice' && 
+                 previousPath && 
+                 !previousPath.includes('/weekly-practice')) {
+        // Use URL parameter to force Week 1
+        window.history.replaceState(null, '', '/weekly-practice?week=1');
+        localStorage.setItem('selectedWeeklyPracticeWeek', '1');
+      }
+      
+      // Determine transition duration based on destination page
+      let transitionDuration = 800; // Default duration
+      
+      // Longer duration for heavy pages
+      if (location.pathname === '/tutorial-tasks' || location.pathname === '/weekly-practice') {
+        transitionDuration = 1200; // Longer for content-heavy pages
+      }
+      
+      // Special case: Weekly Practice → Tutorial Tasks (add 500ms delay)
+      if (location.pathname === '/tutorial-tasks' && 
+          previousPath && 
+          previousPath.includes('/weekly-practice')) {
+        // Check if navigating to Week 2 (use localStorage since URL might not be updated yet)
+        const tutorialWeek = localStorage.getItem('selectedTutorialWeek');
+        if (tutorialWeek === '2') {
+          transitionDuration = 2500; // Extended duration for Week 2 (2000 + 500)
+        } else {
+          transitionDuration = 1700; // Standard duration for Week 1 (1200 + 500)
+        }
+      }
+      
+      // End transition after content is loaded (wait for DOM updates)
+      const timer = setTimeout(() => {
+        setIsTransitioning(false);
+      }, transitionDuration);
+      
+      return () => clearTimeout(timer);
+    }
+  }, [location.pathname]);
+
+  const handleLogout = () => {
+    localStorage.removeItem('token');
+    localStorage.removeItem('user');
+    window.location.href = '/';
+  };
+
+  const navigation = [
+    { name: 'Home', href: '/dashboard', icon: HomeIcon },
+    { name: 'Tutorial Tasks', href: '/tutorial-tasks', icon: AcademicCapIcon },
+    { name: 'Weekly Practice', href: '/weekly-practice', icon: BookOpenIcon },
+    { name: 'Votes', href: '/votes', icon: HandThumbUpIcon },
+  ];
+
+  // Add Manage link for admin users
+  if (user?.role === 'admin') {
+    navigation.push({ name: 'Manage', href: '/manage', icon: UserIcon });
+  }
+
+  return (
+    <div className="min-h-screen bg-gray-50">
+      {/* Navigation */}
+      <nav className="bg-white shadow-sm border-b border-gray-200">
+        <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
+          <div className="flex justify-between h-16">
+            <div className="flex">
+              <div className="flex-shrink-0 flex items-center">
+                <Link to="/dashboard" className="text-xl font-bold text-indigo-600">
+                  Transcreation
+                </Link>
+              </div>
+              <div className="hidden sm:ml-6 sm:flex sm:space-x-8">
+                {navigation.map((item) => {
+                  const isActive = location.pathname === item.href;
+                  return (
+                    <Link
+                      key={item.name}
+                      to={item.href}
+                      className={`inline-flex items-center px-1 pt-1 border-b-2 text-sm font-medium transition-all duration-200 ease-in-out ${
+                        isActive
+                          ? 'border-indigo-500 text-gray-900'
+                          : 'border-transparent text-gray-500 hover:border-gray-300 hover:text-gray-700'
+                      }`}
+                    >
+                      <item.icon className="h-4 w-4 mr-1" />
+                      {item.name}
+                    </Link>
+                  );
+                })}
+              </div>
+            </div>
+            <div className="flex items-center">
+              {user && (
+                <div className="flex items-center space-x-4">
+                  <span className="text-sm text-gray-700">
+                    Welcome, {user.name}
+                  </span>
+                  <button
+                    onClick={handleLogout}
+                    className="text-gray-500 hover:text-gray-700 flex items-center"
+                  >
+                    <ArrowRightOnRectangleIcon className="h-4 w-4 mr-1" />
+                    Logout
+                  </button>
+                </div>
+              )}
+            </div>
+          </div>
+        </div>
+      </nav>
+
+      {/* Mobile Navigation */}
+      <div className="sm:hidden">
+        <div className="pt-2 pb-3 space-y-1">
+          {navigation.map((item) => {
+            const isActive = location.pathname === item.href;
+            return (
+              <Link
+                key={item.name}
+                to={item.href}
+                className={`block pl-3 pr-4 py-2 border-l-4 text-base font-medium transition-all duration-200 ease-in-out ${
+                  isActive
+                    ? 'bg-indigo-50 border-indigo-500 text-indigo-700'
+                    : 'border-transparent text-gray-600 hover:bg-gray-50 hover:border-gray-300 hover:text-gray-800'
+                }`}
+              >
+                <div className="flex items-center">
+                  <item.icon className="h-4 w-4 mr-2" />
+                  {item.name}
+                </div>
+              </Link>
+            );
+          })}
+        </div>
+      </div>
+
+                        {/* Main Content */}
+                  <main>
+                    {!isTransitioning && children}
+                  </main>
+      
+      {/* Transition Loading Indicator */}
+      {isTransitioning && (
+        <div className="fixed top-1/2 left-1/2 transform -translate-x-1/2 -translate-y-1/2 z-50">
+          <div className="bg-white rounded-lg shadow-lg p-4 flex items-center space-x-3">
+            <div className="animate-spin rounded-full h-6 w-6 border-b-2 border-indigo-600"></div>
+            <span className="text-gray-700 font-medium">Loading...</span>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+};
+
+export default Layout; 

backups/complete-backup-2025-08-10T07-59-20-407Z/code/frontend/TutorialTasks.tsx

@@ -0,0 +1,1724 @@
+import React, { useState, useEffect, useCallback } from 'react';
+import { useNavigate } from 'react-router-dom';
+import { api } from '../services/api';
+import { 
+  AcademicCapIcon, 
+  DocumentTextIcon, 
+  CheckCircleIcon,
+  ClockIcon,
+  ArrowRightIcon,
+  PencilIcon,
+  XMarkIcon,
+  CheckIcon,
+  PlusIcon,
+  TrashIcon
+} from '@heroicons/react/24/outline';
+
+interface TutorialTask {
+  _id: string;
+  content: string;
+  weekNumber: number;
+  translationBrief?: string;
+  imageUrl?: string;
+  imageAlt?: string;
+  imageSize?: number;
+  imageAlignment?: 'left' | 'center' | 'right';
+}
+
+interface TutorialWeek {
+  weekNumber: number;
+  translationBrief?: string;
+  tasks: TutorialTask[];
+}
+
+interface UserSubmission {
+  _id: string;
+  transcreation: string;
+  status: string;
+  score: number;
+  groupNumber?: number;
+  isOwner?: boolean;
+  userId?: {
+    _id: string;
+    username: string;
+  };
+  voteCounts: {
+    '1': number;
+    '2': number;
+    '3': number;
+  };
+}
+
+const TutorialTasks: React.FC = () => {
+  const [selectedWeek, setSelectedWeek] = useState<number>(() => {
+    const savedWeek = localStorage.getItem('selectedTutorialWeek');
+    return savedWeek ? parseInt(savedWeek) : 1;
+  });
+  const [isWeekTransitioning, setIsWeekTransitioning] = useState(false);
+  const [tutorialTasks, setTutorialTasks] = useState<TutorialTask[]>([]);
+  const [tutorialWeek, setTutorialWeek] = useState<TutorialWeek | null>(null);
+  const [userSubmissions, setUserSubmissions] = useState<{[key: string]: UserSubmission[]}>({});
+  const [loading, setLoading] = useState(true);
+  const [submitting, setSubmitting] = useState<{[key: string]: boolean}>({});
+  const [translationText, setTranslationText] = useState<{[key: string]: string}>({});
+  const [selectedGroups, setSelectedGroups] = useState<{[key: string]: number}>({});
+  const [expandedSections, setExpandedSections] = useState<{[key: string]: boolean}>({});
+
+  const [editingTask, setEditingTask] = useState<string | null>(null);
+  const [editingBrief, setEditingBrief] = useState<{[key: number]: boolean}>({});
+  const [addingTask, setAddingTask] = useState<boolean>(false);
+  const [addingImage, setAddingImage] = useState<boolean>(false);
+  const [editForm, setEditForm] = useState<{
+    content: string;
+    translationBrief: string;
+    imageUrl: string;
+    imageAlt: string;
+  }>({
+    content: '',
+    translationBrief: '',
+    imageUrl: '',
+    imageAlt: ''
+  });
+  const [imageForm, setImageForm] = useState<{
+    imageUrl: string;
+    imageAlt: string;
+    imageSize: number;
+    imageAlignment: 'left' | 'center' | 'right';
+  }>({
+    imageUrl: '',
+    imageAlt: '',
+    imageSize: 200,
+    imageAlignment: 'center'
+  });
+  const [selectedFile, setSelectedFile] = useState<File | null>(null);
+  const [uploading, setUploading] = useState(false);
+  const [saving, setSaving] = useState(false);
+  const navigate = useNavigate();
+
+  const weeks = [1, 2, 3, 4, 5, 6];
+
+  const handleWeekChange = async (week: number) => {
+    setIsWeekTransitioning(true);
+    
+    // Clear existing data first
+    setTutorialTasks([]);
+    setTutorialWeek(null);
+    setUserSubmissions({});
+    
+    // Update state and localStorage
+    setSelectedWeek(week);
+    localStorage.setItem('selectedTutorialWeek', week.toString());
+    
+    // Force a small delay to ensure state is updated
+    await new Promise(resolve => setTimeout(resolve, 50));
+    
+    // Wait for actual content to load before ending animation
+    try {
+      // Fetch new week's data with the updated selectedWeek
+      const response = await api.get(`/api/search/tutorial-tasks/${week}`);
+      
+      if (response.data) {
+        const tasks = response.data;
+        console.log('Fetched tasks for week', week, ':', tasks);
+        
+        // Ensure tasks are sorted by title
+        const sortedTasks = tasks.sort((a: any, b: any) => {
+          const aNum = parseInt(a.title?.match(/ST (\d+)/)?.[1] || '0');
+          const bNum = parseInt(b.title?.match(/ST (\d+)/)?.[1] || '0');
+          return aNum - bNum;
+        });
+        
+        setTutorialTasks(sortedTasks);
+        
+        // Use translation brief from tasks or localStorage
+        let translationBrief = null;
+        if (tasks.length > 0) {
+          translationBrief = tasks[0].translationBrief;
+        } else {
+          const briefKey = `translationBrief_week_${week}`;
+          translationBrief = localStorage.getItem(briefKey);
+        }
+        
+        const tutorialWeekData: TutorialWeek = {
+          weekNumber: week,
+          translationBrief: translationBrief,
+          tasks: tasks
+        };
+        setTutorialWeek(tutorialWeekData);
+        
+        // Fetch user submissions for the new tasks
+        await fetchUserSubmissions(tasks);
+      }
+      
+      // Wait longer for DOM to update with new content (especially for Week 2)
+      const delay = week === 2 ? 400 : 200;
+      await new Promise(resolve => setTimeout(resolve, delay));
+    } catch (error) {
+      console.error('Error loading week data:', error);
+    } finally {
+      // End transition after content is loaded and rendered
+      setIsWeekTransitioning(false);
+    }
+  };
+
+  const handleFileUpload = async (file: File): Promise<string> => {
+    try {
+      setUploading(true);
+      
+      // Convert file to data URL for display
+      return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+          const dataUrl = reader.result as string;
+          console.log('File uploaded:', file.name, 'Size:', file.size);
+          console.log('Generated data URL:', dataUrl.substring(0, 50) + '...');
+          resolve(dataUrl);
+        };
+        reader.onerror = () => {
+          console.error('Error reading file:', reader.error);
+          reject(reader.error);
+        };
+        reader.readAsDataURL(file);
+      });
+    } catch (error) {
+      console.error('Error uploading file:', error);
+      throw error;
+    } finally {
+      setUploading(false);
+    }
+  };
+
+  const handleFileChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+    const file = event.target.files?.[0];
+    if (file) {
+      setSelectedFile(file);
+    }
+  };
+
+  const toggleExpanded = (taskId: string) => {
+    setExpandedSections(prev => ({
+      ...prev,
+      [taskId]: !prev[taskId]
+    }));
+  };
+
+  const fetchUserSubmissions = useCallback(async (tasks: TutorialTask[]) => {
+    try {
+      const token = localStorage.getItem('token');
+      const user = localStorage.getItem('user');
+      
+      if (!token || !user) {
+        return;
+      }
+
+      const response = await api.get('/api/submissions/my-submissions');
+
+      if (response.data && response.data.submissions) {
+        const data = response.data;
+        
+        const groupedSubmissions: {[key: string]: UserSubmission[]} = {};
+        
+        // Initialize all tasks with empty arrays
+        tasks.forEach(task => {
+          groupedSubmissions[task._id] = [];
+        });
+        
+        // Then populate with actual submissions
+        if (data.submissions && Array.isArray(data.submissions)) {
+          data.submissions.forEach((submission: any) => {
+            // Extract the actual ID from sourceTextId (could be string or object)
+            const sourceTextId = submission.sourceTextId?._id || submission.sourceTextId;
+            
+            if (sourceTextId && groupedSubmissions[sourceTextId]) {
+              groupedSubmissions[sourceTextId].push(submission);
+            }
+          });
+        }
+                  
+        setUserSubmissions(groupedSubmissions);
+      }
+    } catch (error) {
+      console.error('Error fetching user submissions:', error);
+    }
+  }, []);
+
+  const fetchTutorialTasks = useCallback(async (showLoading = true) => {
+    try {
+      if (showLoading) {
+        setLoading(true);
+      }
+      const token = localStorage.getItem('token');
+      const user = localStorage.getItem('user');
+      
+      if (!token || !user) {
+        navigate('/login');
+        return;
+      }
+
+      const response = await api.get(`/api/search/tutorial-tasks/${selectedWeek}`);
+
+      if (response.data) {
+        const tasks = response.data;
+        console.log('Fetched tasks:', tasks);
+        console.log('Tasks with images:', tasks.filter((task: TutorialTask) => task.imageUrl));
+        
+        // Debug: Log each task's fields
+        tasks.forEach((task: any, index: number) => {
+          console.log(`Task ${index} fields:`, {
+            _id: task._id,
+            content: task.content,
+            imageUrl: task.imageUrl,
+            imageAlt: task.imageAlt,
+            translationBrief: task.translationBrief,
+            weekNumber: task.weekNumber,
+            category: task.category
+          });
+          console.log(`Task ${index} imageUrl:`, task.imageUrl);
+          console.log(`Task ${index} translationBrief:`, task.translationBrief);
+        });
+        
+        // Ensure tasks are sorted by title to maintain correct order (Tutorial ST 1, Tutorial ST 2, etc.)
+        const sortedTasks = tasks.sort((a: any, b: any) => {
+          const aNum = parseInt(a.title?.match(/ST (\d+)/)?.[1] || '0');
+          const bNum = parseInt(b.title?.match(/ST (\d+)/)?.[1] || '0');
+          return aNum - bNum;
+        });
+        setTutorialTasks(sortedTasks);
+        
+        // Use translation brief from tasks or localStorage
+        let translationBrief = null;
+        if (tasks.length > 0) {
+          translationBrief = tasks[0].translationBrief;
+          console.log('Translation brief from task:', translationBrief);
+        } else {
+          // Check localStorage for brief if no tasks exist
+          const briefKey = `translationBrief_week_${selectedWeek}`;
+          translationBrief = localStorage.getItem(briefKey);
+          console.log('Translation brief from localStorage:', translationBrief);
+          console.log('localStorage key:', briefKey);
+        }
+        
+        console.log('Final translation brief:', translationBrief);
+        const tutorialWeekData: TutorialWeek = {
+          weekNumber: selectedWeek,
+          translationBrief: translationBrief,
+          tasks: tasks
+        };
+        setTutorialWeek(tutorialWeekData);
+        
+        await fetchUserSubmissions(tasks);
+      } else {
+        console.error('Failed to fetch tutorial tasks');
+      }
+    } catch (error) {
+      console.error('Error fetching tutorial tasks:', error);
+    } finally {
+      if (showLoading) {
+        setLoading(false);
+      }
+    }
+  }, [selectedWeek, fetchUserSubmissions, navigate]);
+
+  useEffect(() => {
+    const user = localStorage.getItem('user');
+    if (!user) {
+      navigate('/login');
+      return;
+    }
+    fetchTutorialTasks();
+  }, [fetchTutorialTasks, navigate]);
+
+  // Listen for week reset events from page navigation
+  useEffect(() => {
+    const handleWeekReset = (event: CustomEvent) => {
+      if (event.detail.page === 'tutorial-tasks') {
+        console.log('Week reset event received for tutorial tasks');
+        setSelectedWeek(event.detail.week);
+        localStorage.setItem('selectedTutorialWeek', event.detail.week.toString());
+      }
+    };
+
+    window.addEventListener('weekReset', handleWeekReset as EventListener);
+    return () => {
+      window.removeEventListener('weekReset', handleWeekReset as EventListener);
+    };
+  }, []);
+
+  // Refresh submissions when user changes (after login/logout)
+  useEffect(() => {
+    const user = localStorage.getItem('user');
+    if (user && tutorialTasks.length > 0) {
+      fetchUserSubmissions(tutorialTasks);
+    }
+  }, [tutorialTasks, fetchUserSubmissions]);
+
+  const handleSubmitTranslation = async (taskId: string) => {
+    if (!translationText[taskId]?.trim()) {
+      return;
+    }
+
+    if (!selectedGroups[taskId]) {
+      return;
+    }
+
+    try {
+      setSubmitting({ ...submitting, [taskId]: true });
+      const user = JSON.parse(localStorage.getItem('user') || '{}');
+      const response = await api.post('/api/submissions', {
+        sourceTextId: taskId,
+        transcreation: translationText[taskId],
+        groupNumber: selectedGroups[taskId],
+        culturalAdaptations: [],
+        username: user.name || 'Unknown'
+      });
+
+      if (response.status >= 200 && response.status < 300) {
+        const result = response.data;
+        console.log('Submission created successfully:', result);
+   
+        setTranslationText({ ...translationText, [taskId]: '' });
+        setSelectedGroups({ ...selectedGroups, [taskId]: 0 });
+        await fetchUserSubmissions(tutorialTasks);
+      } else {
+        console.error('Failed to submit translation:', response.data);
+      }
+    } catch (error) {
+      console.error('Error submitting translation:', error);
+      
+    } finally {
+      setSubmitting({ ...submitting, [taskId]: false });
+    }
+  };
+
+  const [editingSubmission, setEditingSubmission] = useState<{id: string, text: string} | null>(null);
+  const [editSubmissionText, setEditSubmissionText] = useState('');
+
+  const handleEditSubmission = async (submissionId: string, currentText: string) => {
+    setEditingSubmission({ id: submissionId, text: currentText });
+    setEditSubmissionText(currentText);
+  };
+
+  const saveEditedSubmission = async () => {
+    if (!editingSubmission || !editSubmissionText.trim()) return;
+
+    try {
+      const response = await api.put(`/api/submissions/${editingSubmission.id}`, {
+        transcreation: editSubmissionText
+      });
+
+      if (response.status >= 200 && response.status < 300) {
+  
+        setEditingSubmission(null);
+        setEditSubmissionText('');
+        await fetchUserSubmissions(tutorialTasks);
+      } else {
+        console.error('Failed to update translation:', response.data);
+      }
+    } catch (error) {
+      console.error('Error updating translation:', error);
+
+    }
+  };
+
+  const cancelEditSubmission = () => {
+    setEditingSubmission(null);
+    setEditSubmissionText('');
+  };
+
+  const handleDeleteSubmission = async (submissionId: string) => {
+
+
+    try {
+      const response = await api.delete(`/api/submissions/${submissionId}`);
+
+      if (response.status === 200) {
+  
+        await fetchUserSubmissions(tutorialTasks);
+      } else {
+
+      }
+    } catch (error) {
+      console.error('Error deleting submission:', error);
+
+    }
+  };
+
+  const getStatusIcon = (status: string) => {
+    switch (status) {
+      case 'approved':
+        return <CheckCircleIcon className="h-5 w-5 text-green-500" />;
+      case 'pending':
+        return <ClockIcon className="h-5 w-5 text-yellow-500" />;
+      default:
+        return <ClockIcon className="h-5 w-5 text-gray-500" />;
+    }
+  };
+
+  const startEditing = (task: TutorialTask) => {
+    setEditingTask(task._id);
+    setEditForm({
+      content: task.content,
+      translationBrief: task.translationBrief || '',
+      imageUrl: task.imageUrl || '',
+      imageAlt: task.imageAlt || ''
+    });
+  };
+
+  const startEditingBrief = () => {
+    setEditingBrief(prev => ({ ...prev, [selectedWeek]: true }));
+    setEditForm({
+      content: '',
+      translationBrief: tutorialWeek?.translationBrief || '',
+      imageUrl: '',
+      imageAlt: ''
+    });
+  };
+
+  const startAddingBrief = () => {
+    setEditingBrief(prev => ({ ...prev, [selectedWeek]: true }));
+    setEditForm({
+      content: '',
+      translationBrief: '',
+      imageUrl: '',
+      imageAlt: ''
+    });
+  };
+
+  const removeBrief = async () => {
+
+    
+    try {
+      setSaving(true);
+      const token = localStorage.getItem('token');
+      const user = JSON.parse(localStorage.getItem('user') || '{}');
+      
+      // Check if user is admin
+      if (user.role !== 'admin') {
+  
+        return;
+      }
+
+              const response = await api.put(`/api/auth/admin/tutorial-brief/${selectedWeek}`, {
+        translationBrief: '',
+        weekNumber: selectedWeek
+      });
+
+      if (response.status >= 200 && response.status < 300) {
+        const briefKey = `translationBrief_week_${selectedWeek}`;
+        localStorage.removeItem(briefKey);
+        setEditForm((prev) => ({ ...prev, translationBrief: '' }));
+        await fetchTutorialTasks();
+
+      } else {
+        console.error('Failed to remove translation brief:', response.data);
+        
+      }
+    } catch (error) {
+      console.error('Failed to remove translation brief:', error);
+      
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  const cancelEditing = () => {
+    setEditingTask(null);
+    setEditingBrief(prev => ({ ...prev, [selectedWeek]: false }));
+    setEditForm({
+      content: '',
+      translationBrief: '',
+      imageUrl: '',
+      imageAlt: ''
+    });
+    setSelectedFile(null);
+  };
+
+  const saveTask = async () => {
+    if (!editingTask) return;
+    
+    try {
+      setSaving(true);
+      const token = localStorage.getItem('token');
+      const user = JSON.parse(localStorage.getItem('user') || '{}');
+      
+      // Check if user is admin
+      if (user.role !== 'admin') {
+
+        return;
+      }
+
+      const updateData = {
+        ...editForm,
+        weekNumber: selectedWeek
+      };
+      console.log('Saving task with data:', updateData);
+      
+              const response = await api.put(`/api/auth/admin/tutorial-tasks/${editingTask}`, updateData);
+
+              if (response.status >= 200 && response.status < 300) {
+          await fetchTutorialTasks(false);
+          setEditingTask(null);
+
+        } else {
+          console.error('Failed to update tutorial task:', response.data);
+          
+        }
+    } catch (error) {
+      console.error('Failed to update tutorial task:', error);
+      
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  const saveBrief = async () => {
+    try {
+      setSaving(true);
+      const user = JSON.parse(localStorage.getItem('user') || '{}');
+      
+      // Check if user is admin
+      if (user.role !== 'admin') {
+        return;
+      }
+
+      console.log('Saving brief for week:', selectedWeek);
+      console.log('Brief content:', editForm.translationBrief);
+
+      // Save brief by creating or updating the first task of the week
+      if (tutorialTasks.length > 0) {
+        const firstTask = tutorialTasks[0];
+        console.log('Updating first task with brief:', firstTask._id);
+        
+        const response = await api.put(`/api/auth/admin/tutorial-tasks/${firstTask._id}`, {
+          ...firstTask,
+          translationBrief: editForm.translationBrief,
+          weekNumber: selectedWeek
+        });
+
+        if (response.status >= 200 && response.status < 300) {
+          console.log('Brief saved successfully');
+          // Optimistic UI update
+          const briefKey = `translationBrief_week_${selectedWeek}`;
+          localStorage.setItem(briefKey, editForm.translationBrief);
+          setTutorialWeek(prev => prev ? { ...prev, translationBrief: editForm.translationBrief } : prev);
+          setEditingBrief(prev => ({ ...prev, [selectedWeek]: false }));
+          // Background refresh
+          fetchTutorialTasks(false);
+        } else {
+          console.error('Failed to save brief:', response.data);
+        }
+      } else {
+        // If no tasks exist, save the brief to localStorage
+        console.log('No tasks available to save brief to - saving to localStorage');
+        const briefKey = `translationBrief_week_${selectedWeek}`;
+        localStorage.setItem(briefKey, editForm.translationBrief);
+        setEditingBrief(prev => ({ ...prev, [selectedWeek]: false }));
+      }
+    } catch (error) {
+      console.error('Failed to update translation brief:', error);
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  const startAddingTask = () => {
+    setAddingTask(true);
+    setEditForm({
+      content: '',
+      translationBrief: '',
+      imageUrl: '',
+      imageAlt: ''
+    });
+  };
+
+  const cancelAddingTask = () => {
+    setAddingTask(false);
+    setEditForm({
+      content: '',
+      translationBrief: '',
+      imageUrl: '',
+      imageAlt: ''
+    });
+    setSelectedFile(null);
+  };
+
+  const startAddingImage = () => {
+    setAddingImage(true);
+    setImageForm({
+      imageUrl: '',
+      imageAlt: '',
+      imageSize: 200,
+      imageAlignment: 'center'
+    });
+  };
+
+  const cancelAddingImage = () => {
+    setAddingImage(false);
+    setImageForm({
+      imageUrl: '',
+      imageAlt: '',
+      imageSize: 200,
+      imageAlignment: 'center'
+    });
+  };
+
+
+
+  const saveNewTask = async () => {
+    try {
+      setSaving(true);
+      const user = JSON.parse(localStorage.getItem('user') || '{}');
+      
+      // Check if user is admin
+      if (user.role !== 'admin') {
+        return;
+      }
+
+      // Allow either content or imageUrl, but not both empty
+      if (!editForm.content.trim() && !editForm.imageUrl.trim()) {
+        return;
+      }
+
+      console.log('Saving new task for week:', selectedWeek);
+      console.log('Task content:', editForm.content);
+      console.log('Image URL:', editForm.imageUrl);
+      console.log('Image Alt:', editForm.imageAlt);
+
+      const taskData = {
+        title: `Week ${selectedWeek} Tutorial Task`,
+        content: editForm.content,
+        sourceLanguage: 'English',
+        weekNumber: selectedWeek,
+        category: 'tutorial',
+        imageUrl: editForm.imageUrl || null,
+        imageAlt: editForm.imageAlt || null,
+        // Add imageSize and imageAlignment for image-only content
+        ...(editForm.imageUrl && !editForm.content.trim() && { imageSize: 200 }),
+        ...(editForm.imageUrl && !editForm.content.trim() && { imageAlignment: 'center' })
+      };
+
+      console.log('Task data being sent:', JSON.stringify(taskData, null, 2));
+
+      console.log('Sending task data:', taskData);
+
+              const response = await api.post('/api/auth/admin/tutorial-tasks', taskData);
+      
+      console.log('Task save response:', response.data);
+
+      if (response.status >= 200 && response.status < 300) {
+        console.log('Task saved successfully');
+                  console.log('Saved task response:', response.data);
+          console.log('Saved task response keys:', Object.keys(response.data || {}));
+          console.log('Saved task response.task:', response.data?.task);
+          console.log('Saved task response.task.imageUrl:', response.data?.task?.imageUrl);
+          console.log('Saved task response.task.translationBrief:', response.data?.task?.translationBrief);
+        await fetchTutorialTasks(false);
+        setAddingTask(false);
+
+              } else {
+          console.error('Failed to add tutorial task:', response.data);
+        }
+      } catch (error) {
+        console.error('Failed to add tutorial task:', error);
+      } finally {
+      setSaving(false);
+    }
+  };
+
+  const saveNewImage = async () => {
+    try {
+      setSaving(true);
+      const user = JSON.parse(localStorage.getItem('user') || '{}');
+      
+      // Check if user is admin
+      if (user.role !== 'admin') {
+        return;
+      }
+
+      if (!imageForm.imageUrl.trim()) {
+        return;
+      }
+
+      const payload = {
+        title: `Week ${selectedWeek} Image Task`,
+        content: '', // Empty content for image-only task
+        sourceLanguage: 'English',
+        weekNumber: selectedWeek,
+        category: 'tutorial',
+        imageUrl: imageForm.imageUrl.trim(),
+        imageAlt: imageForm.imageAlt.trim() || null,
+        imageSize: imageForm.imageSize,
+        imageAlignment: imageForm.imageAlignment
+      };
+
+      console.log('Saving new image task with payload:', payload);
+
+      const response = await api.post('/api/auth/admin/tutorial-tasks', payload);
+
+      if (response.data) {
+        console.log('Image task saved successfully:', response.data);
+        await fetchTutorialTasks(false);
+        setAddingImage(false);
+      } else {
+        console.error('Failed to save image task');
+      }
+    } catch (error) {
+      console.error('Failed to add image task:', error);
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  const deleteTask = async (taskId: string) => {
+
+    
+    try {
+      const token = localStorage.getItem('token');
+      const user = JSON.parse(localStorage.getItem('user') || '{}');
+      
+      // Check if user is admin
+      if (user.role !== 'admin') {
+
+        return;
+      }
+
+      const response = await api.delete(`/api/auth/admin/tutorial-tasks/${taskId}`);
+
+      if (response.status >= 200 && response.status < 300) {
+        await fetchTutorialTasks(false);
+
+      } else {
+        console.error('Failed to delete tutorial task:', response.data);
+        
+      }
+    } catch (error) {
+      console.error('Failed to delete tutorial task:', error);
+      
+    }
+  };
+
+  // Remove intrusive loading screen - just show content with loading state
+
+  return (
+    <div className="min-h-screen bg-gray-50 py-8">
+      <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
+        {/* Header */}
+        <div className="mb-8">
+          <div className="flex items-center mb-4">
+            <AcademicCapIcon className="h-8 w-8 text-indigo-900 mr-3" />
+            <h1 className="text-3xl font-bold text-gray-900">Tutorial Tasks</h1>
+          </div>
+          <p className="text-gray-600">
+            Complete weekly tutorial tasks with your group to practice collaborative translation skills.
+          </p>
+        </div>
+
+        {/* Week Selector */}
+        <div className="mb-6">
+          <div className="flex space-x-2 overflow-x-auto pb-2">
+            {weeks.map((week) => (
+              <button
+                key={week}
+                onClick={() => handleWeekChange(week)}
+                className={`px-4 py-2 rounded-lg font-medium whitespace-nowrap transition-all duration-200 ease-in-out ${
+                  selectedWeek === week
+                    ? 'bg-indigo-600 text-white'
+                    : 'bg-white text-gray-700 hover:bg-gray-50 border border-gray-300'
+                }`}
+              >
+                Week {week}
+              </button>
+            ))}
+          </div>
+        </div>
+
+                {/* Week Transition Loading Spinner */}
+        {isWeekTransitioning && (
+          <div className="fixed top-1/2 left-1/2 transform -translate-x-1/2 -translate-y-1/2 z-50">
+            <div className="bg-white rounded-lg shadow-lg p-4 flex items-center space-x-3">
+              <div className="animate-spin rounded-full h-6 w-6 border-b-2 border-indigo-600"></div>
+              <span className="text-gray-700 font-medium">Loading...</span>
+            </div>
+          </div>
+        )}
+
+        {!isWeekTransitioning && (
+          <>
+            {/* Translation Brief - Shown once at the top */}
+            {tutorialWeek && tutorialWeek.translationBrief ? (
+          <div className="bg-white rounded-lg p-6 mb-8 border border-gray-200 shadow-sm">
+            <div className="flex items-center justify-between mb-4">
+              <div className="flex items-center space-x-3">
+                <div className="bg-indigo-600 rounded-lg p-2">
+                  <DocumentTextIcon className="h-5 w-5 text-white" />
+                </div>
+                <h3 className="text-indigo-900 font-semibold text-xl">Translation Brief</h3>
+              </div>
+              {JSON.parse(localStorage.getItem('user') || '{}').role === 'admin' && (
+                <div className="flex items-center space-x-2">
+                  {editingBrief[selectedWeek] ? (
+                    <>
+                      <button
+                        onClick={saveBrief}
+                        disabled={saving}
+                        className="bg-indigo-500 hover:bg-indigo-600 text-white px-3 py-1 rounded-md transition-colors duration-200 text-sm"
+                      >
+                        {saving ? (
+                          <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-white"></div>
+                        ) : (
+                          <CheckIcon className="h-4 w-4" />
+                        )}
+                      </button>
+                      <button
+                        onClick={cancelEditing}
+                        className="bg-gray-500 hover:bg-gray-600 text-white px-3 py-1 rounded-md transition-colors duration-200 text-sm"
+                      >
+                        <XMarkIcon className="h-4 w-4" />
+                      </button>
+                    </>
+                  ) : (
+                    <>
+                      <button
+                        onClick={startEditingBrief}
+                        className="bg-gray-100 hover:bg-gray-200 text-gray-700 px-3 py-1 rounded-md transition-colors duration-200 text-sm"
+                      >
+                        <PencilIcon className="h-4 w-4" />
+                      </button>
+                      <button
+                        onClick={() => removeBrief()}
+                        className="bg-red-100 hover:bg-red-200 text-red-700 px-3 py-1 rounded-md transition-colors duration-200 text-sm"
+                      >
+                        <TrashIcon className="h-4 w-4" />
+                      </button>
+                    </>
+                  )}
+                </div>
+              )}
+            </div>
+            {editingBrief[selectedWeek] ? (
+              <textarea
+                value={editForm.translationBrief}
+                onChange={(e) => setEditForm({ ...editForm, translationBrief: e.target.value })}
+                className="w-full p-4 border border-gray-300 rounded-lg text-gray-900 leading-relaxed text-base bg-white focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500"
+                rows={6}
+                placeholder="Enter translation brief..."
+              />
+            ) : (
+                                    <p className="text-gray-900 leading-relaxed text-lg font-smiley">{tutorialWeek.translationBrief}</p>
+            )}
+            <div className="mt-4 p-3 bg-indigo-50 rounded-lg">
+              <p className="text-indigo-900 text-sm">
+                <strong>Note:</strong> Tutorial tasks are completed as group submissions. Each group should collaborate to create a single translation per task.
+              </p>
+            </div>
+          </div>
+        ) : (
+          // Show add brief button when no brief exists
+          JSON.parse(localStorage.getItem('user') || '{}').role === 'admin' && (
+            <div className="bg-white rounded-lg p-6 mb-8 border border-gray-200 border-dashed shadow-sm">
+              <div className="flex items-center justify-between mb-4">
+                              <div className="flex items-center space-x-3">
+                <div className="bg-indigo-100 rounded-lg p-2">
+                  <DocumentTextIcon className="h-5 w-5 text-indigo-900" />
+                </div>
+                <h3 className="text-indigo-900 font-semibold text-xl">Translation Brief</h3>
+              </div>
+                <button
+                  onClick={startAddingBrief}
+                  className="bg-indigo-600 hover:bg-indigo-700 text-white px-6 py-3 rounded-lg font-medium flex items-center space-x-2 shadow-sm"
+                >
+                  <PlusIcon className="h-5 w-5" />
+                  <span className="font-medium">Add Brief</span>
+                </button>
+              </div>
+              {editingBrief[selectedWeek] && (
+                <div className="space-y-4">
+                  <textarea
+                    value={editForm.translationBrief}
+                    onChange={(e) => setEditForm({ ...editForm, translationBrief: e.target.value })}
+                    className="w-full p-4 border border-gray-300 rounded-lg text-gray-900 leading-relaxed text-base bg-white focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500"
+                    rows={6}
+                    placeholder="Enter translation brief..."
+                  />
+                  <div className="flex justify-end space-x-2">
+                    <button
+                      onClick={saveBrief}
+                      disabled={saving}
+                      className="bg-indigo-600 hover:bg-indigo-700 text-white px-6 py-3 rounded-lg font-medium flex items-center space-x-2 shadow-sm"
+                    >
+                      {saving ? (
+                        <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-white"></div>
+                      ) : (
+                        <>
+                          <CheckIcon className="h-5 w-5" />
+                          <span className="font-medium">Save Brief</span>
+                        </>
+                      )}
+                    </button>
+                    <button
+                      onClick={cancelEditing}
+                      className="bg-gray-500 hover:bg-gray-600 text-white px-6 py-3 rounded-lg font-medium flex items-center space-x-2 shadow-sm"
+                    >
+                      <XMarkIcon className="h-5 w-5" />
+                      <span className="font-medium">Cancel</span>
+                    </button>
+                  </div>
+                </div>
+              )}
+            </div>
+          )
+        )}
+
+        {/* Tutorial Tasks */}
+        <div className="space-y-6">
+          {/* Add New Tutorial Task Section */}
+          {JSON.parse(localStorage.getItem('user') || '{}').role === 'admin' && (
+            <div className="mb-8">
+              {addingTask ? (
+                <div className="bg-white rounded-lg p-6 border border-gray-200 shadow-sm">
+                  <div className="flex items-center space-x-3 mb-4">
+                    <div className="bg-gray-100 rounded-lg p-2">
+                      <PlusIcon className="h-4 w-4 text-gray-600" />
+                    </div>
+                    <h4 className="text-gray-900 font-semibold text-lg">New Tutorial Task</h4>
+                  </div>
+                  <div className="space-y-4">
+                    <div>
+                      <label className="block text-sm font-medium text-gray-700 mb-2">
+                        Task Content *
+                      </label>
+                      <textarea
+                        value={editForm.content}
+                        onChange={(e) => setEditForm({ ...editForm, content: e.target.value })}
+                        className="w-full px-4 py-3 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500 bg-white"
+                        rows={4}
+                        placeholder="Enter tutorial task content..."
+                      />
+                    </div>
+                    <div className="space-y-4">
+                      <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+                        <div>
+                          <label className="block text-sm font-medium text-gray-700 mb-2">
+                            Image URL (Optional)
+                          </label>
+                          <input
+                            type="url"
+                            value={editForm.imageUrl}
+                            onChange={(e) => setEditForm({ ...editForm, imageUrl: e.target.value })}
+                            className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500"
+                            placeholder="https://example.com/image.jpg"
+                          />
+                        </div>
+                        <div>
+                          <label className="block text-sm font-medium text-gray-700 mb-2">
+                            Image Alt Text (Optional)
+                          </label>
+                          <input
+                            type="text"
+                            value={editForm.imageAlt}
+                            onChange={(e) => setEditForm({ ...editForm, imageAlt: e.target.value })}
+                            className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500"
+                            placeholder="Description of the image"
+                          />
+                        </div>
+                      </div>
+                      
+                      {/* File Upload Section - Only for Week 2+ */}
+                      {selectedWeek >= 2 && (
+                        <div className="border-t pt-4">
+                          <label className="block text-sm font-medium text-gray-700 mb-2">
+                            Upload Local Image (Optional)
+                          </label>
+                          <div className="space-y-2">
+                            <input
+                              type="file"
+                              accept="image/*"
+                              onChange={handleFileChange}
+                              className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500"
+                            />
+                            {selectedFile && (
+                              <div className="flex items-center space-x-2">
+                                <span className="text-sm text-gray-600">{selectedFile.name}</span>
+                                <button
+                                  type="button"
+                                  onClick={async () => {
+                                    try {
+                                      const imageUrl = await handleFileUpload(selectedFile);
+                                      setEditForm({ ...editForm, imageUrl });
+                                                                                setSelectedFile(null);
+                                                                          } catch (error) {
+                                        console.error('Upload error:', error);
+                                      }
+                                  }}
+                                  disabled={uploading}
+                                  className="bg-green-500 hover:bg-green-600 disabled:bg-gray-400 text-white px-3 py-1 rounded text-sm"
+                                >
+                                  {uploading ? 'Uploading...' : 'Upload'}
+                                </button>
+                              </div>
+                            )}
+                          </div>
+                        </div>
+                      )}
+                    </div>
+                  </div>
+                  <div className="flex justify-end space-x-2 mt-4">
+                    <button
+                      onClick={saveNewTask}
+                      disabled={saving}
+                      className="bg-indigo-500 hover:bg-indigo-600 text-white px-4 py-2 rounded-lg transition-colors duration-200 flex items-center space-x-2 text-sm"
+                    >
+                      {saving ? (
+                        <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-white"></div>
+                      ) : (
+                        <>
+                          <CheckIcon className="h-4 w-4" />
+                          <span>Save Task</span>
+                        </>
+                      )}
+                    </button>
+                    <button
+                      onClick={cancelAddingTask}
+                      className="bg-gray-500 hover:bg-gray-600 text-white px-4 py-2 rounded-lg transition-colors duration-200 flex items-center space-x-2 text-sm"
+                    >
+                      <XMarkIcon className="h-4 w-4" />
+                      <span>Cancel</span>
+                    </button>
+                  </div>
+                </div>
+              ) : addingImage ? (
+                <div className="bg-white rounded-lg p-6 border border-gray-200 shadow-sm">
+                  <div className="flex items-center space-x-3 mb-4">
+                    <div className="bg-blue-100 rounded-lg p-2">
+                      <PlusIcon className="h-4 w-4 text-blue-600" />
+                    </div>
+                    <h4 className="text-blue-900 font-semibold text-lg">New Image Task</h4>
+                  </div>
+                  <div className="space-y-4">
+                    <div>
+                      <label className="block text-sm font-medium text-gray-700 mb-2">
+                        Image URL *
+                      </label>
+                      <input
+                        type="url"
+                        value={imageForm.imageUrl}
+                        onChange={(e) => setImageForm({ ...imageForm, imageUrl: e.target.value })}
+                        className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500"
+                        placeholder="https://example.com/image.jpg"
+                      />
+                    </div>
+                    <div>
+                      <label className="block text-sm font-medium text-gray-700 mb-2">
+                        Image Alt Text (Optional)
+                      </label>
+                      <input
+                        type="text"
+                        value={imageForm.imageAlt}
+                        onChange={(e) => setImageForm({ ...imageForm, imageAlt: e.target.value })}
+                        className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500"
+                        placeholder="Description of the image"
+                      />
+                    </div>
+                    
+                    {/* File Upload Section */}
+                    <div className="border-t pt-4">
+                      <label className="block text-sm font-medium text-gray-700 mb-2">
+                        Upload Local Image (Optional)
+                      </label>
+                      <div className="space-y-2">
+                        <input
+                          type="file"
+                          accept="image/*"
+                          onChange={handleFileChange}
+                          className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500"
+                        />
+                        {selectedFile && (
+                          <div className="flex items-center space-x-2">
+                            <span className="text-sm text-gray-600">{selectedFile.name}</span>
+                            <button
+                              type="button"
+                              onClick={async () => {
+                                try {
+                                  const imageUrl = await handleFileUpload(selectedFile);
+                                  setImageForm({ ...imageForm, imageUrl });
+                                  setSelectedFile(null);
+                                } catch (error) {
+                                  console.error('Upload error:', error);
+                                }
+                              }}
+                              disabled={uploading}
+                              className="bg-green-500 hover:bg-green-600 disabled:bg-gray-400 text-white px-3 py-1 rounded text-sm"
+                            >
+                              {uploading ? 'Uploading...' : 'Upload'}
+                            </button>
+                          </div>
+                        )}
+                      </div>
+                    </div>
+
+                    <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+                      <div>
+                        <label className="block text-sm font-medium text-gray-700 mb-2">
+                          Image Size
+                        </label>
+                        <select
+                          value={imageForm.imageSize}
+                          onChange={(e) => setImageForm({ ...imageForm, imageSize: parseInt(e.target.value) })}
+                          className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500"
+                        >
+                          <option value={150}>150px</option>
+                          <option value={200}>200px</option>
+                          <option value={300}>300px</option>
+                        </select>
+                      </div>
+                      <div>
+                        <label className="block text-sm font-medium text-gray-700 mb-2">
+                          Image Alignment
+                        </label>
+                        <select
+                          value={imageForm.imageAlignment}
+                          onChange={(e) => setImageForm({ ...imageForm, imageAlignment: e.target.value as 'left' | 'center' | 'right' })}
+                          className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500"
+                        >
+                          <option value="left">Left</option>
+                          <option value="center">Center</option>
+                          <option value="right">Right</option>
+                        </select>
+                      </div>
+                    </div>
+                  </div>
+                  <div className="flex justify-end space-x-2 mt-4">
+                    <button
+                      onClick={saveNewImage}
+                      disabled={saving}
+                      className="bg-blue-500 hover:bg-blue-600 text-white px-4 py-2 rounded-lg transition-colors duration-200 flex items-center space-x-2 text-sm"
+                    >
+                      {saving ? (
+                        <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-white"></div>
+                      ) : (
+                        <>
+                          <CheckIcon className="h-4 w-4" />
+                          <span>Save Image</span>
+                        </>
+                      )}
+                    </button>
+                    <button
+                      onClick={cancelAddingImage}
+                      className="bg-gray-500 hover:bg-gray-600 text-white px-4 py-2 rounded-lg transition-colors duration-200 flex items-center space-x-2 text-sm"
+                    >
+                      <XMarkIcon className="h-4 w-4" />
+                      <span>Cancel</span>
+                    </button>
+                  </div>
+                </div>
+              ) : (
+                <div className="bg-white rounded-lg p-6 border border-gray-200 border-dashed shadow-sm">
+                  <div className="flex items-center justify-between">
+                    <div className="flex items-center space-x-3">
+                      <div className="bg-gray-100 rounded-lg p-2">
+                        <PlusIcon className="h-5 w-5 text-gray-600" />
+                      </div>
+                      <div>
+                        <h3 className="text-lg font-semibold text-indigo-900">Add New Tutorial Task</h3>
+                        <p className="text-gray-600 text-sm">Create a new tutorial task for Week {selectedWeek}</p>
+                      </div>
+                    </div>
+                    <div className="flex space-x-3">
+                      <div className="flex space-x-3">
+                        <button
+                          onClick={startAddingTask}
+                          className="bg-indigo-600 hover:bg-indigo-700 text-white px-6 py-3 rounded-lg font-medium flex items-center space-x-2 shadow-sm"
+                        >
+                          <PlusIcon className="h-5 w-5" />
+                          <span className="font-medium">Add Task</span>
+                        </button>
+                        {selectedWeek >= 3 && (
+                          <button
+                            onClick={startAddingImage}
+                            className="bg-blue-600 hover:bg-blue-700 text-white px-6 py-3 rounded-lg font-medium flex items-center space-x-2 shadow-sm"
+                          >
+                            <PlusIcon className="h-5 w-5" />
+                            <span className="font-medium">Add Image</span>
+                          </button>
+                        )}
+                      </div>
+
+                    </div>
+                  </div>
+                </div>
+              )}
+            </div>
+          )}
+
+          {tutorialTasks.length === 0 && !addingTask ? (
+            <div className="text-center py-12">
+              <DocumentTextIcon className="h-12 w-12 text-gray-400 mx-auto mb-4" />
+              <h3 className="text-lg font-medium text-gray-900 mb-2">
+                No tutorial tasks available
+              </h3>
+              <p className="text-gray-600">
+                Tutorial tasks for Week {selectedWeek} haven't been set up yet.
+              </p>
+            </div>
+          ) : (
+            tutorialTasks.map((task) => (
+              <div key={task._id} className="bg-white rounded-xl shadow-lg border border-gray-100 p-8 hover:shadow-xl transition-shadow duration-300">
+                <div className="mb-6">
+                  <div className="flex items-center justify-between mb-4">
+                    <div className="flex items-center space-x-3">
+                      <div className="bg-indigo-100 rounded-full p-2">
+                        <DocumentTextIcon className="h-5 w-5 text-indigo-900" />
+                      </div>
+                      <div>
+                        <h3 className="text-lg font-semibold text-gray-900">Source Text #{tutorialTasks.indexOf(task) + 1}</h3>
+                      </div>
+                    </div>
+                    {JSON.parse(localStorage.getItem('user') || '{}').role === 'admin' && (
+                      <div className="flex items-center space-x-2">
+                        {editingTask === task._id ? (
+                          <>
+                            <button
+                              onClick={saveTask}
+                              disabled={saving}
+                              className="bg-green-100 hover:bg-green-200 text-green-700 px-3 py-1 rounded-lg transition-colors duration-200"
+                            >
+                              {saving ? (
+                                <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-green-600"></div>
+                              ) : (
+                                <CheckIcon className="h-4 w-4" />
+                              )}
+                            </button>
+                            <button
+                              onClick={cancelEditing}
+                              className="bg-red-100 hover:bg-red-200 text-red-700 px-3 py-1 rounded-lg transition-colors duration-200"
+                            >
+                              <XMarkIcon className="h-4 w-4" />
+                            </button>
+                          </>
+                        ) : (
+                          <>
+                            <button
+                              onClick={() => startEditing(task)}
+                              className="bg-gray-100 hover:bg-gray-200 text-gray-700 px-3 py-1 rounded-md transition-colors duration-200 text-sm"
+                            >
+                              <PencilIcon className="h-4 w-4" />
+                            </button>
+                            <button
+                              onClick={() => deleteTask(task._id)}
+                              className="bg-red-100 hover:bg-red-200 text-red-700 px-3 py-1 rounded-lg transition-colors duration-200"
+                            >
+                              <TrashIcon className="h-4 w-4" />
+                            </button>
+                          </>
+                        )}
+                      </div>
+                    )}
+                  </div>
+
+                  {/* Content - Clean styling with image support */}
+                  <div className="bg-gradient-to-r from-indigo-50 to-blue-50 rounded-xl p-6 mb-6 border border-indigo-200">
+                    {editingTask === task._id ? (
+                      <div className="space-y-4">
+                        <textarea
+                          value={editForm.content}
+                          onChange={(e) => setEditForm({...editForm, content: e.target.value})}
+                          className="w-full px-4 py-3 border border-indigo-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500 bg-white"
+                          rows={5}
+                          placeholder="Enter source text..."
+                        />
+                        <div className="space-y-4">
+                          <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+                            <div>
+                              <label className="block text-sm font-medium text-gray-700 mb-2">Image URL</label>
+                              <input
+                                type="url"
+                                value={editForm.imageUrl}
+                                onChange={(e) => setEditForm({...editForm, imageUrl: e.target.value})}
+                                className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500"
+                                placeholder="https://example.com/image.jpg"
+                              />
+                            </div>
+                            <div>
+                              <label className="block text-sm font-medium text-gray-700 mb-2">Image Alt Text</label>
+                              <input
+                                type="text"
+                                value={editForm.imageAlt}
+                                onChange={(e) => setEditForm({...editForm, imageAlt: e.target.value})}
+                                className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500"
+                                placeholder="Description of the image"
+                              />
+                            </div>
+                          </div>
+                          
+                          {/* File Upload Section - Only for Week 2+ */}
+                          {selectedWeek >= 2 && (
+                            <div className="border-t pt-4">
+                              <label className="block text-sm font-medium text-gray-700 mb-2">
+                                Upload Local Image (Optional)
+                              </label>
+                              <div className="space-y-2">
+                                <input
+                                  type="file"
+                                  accept="image/*"
+                                  onChange={handleFileChange}
+                                  className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500"
+                                />
+                                {selectedFile && (
+                                  <div className="flex items-center space-x-2">
+                                    <span className="text-sm text-gray-600">{selectedFile.name}</span>
+                                    <button
+                                      type="button"
+                                      onClick={async () => {
+                                        try {
+                                          const imageUrl = await handleFileUpload(selectedFile);
+                                          console.log('Uploaded image URL:', imageUrl);
+                                          setEditForm({ ...editForm, imageUrl });
+                                          console.log('Updated editForm:', { ...editForm, imageUrl });
+                                          
+                                          // Save the task with the new image URL
+                                          if (editingTask) {
+                                            console.log('Saving task with image URL:', imageUrl);
+                                            const response = await api.put(`/api/auth/admin/tutorial-tasks/${editingTask}`, {
+                                              ...editForm,
+                                              imageUrl,
+                                              weekNumber: selectedWeek
+                                            });
+                                            console.log('Task save response:', response.data);
+                                            
+                                            if (response.status >= 200 && response.status < 300) {
+                                              await fetchTutorialTasks(false); // Refresh tasks
+                                            }
+                                          }
+                                          
+                                          setSelectedFile(null);
+                                        } catch (error) {
+                                          console.error('Upload error:', error);
+                                        }
+                                      }}
+                                      disabled={uploading}
+                                      className="bg-green-500 hover:bg-green-600 disabled:bg-gray-400 text-white px-3 py-1 rounded text-sm"
+                                    >
+                                      {uploading ? 'Uploading...' : 'Upload'}
+                                    </button>
+                                  </div>
+                                )}
+                              </div>
+                            </div>
+                          )}
+                        </div>
+                      </div>
+                    ) : (
+                      <div className="space-y-4">
+                        {task.imageUrl ? (
+                          // Check if this is an image-only task (created via "Add Image" function)
+                          task.content === 'Image-based task' ? (
+                            // Image-only layout with dynamic sizing and alignment
+                            <div className={`flex flex-col md:flex-row gap-6 items-start ${
+                              task.imageAlignment === 'left' ? 'md:flex-row' : 
+                              task.imageAlignment === 'right' ? 'md:flex-row-reverse' : 
+                              'md:flex-col'
+                            }`}>
+                              {/* Image section */}
+                              <div className={`${
+                                task.imageAlignment === 'left' ? 'w-full md:w-1/2' :
+                                task.imageAlignment === 'right' ? 'w-full md:w-1/2' :
+                                'w-full'
+                              } flex ${
+                                task.imageAlignment === 'left' ? 'justify-start' :
+                                task.imageAlignment === 'right' ? 'justify-end' :
+                                'justify-center'
+                              }`}>
+                                <div className="inline-block rounded-lg shadow-md overflow-hidden">
+                                  <img 
+                                    src={task.imageUrl} 
+                                    alt={task.imageAlt || 'Uploaded image'}
+                                    className="w-full h-auto"
+                                    style={{ 
+                                      height: `${task.imageSize || 200}px`, 
+                                      width: 'auto', 
+                                      objectFit: 'contain' 
+                                    }}
+                                    onError={(e) => {
+                                      console.error('Image failed to load:', e);
+                                      e.currentTarget.style.display = 'none';
+                                    }}
+                                    onLoad={() => {
+                                      console.log('🔧 Debug - Task image loaded:', {
+                                        imageUrl: task.imageUrl,
+                                        imageSize: task.imageSize,
+                                        content: task.content,
+                                        weekNumber: task.weekNumber
+                                      });
+                                    }}
+                                  />
+                                  {task.imageAlt && (
+                                    <div className="text-xs text-gray-500 mt-2 text-center">Alt: {task.imageAlt}</div>
+                                  )}
+                                </div>
+                              </div>
+                            </div>
+                          ) : (
+                            // Regular task layout (original side-by-side for ALL weeks)
+                            <div className="flex flex-col md:flex-row gap-6 items-start">
+                              {/* Image on the left - 50% width */}
+                              <div className="w-full md:w-1/2 flex justify-center">
+                                {task.imageUrl.startsWith('data:') ? (
+                                  // Show actual image if it's a data URL
+                                  <div className="inline-block rounded-lg shadow-md overflow-hidden">
+                                    <img 
+                                      src={task.imageUrl} 
+                                      alt={task.imageAlt || 'Uploaded image'}
+                                      className="w-full h-auto"
+                                      style={{ height: '200px', width: 'auto', objectFit: 'contain' }} // Fixed height for consistency
+                                      onError={(e) => {
+                                        console.error('Image failed to load:', e);
+                                        e.currentTarget.style.display = 'none';
+                                      }}
+                                    />
+                                  </div>
+                                ) : (
+                                  // Show placeholder if it's not a data URL
+                                  <div className="inline-block rounded-lg shadow-md bg-green-500 text-white p-6 text-center">
+                                    <div className="text-3xl mb-2">📷</div>
+                                    <div className="font-semibold">Image Uploaded</div>
+                                    <div className="text-sm opacity-75">{task.imageUrl}</div>
+                                  </div>
+                                )}
+                              </div>
+                              {/* Text on the right - 50% width */}
+                              <div className="w-full md:w-1/2">
+                                <div className="text-indigo-900 leading-relaxed text-lg font-source-text whitespace-pre-wrap">{task.content}</div>
+                              </div>
+                            </div>
+                          )
+                        ) : (
+                          // Text only when no image
+                          <div>
+                            <div className="text-indigo-900 leading-relaxed text-lg font-source-text whitespace-pre-wrap">{task.content}</div>
+                          </div>
+                        )}
+                        {(() => { console.log('Task imageUrl check:', task._id, task.imageUrl, !!task.imageUrl); return null; })()}
+                      </div>
+                    )}
+                  </div>
+
+
+                </div>
+
+                {/* All Submissions for this Task */}
+                {userSubmissions[task._id] && userSubmissions[task._id].length > 0 && (
+                  <div className="bg-gradient-to-r from-white to-indigo-50 rounded-xl p-6 mb-6 border border-stone-200">
+                    <div className="flex items-center justify-between mb-4">
+                      <div className="flex items-center space-x-2">
+                        <div className="bg-indigo-100 rounded-full p-1">
+                          <CheckCircleIcon className="h-4 w-4 text-indigo-900" />
+                        </div>
+                        <h4 className="text-stone-900 font-semibold text-lg">All Submissions ({userSubmissions[task._id].length})</h4>
+                      </div>
+                      <button
+                        onClick={() => toggleExpanded(task._id)}
+                        className="flex items-center space-x-1 text-indigo-900 hover:text-indigo-900 text-sm font-medium"
+                      >
+                        <span>{expandedSections[task._id] ? 'Collapse' : 'Expand'}</span>
+                        <svg
+                          className={`w-4 h-4 transition-transform duration-200 ${expandedSections[task._id] ? 'rotate-180' : ''}`}
+                          fill="none"
+                          stroke="currentColor"
+                          viewBox="0 0 24 24"
+                        >
+                          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 9l-7 7-7-7" />
+                        </svg>
+                      </button>
+                    </div>
+                    <div className={`grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-3 transition-all duration-300 ${
+                      expandedSections[task._id] 
+                        ? 'max-h-none overflow-visible' 
+                        : 'max-h-0 overflow-hidden'
+                    }`}>
+                      {userSubmissions[task._id].map((submission, index) => (
+                        <div key={submission._id} className="bg-white rounded-lg p-3 border border-stone-200 flex flex-col justify-between h-full">
+                          <div className="flex items-center justify-between mb-2">
+                            <div className="flex items-center space-x-2">
+                              {submission.isOwner && (
+                                <span className="inline-block bg-purple-100 text-purple-800 text-xs px-1.5 py-0.5 rounded-full">
+                                  Your Submission
+                                </span>
+                              )}
+                            </div>
+                            {getStatusIcon(submission.status)}
+                          </div>
+                          <p className="text-stone-800 leading-relaxed text-base mb-2 font-smiley">{submission.transcreation}</p>
+                          <div className="flex items-center space-x-4 text-xs text-stone-700 mt-auto">
+                            <div className="flex items-center space-x-1">
+                              <span className="font-medium">Group:</span>
+                              <span className="bg-indigo-100 px-1.5 py-0.5 rounded-full text-indigo-900 text-xs">
+                                {submission.groupNumber}
+                              </span>
+                            </div>
+                            <div className="flex items-center space-x-1">
+                              <span className="font-medium">Votes:</span>
+                              <span className="bg-indigo-100 px-1.5 py-0.5 rounded-full text-indigo-900 text-xs">
+                                {(submission.voteCounts?.['1'] || 0) + (submission.voteCounts?.['2'] || 0) + (submission.voteCounts?.['3'] || 0)}
+                              </span>
+                            </div>
+                          </div>
+                          <div className="flex items-center space-x-2 mt-2">
+                            {submission.isOwner && (
+                              <button
+                                onClick={() => handleEditSubmission(submission._id, submission.transcreation)}
+                                className="text-indigo-900 hover:text-indigo-900 text-sm font-medium"
+                              >
+                                Edit
+                              </button>
+                            )}
+                            {JSON.parse(localStorage.getItem('user') || '{}').role === 'admin' && (
+                              <button
+                                onClick={() => handleDeleteSubmission(submission._id)}
+                                className="text-red-600 hover:text-red-800 text-sm font-medium"
+                              >
+                                Delete
+                              </button>
+                            )}
+                          </div>
+                        </div>
+                      ))}
+                    </div>
+                  </div>
+                )}
+
+                                  {/* Translation Input (always show if user is logged in, but hide for image-only content) */}
+                  {localStorage.getItem('token') && task.content !== 'Image-based task' && (
+                  <div className="bg-white rounded-lg p-6 border border-gray-200 shadow-sm">
+                    <div className="flex items-center space-x-3 mb-4">
+                      <div className="bg-gray-100 rounded-lg p-2">
+                        <DocumentTextIcon className="h-4 w-4 text-gray-600" />
+                      </div>
+                      <h4 className="text-gray-900 font-semibold text-lg">Group Translation</h4>
+                    </div>
+                    
+                    {/* Group Selection */}
+                    <div className="mb-4">
+                      <label className="block text-sm font-medium text-gray-700 mb-2">
+                        Select Your Group *
+                      </label>
+                      <select
+                        value={selectedGroups[task._id] || ''}
+                        onChange={(e) => setSelectedGroups({ ...selectedGroups, [task._id]: parseInt(e.target.value) })}
+                        className="w-48 px-3 py-2 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500 bg-white text-sm"
+                        required
+                      >
+                        <option value="">Choose your group...</option>
+                        {[1, 2, 3, 4, 5, 6, 7, 8].map((group) => (
+                          <option key={group} value={group}>
+                            Group {group}
+                          </option>
+                        ))}
+                      </select>
+                    </div>
+
+                    <div className="mb-4">
+                      <label className="block text-sm font-medium text-gray-700 mb-2">
+                        Your Group's Translation *
+                      </label>
+                      <textarea
+                        value={translationText[task._id] || ''}
+                        onChange={(e) => setTranslationText({ ...translationText, [task._id]: e.target.value })}
+                        className="w-full px-4 py-3 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500 bg-white"
+                        rows={4}
+                        placeholder="Enter your group's translation here..."
+                      />
+                    </div>
+
+                    <button
+                      onClick={() => handleSubmitTranslation(task._id)}
+                      disabled={submitting[task._id]}
+                      className="bg-indigo-500 hover:bg-indigo-600 disabled:bg-gray-400 text-white px-6 py-3 rounded-lg font-medium flex items-center justify-center transition-all duration-200"
+                    >
+                      {submitting[task._id] ? (
+                        <>
+                          <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-white mr-2"></div>
+                          Submitting...
+                        </>
+                      ) : (
+                        <>
+                          Submit Group Translation
+                          <ArrowRightIcon className="h-4 w-4 ml-2" />
+                        </>
+                      )}
+                    </button>
+                  </div>
+                )}
+
+                {/* Show login message for visitors */}
+                {!localStorage.getItem('token') && (
+                  <div className="bg-gradient-to-r from-gray-50 to-indigo-50 rounded-xl p-6 border border-gray-200">
+                    <div className="flex items-center space-x-2 mb-4">
+                      <div className="bg-gray-100 rounded-full p-1">
+                        <DocumentTextIcon className="h-4 w-4 text-gray-600" />
+                      </div>
+                      <h4 className="text-gray-900 font-semibold text-lg">Login Required</h4>
+                    </div>
+                    <p className="text-gray-700 mb-4">
+                      Please log in to submit translations for this tutorial task.
+                    </p>
+                    <button
+                      onClick={() => window.location.href = '/login'}
+                      className="bg-indigo-500 hover:bg-indigo-600 text-white px-6 py-3 rounded-lg font-medium flex items-center justify-center transition-all duration-200"
+                    >
+                      Go to Login
+                      <ArrowRightIcon className="h-4 w-4 ml-2" />
+                    </button>
+                  </div>
+                )}
+              </div>
+            ))
+          )}
+        </div>
+        </>
+        )}
+      </div>
+
+      {/* Edit Submission Modal */}
+      {editingSubmission && (
+        <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50">
+          <div className="bg-white rounded-lg p-6 w-full max-w-2xl mx-4">
+            <div className="flex items-center justify-between mb-4">
+              <h3 className="text-lg font-semibold text-gray-900">Edit Translation</h3>
+              <button
+                onClick={cancelEditSubmission}
+                className="text-gray-400 hover:text-gray-600"
+              >
+                <XMarkIcon className="h-6 w-6" />
+              </button>
+            </div>
+            <div className="mb-4">
+              <textarea
+                value={editSubmissionText}
+                onChange={(e) => setEditSubmissionText(e.target.value)}
+                className="w-full px-4 py-3 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-purple-500 focus:border-purple-500"
+                rows={6}
+                placeholder="Enter your translation..."
+              />
+            </div>
+            <div className="flex justify-end space-x-3">
+              <button
+                onClick={cancelEditSubmission}
+                className="px-4 py-2 text-gray-600 hover:text-gray-800 border border-gray-300 rounded-lg"
+              >
+                Cancel
+              </button>
+              <button
+                onClick={saveEditedSubmission}
+                className="px-4 py-2 bg-purple-600 text-white rounded-lg hover:bg-purple-700"
+              >
+                Save Changes
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+};
+
+export default TutorialTasks; 

backups/complete-backup-2025-08-10T07-59-20-407Z/code/frontend/api.ts

@@ -0,0 +1,91 @@
+import axios from 'axios';
+
+// Create axios instance with base configuration
+// FORCE REBUILD: Fixed double /api issue by removing /api from baseURL
+const api = axios.create({
+  baseURL: 'https://linguabot-transcreation-backend.hf.space',
+  headers: {
+    'Content-Type': 'application/json',
+  },
+  timeout: 10000, // 10 second timeout
+});
+
+// Debug: Log the API URL being used
+console.log('🔧 API CONFIGURATION DEBUG - FIXED DOUBLE /API ISSUE:');
+console.log('API Base URL: https://linguabot-transcreation-backend.hf.space');
+console.log('Environment variables:', {
+  REACT_APP_API_URL: process.env.REACT_APP_API_URL,
+  NODE_ENV: process.env.NODE_ENV
+});
+console.log('Build timestamp:', new Date().toISOString()); // FORCE REBUILD - Video seeking and subtitle syncing
+console.log('🔄 FORCE REBUILD: Admin API routes fixed - should resolve 404 errors');
+console.log('🔄 FORCE REBUILD: Subtitle submissions feature added - new UI and API endpoints');
+
+// Request interceptor to add auth token and user role
+api.interceptors.request.use(
+  (config) => {
+    const token = localStorage.getItem('token');
+    if (token) {
+      config.headers.Authorization = `Bearer ${token}`;
+    }
+    
+    // Add user role and info to headers
+    const user = localStorage.getItem('user');
+    if (user) {
+      try {
+        const userData = JSON.parse(user);
+        config.headers['user-role'] = userData.role || 'visitor';
+        config.headers['user-info'] = JSON.stringify({
+          _id: userData._id,
+          username: userData.username,
+          role: userData.role
+        });
+      } catch (error) {
+        config.headers['user-role'] = 'visitor';
+      }
+    }
+    
+    // Debug: Log the actual request URL
+    console.log('🚀 Making API request to:', (config.baseURL || '') + (config.url || ''));
+    console.log('🔑 Auth token:', token ? 'Present' : 'Missing');
+    
+    return config;
+  },
+  (error) => {
+    return Promise.reject(error);
+  }
+);
+
+// Response interceptor to handle errors
+api.interceptors.response.use(
+  (response) => {
+    console.log('✅ API response received:', response.config.url);
+    return response;
+  },
+  (error) => {
+    console.error('❌ API request failed:', error.config?.url, error.message);
+    
+    // Don't auto-redirect for admin operations - let the component handle it
+    if (error.response?.status === 401 && !error.config?.url?.includes('/subtitles/update/')) {
+      // Token expired or invalid - only redirect for non-admin operations
+      localStorage.removeItem('token');
+      localStorage.removeItem('user');
+      window.location.href = '/login';
+    } else if (error.response?.status === 429) {
+      // Rate limit exceeded - retry after delay
+      console.warn('Rate limit exceeded, retrying after delay...');
+      return new Promise(resolve => {
+        setTimeout(() => {
+          resolve(api.request(error.config));
+        }, 2000); // Wait 2 seconds before retry
+      });
+    } else if (error.response?.status === 500) {
+      console.error('Server error:', error.response.data);
+    } else if (error.code === 'ECONNABORTED') {
+      console.error('Request timeout');
+    }
+    return Promise.reject(error);
+  }
+);
+
+export { api }; 

backups/complete-backup-2025-08-10T07-59-20-407Z/manifest.json

@@ -0,0 +1,49 @@
+{
+  "backupInfo": {
+    "timestamp": "2025-08-10T07:59:22.048Z",
+    "backupType": "Complete Backup",
+    "description": "Full backup including database collections and key code files",
+    "version": "1.0"
+  },
+  "database": {
+    "collections": [
+      "users",
+      "sourcetexts",
+      "submissions",
+      "subtitles",
+      "subtitlesubmissions"
+    ],
+    "totalDocuments": 107
+  },
+  "codeFiles": {
+    "frontend": [
+      "../frontend/client/src/pages/WeeklyPractice.tsx",
+      "../frontend/client/src/pages/TutorialTasks.tsx",
+      "../frontend/client/src/components/Layout.tsx",
+      "../frontend/client/src/services/api.ts"
+    ],
+    "backend": [
+      "index.js",
+      "routes/auth.js",
+      "routes/subtitles.js",
+      "routes/subtitleSubmissions.js",
+      "models/SourceText.js",
+      "models/Subtitle.js",
+      "models/SubtitleSubmission.js",
+      "seed-atlas-subtitles.js",
+      "seed-subtitle-submissions.js"
+    ]
+  },
+  "features": [
+    "Database collections backup",
+    "Key frontend components backup",
+    "Backend routes and models backup",
+    "Seed data scripts backup",
+    "Manifest with backup details"
+  ],
+  "restoreInstructions": {
+    "database": "Use the JSON files to restore collections to MongoDB",
+    "code": "Copy the code files back to their original locations",
+    "verification": "Check manifest.json for backup contents and details"
+  }
+}

backups/complete-backup-2025-08-10T07-59-20-407Z/submissions.json

@@ -0,0 +1,1361 @@
+[
+  {
+    "_id": "68936c2dfffd7a32515e55b7",
+    "sourceTextId": "6890c5676f4532c7d2f0f88c",
+    "userId": "3c6298fe9c723538a5fec5a8",
+    "username": "Visitor",
+    "groupNumber": 8,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "皮皮果宠物用品店｜ 狗狗防风防水羽绒马甲，内置牵引扣，加厚北极绒内里",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "3132017cf466170455c5518c",
+        "rank": 1,
+        "createdAt": "2025-08-06T23:52:52.602Z",
+        "_id": "6893ead4fffd7a32515e6000"
+      },
+      {
+        "userId": "36222902424b6b5e2a2d5177",
+        "rank": 1,
+        "createdAt": "2025-08-06T23:53:55.985Z",
+        "_id": "6893eb13fffd7a32515e610b"
+      },
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 3,
+        "createdAt": "2025-08-07T03:17:22.949Z",
+        "_id": "68941ac2fffd7a32515e65a3"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T14:52:29.612Z",
+    "updatedAt": "2025-08-07T03:17:22.949Z",
+    "__v": 5
+  },
+  {
+    "_id": "68936cd2fffd7a32515e55be",
+    "sourceTextId": "6890c5676f4532c7d2f0f88e",
+    "userId": "3c6298fe9c723538a5fec5a8",
+    "username": "Visitor",
+    "groupNumber": 8,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "产品详情\n\n一件顶两件！外套+胸背带完美结合。\n内置胸背带设计 | 胸背带与外套一体化，配备坚固D型环，牵引更安全。\n出门超省心 | 冬天带毛孩子出门，再也不用里三层外三层！拉链一拉、扣环一扣，即刻出发。",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 3,
+        "createdAt": "2025-08-07T04:59:02.447Z",
+        "_id": "68943296fffd7a32515e6bd0"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T14:55:14.322Z",
+    "updatedAt": "2025-08-07T04:59:02.455Z",
+    "__v": 1
+  },
+  {
+    "_id": "68936cfbfffd7a32515e55c5",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ee7",
+    "userId": "3c6298fe9c723538a5fec5a8",
+    "username": "Visitor",
+    "groupNumber": 8,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "抓绒内里+厚实棉层，狗狗一穿就不想脱。",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [],
+    "feedback": [],
+    "createdAt": "2025-08-06T14:55:55.810Z",
+    "updatedAt": "2025-08-06T14:55:55.811Z",
+    "__v": 0
+  },
+  {
+    "_id": "68936d2afffd7a32515e55cc",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51eea",
+    "userId": "3c6298fe9c723538a5fec5a8",
+    "username": "Visitor",
+    "groupNumber": 8,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "防风防水面料，不惧风雨。",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [],
+    "feedback": [],
+    "createdAt": "2025-08-06T14:56:42.681Z",
+    "updatedAt": "2025-08-06T14:56:42.682Z",
+    "__v": 0
+  },
+  {
+    "_id": "68936d44fffd7a32515e55d3",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51eed",
+    "userId": "3c6298fe9c723538a5fec5a8",
+    "username": "Visitor",
+    "groupNumber": 8,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "拉链挡风片设计，防止风雨从拉链缝隙钻入。",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 1,
+        "createdAt": "2025-08-07T05:03:05.127Z",
+        "_id": "68943389fffd7a32515e6daa"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T14:57:08.907Z",
+    "updatedAt": "2025-08-07T05:03:05.128Z",
+    "__v": 1
+  },
+  {
+    "_id": "68936e04fffd7a32515e55da",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ef0",
+    "userId": "3c6298fe9c723538a5fec5a8",
+    "username": "Visitor",
+    "groupNumber": 8,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "一体式牵引\n\n内置环绕式加固胸背带，受力均匀，狗狗用力拉扯也不用担心脱落，遛狗更安心。",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [],
+    "feedback": [],
+    "createdAt": "2025-08-06T15:00:20.746Z",
+    "updatedAt": "2025-08-06T15:00:20.747Z",
+    "__v": 0
+  },
+  {
+    "_id": "68936e12fffd7a32515e55e1",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ef3",
+    "userId": "3c6298fe9c723538a5fec5a8",
+    "username": "Visitor",
+    "groupNumber": 8,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "两色可选，满足您和爱犬的时尚需求！",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 3,
+        "createdAt": "2025-08-07T03:38:14.480Z",
+        "_id": "68941fa6fffd7a32515e671a"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T15:00:34.362Z",
+    "updatedAt": "2025-08-07T03:38:14.521Z",
+    "__v": 1
+  },
+  {
+    "_id": "68936e33fffd7a32515e55e8",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ef6",
+    "userId": "3c6298fe9c723538a5fec5a8",
+    "username": "Visitor",
+    "groupNumber": 8,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "温暖过冬，就选它！",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 1,
+        "createdAt": "2025-08-07T03:20:11.280Z",
+        "_id": "68941b6bfffd7a32515e661c"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T15:01:07.931Z",
+    "updatedAt": "2025-08-07T03:20:11.281Z",
+    "__v": 1
+  },
+  {
+    "_id": "68936e83fffd7a32515e55ef",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ef9",
+    "userId": "3c6298fe9c723538a5fec5a8",
+    "username": "Visitor",
+    "groupNumber": 8,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "无论是寒风凛冽的冬日漫步。。。",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 3,
+        "createdAt": "2025-08-07T03:59:02.319Z",
+        "_id": "68942486fffd7a32515e67e0"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T15:02:27.052Z",
+    "updatedAt": "2025-08-07T03:59:02.320Z",
+    "__v": 1
+  },
+  {
+    "_id": "68936ee3fffd7a32515e55f6",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51efc",
+    "userId": "3c6298fe9c723538a5fec5a8",
+    "username": "Visitor",
+    "groupNumber": 8,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "还是悠闲自在的家中时光。。。",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "36222902424b6b5e2a2d5177",
+        "rank": 2,
+        "createdAt": "2025-08-06T23:55:48.009Z",
+        "_id": "6893eb84fffd7a32515e61dd"
+      },
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 3,
+        "createdAt": "2025-08-07T03:30:22.487Z",
+        "_id": "68941dcefffd7a32515e66c5"
+      },
+      {
+        "userId": "dbd9b0a6d957cd7ba6a39b9a",
+        "rank": 3,
+        "createdAt": "2025-08-07T09:52:51.307Z",
+        "_id": "68947773fffd7a32515ea29c"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T15:04:03.037Z",
+    "updatedAt": "2025-08-07T09:52:51.308Z",
+    "__v": 3
+  },
+  {
+    "_id": "68936f0ffffd7a32515e55fd",
+    "sourceTextId": "6890c6b2e6b9f36dd5b51eff",
+    "userId": "3c6298fe9c723538a5fec5a8",
+    "username": "Visitor",
+    "groupNumber": 8,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "都能给予狗狗最贴心的呵护！",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "36222902424b6b5e2a2d5177",
+        "rank": 2,
+        "createdAt": "2025-08-06T23:56:36.656Z",
+        "_id": "6893ebb4fffd7a32515e628b"
+      },
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 3,
+        "createdAt": "2025-08-07T03:49:25.488Z",
+        "_id": "68942245fffd7a32515e6778"
+      },
+      {
+        "userId": "dbd9b0a6d957cd7ba6a39b9a",
+        "rank": 3,
+        "createdAt": "2025-08-07T09:53:06.725Z",
+        "_id": "68947782fffd7a32515ea356"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T15:04:47.746Z",
+    "updatedAt": "2025-08-07T09:53:06.726Z",
+    "__v": 3
+  },
+  {
+    "_id": "68936fb8fffd7a32515e5604",
+    "sourceTextId": "6890c6b2e6b9f36dd5b51f02",
+    "userId": "3c6298fe9c723538a5fec5a8",
+    "username": "Visitor",
+    "groupNumber": 8,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "温馨提示：耐用舒适面料，防水性能佳，适合小雨天气，不建议暴雨中长时间使用。\n\n大雨天虽然衣服表面会被打湿，但水分不会渗透，毛孩子身体依然干爽舒适！\n\n快为爱犬添置一件冬日新装吧！",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 1,
+        "createdAt": "2025-08-07T04:03:28.838Z",
+        "_id": "68942590fffd7a32515e689e"
+      },
+      {
+        "userId": "dbd9b0a6d957cd7ba6a39b9a",
+        "rank": 2,
+        "createdAt": "2025-08-07T09:53:39.279Z",
+        "_id": "689477a3fffd7a32515ea3d5"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T15:07:36.624Z",
+    "updatedAt": "2025-08-07T09:53:39.280Z",
+    "__v": 2
+  },
+  {
+    "_id": "6893df40fffd7a32515e58c6",
+    "sourceTextId": "6890c5676f4532c7d2f0f88c",
+    "userId": "36222902424b6b5e2a2d5177",
+    "username": "You Lianxiang",
+    "groupNumber": 1,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "PIPCO宠物用品——狗狗羽绒服带内置牵引带｜防水防风冬季背心带牵引绳接口｜给狗狗的暖和极地绒填充防风外套",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "dbd9b0a6d957cd7ba6a39b9a",
+        "rank": 2,
+        "createdAt": "2025-08-06T23:52:34.774Z",
+        "_id": "6893eac2fffd7a32515e5fe9"
+      },
+      {
+        "userId": "3132017cf466170455c5518c",
+        "rank": 3,
+        "createdAt": "2025-08-06T23:53:25.577Z",
+        "_id": "6893eaf5fffd7a32515e6065"
+      },
+      {
+        "userId": "36222902424b6b5e2a2d5177",
+        "rank": 2,
+        "createdAt": "2025-08-06T23:54:06.941Z",
+        "_id": "6893eb1efffd7a32515e6136"
+      },
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 1,
+        "createdAt": "2025-08-07T03:17:39.701Z",
+        "_id": "68941ad3fffd7a32515e65d4"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:03:28.376Z",
+    "updatedAt": "2025-08-07T03:17:39.707Z",
+    "__v": 4
+  },
+  {
+    "_id": "6893e129fffd7a32515e598a",
+    "sourceTextId": "6890c5676f4532c7d2f0f88c",
+    "userId": "4a2e687e4f763331dda9bdd4",
+    "username": "Han Heyang",
+    "groupNumber": 3,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "PIPCO PETS - 狗狗内置背带羽绒夹克｜防水防风冬季背心-带牵引绳扣｜极地暖绒填充狗狗冲锋衣\n\n",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "dbd9b0a6d957cd7ba6a39b9a",
+        "rank": 1,
+        "createdAt": "2025-08-06T23:52:30.645Z",
+        "_id": "6893eabefffd7a32515e5fe2"
+      },
+      {
+        "userId": "3132017cf466170455c5518c",
+        "rank": 2,
+        "createdAt": "2025-08-06T23:53:11.449Z",
+        "_id": "6893eae7fffd7a32515e6043"
+      },
+      {
+        "userId": "36222902424b6b5e2a2d5177",
+        "rank": 3,
+        "createdAt": "2025-08-06T23:54:18.308Z",
+        "_id": "6893eb2afffd7a32515e6159"
+      },
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 2,
+        "createdAt": "2025-08-07T03:17:35.407Z",
+        "_id": "68941acffffd7a32515e65bb"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:11:37.368Z",
+    "updatedAt": "2025-08-07T03:17:35.409Z",
+    "__v": 6
+  },
+  {
+    "_id": "6893e2ecfffd7a32515e5a19",
+    "sourceTextId": "6890c5676f4532c7d2f0f88e",
+    "userId": "36222902424b6b5e2a2d5177",
+    "username": "You Lianxiang",
+    "groupNumber": 1,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "产品介绍\n完美二合一！保暖外套 + 内置牵引带，一步到位。\n内置牵引带：牵引带与夹克融为一体，坚固的 D 形环可用于固定牵引带。\n日常便捷：寒冬带毛孩子出门？无需再给它层层叠穿或费力将牵引带穿过外套孔洞，穿上我们的外套，一拉（拉链）、一扣（牵引绳）、马上出发！",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 2,
+        "createdAt": "2025-08-07T04:59:02.940Z",
+        "_id": "68943296fffd7a32515e6bd3"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:19:08.840Z",
+    "updatedAt": "2025-08-07T04:59:02.940Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e495fffd7a32515e5ab9",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ee7",
+    "userId": "36222902424b6b5e2a2d5177",
+    "username": "You Lianxiang",
+    "groupNumber": 1,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "超暖呵护：舒适绗缝设计 + 柔软摇粒绒内衬，让狗狗时刻温暖又自在",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 1,
+        "createdAt": "2025-08-07T05:01:28.660Z",
+        "_id": "68943328fffd7a32515e6c83"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:26:13.393Z",
+    "updatedAt": "2025-08-07T05:01:28.661Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e4b1fffd7a32515e5ac0",
+    "sourceTextId": "6890c5676f4532c7d2f0f88e",
+    "userId": "4a2e687e4f763331dda9bdd4",
+    "username": "Han Heyang",
+    "groupNumber": 3,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "产品描述\n外套与牵引一体设计，完美二合一！\n内置式牵引装置\n牵引绳固定环直接集成在外套中，配有结实的 D 型金属环，方便连接牵引绳，出门更省心。\n日常出行更方便\n天气寒冷，还在把毛孩子包成粽子或费劲地穿牵引绳？\n这款外套帮你轻松搞定！只需拉拉链，扣牵引，马上出发！\n",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 1,
+        "createdAt": "2025-08-07T04:59:04.673Z",
+        "_id": "68943298fffd7a32515e6c26"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:26:41.181Z",
+    "updatedAt": "2025-08-07T04:59:04.674Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e4e2fffd7a32515e5ad8",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51eea",
+    "userId": "36222902424b6b5e2a2d5177",
+    "username": "You Lianxiang",
+    "groupNumber": 1,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "防风防水外层*，为您的爱犬提供抵御寒风细雨的保护",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 3,
+        "createdAt": "2025-08-07T05:02:14.640Z",
+        "_id": "68943356fffd7a32515e6cde"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:27:30.197Z",
+    "updatedAt": "2025-08-07T05:02:14.641Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e533fffd7a32515e5b01",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ee7",
+    "userId": "4a2e687e4f763331dda9bdd4",
+    "username": "Han Heyang",
+    "groupNumber": 3,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "超柔软绗缝设计搭配抓绒内衬，为狗狗带来满满温暖感！",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 3,
+        "createdAt": "2025-08-07T05:01:27.327Z",
+        "_id": "68943327fffd7a32515e6c52"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:28:51.569Z",
+    "updatedAt": "2025-08-07T05:01:27.328Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e561fffd7a32515e5b88",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51eed",
+    "userId": "36222902424b6b5e2a2d5177",
+    "username": "You Lianxiang",
+    "groupNumber": 1,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "防夹挡片保护您的爱犬免受风雨侵扰",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 3,
+        "createdAt": "2025-08-07T05:03:03.380Z",
+        "_id": "68943387fffd7a32515e6d73"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:29:37.759Z",
+    "updatedAt": "2025-08-07T05:03:03.381Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e569fffd7a32515e5bd9",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51eea",
+    "userId": "4a2e687e4f763331dda9bdd4",
+    "username": "Han Heyang",
+    "groupNumber": 3,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "防风防水外层，有效抵挡寒风与细雨，让爱犬冬日出行无忧。",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 1,
+        "createdAt": "2025-08-07T05:02:16.338Z",
+        "_id": "68943358fffd7a32515e6d12"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:29:45.280Z",
+    "updatedAt": "2025-08-07T05:02:16.339Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e5aafffd7a32515e5bf3",
+    "sourceTextId": "6890c5676f4532c7d2f0f88c",
+    "userId": "779501db783372d27c41e31e",
+    "username": "Li Wenhui",
+    "groupNumber": 2,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "PIPCO-PETS宠物用品- 内置胸背带的小狗羽绒背心｜防水，防风 附牵引绳扣冬季背心｜保暖摇粒绒加厚狗用挡风外套\n\n",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "dbd9b0a6d957cd7ba6a39b9a",
+        "rank": 3,
+        "createdAt": "2025-08-06T23:52:38.321Z",
+        "_id": "6893eac6fffd7a32515e5ff1"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:30:50.978Z",
+    "updatedAt": "2025-08-06T23:52:38.322Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e66afffd7a32515e5c20",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51eed",
+    "userId": "4a2e687e4f763331dda9bdd4",
+    "username": "Han Heyang",
+    "groupNumber": 3,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "贴心挡风片设计，防止风雨通过拉链渗入。",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 2,
+        "createdAt": "2025-08-07T05:03:04.407Z",
+        "_id": "68943388fffd7a32515e6d77"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:34:02.512Z",
+    "updatedAt": "2025-08-07T05:03:04.408Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e66efffd7a32515e5c27",
+    "sourceTextId": "6890c5676f4532c7d2f0f88e",
+    "userId": "779501db783372d27c41e31e",
+    "username": "Li Wenhui",
+    "groupNumber": 2,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "产品描述——这是一件完美契合外套与胸背带的二合一狗狗夹克｜内置胸背带与马甲融为一体，配有坚固的 D 型环用于系遛狗绳｜轻装上阵。\n想和在寒冷的冬天和毛孩子出门吗？只要穿上我们的马甲，一拉，一扣，即刻出发！省下给狗狗“一层又一层或在袖管间穿插安装胸背带的烦恼 。\n\n",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:34:06.910Z",
+    "updatedAt": "2025-08-06T23:53:14.454Z",
+    "__v": 0
+  },
+  {
+    "_id": "6893e69cfffd7a32515e5c53",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ef0",
+    "userId": "36222902424b6b5e2a2d5177",
+    "username": "You Lianxiang",
+    "groupNumber": 1,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "安全牵引绳设计\n有别于普通牵引带易被爱宠扯断的设计，我们坚固的牵引系统贯穿外套内部，环绕狗狗全身形成保护圈，全方位守护毛孩子安全，让您安心无忧。",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 3,
+        "createdAt": "2025-08-07T05:32:28.363Z",
+        "_id": "68943a6cfffd7a32515e6f1f"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:34:52.402Z",
+    "updatedAt": "2025-08-07T05:32:28.364Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e69ffffd7a32515e5c5a",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ee7",
+    "userId": "779501db783372d27c41e31e",
+    "username": "Li Wenhui",
+    "groupNumber": 2,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "剪裁超舒适，软绒衬里，温暖又贴身。",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 2,
+        "createdAt": "2025-08-07T05:01:28.041Z",
+        "_id": "68943328fffd7a32515e6c55"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:34:55.465Z",
+    "updatedAt": "2025-08-07T05:01:28.042Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e6d3fffd7a32515e5c94",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51eea",
+    "userId": "779501db783372d27c41e31e",
+    "username": "Li Wenhui",
+    "groupNumber": 2,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "防风防水*的材质可保护您的爱犬免受风寒和小雨的侵蚀。",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 2,
+        "createdAt": "2025-08-07T05:02:15.351Z",
+        "_id": "68943357fffd7a32515e6ce1"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:35:47.298Z",
+    "updatedAt": "2025-08-07T05:02:15.352Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e6dffffd7a32515e5c9b",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ef3",
+    "userId": "36222902424b6b5e2a2d5177",
+    "username": "You Lianxiang",
+    "groupNumber": 1,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "两种时尚颜色可选",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:35:59.944Z",
+    "updatedAt": "2025-08-06T23:35:59.944Z",
+    "__v": 0
+  },
+  {
+    "_id": "6893e708fffd7a32515e5cb3",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ef6",
+    "userId": "36222902424b6b5e2a2d5177",
+    "username": "You Lianxiang",
+    "groupNumber": 1,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "重要的事情说三遍!\n冬天也可保持舒适！",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:36:40.211Z",
+    "updatedAt": "2025-08-06T23:36:40.211Z",
+    "__v": 0
+  },
+  {
+    "_id": "6893e755fffd7a32515e5cdc",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51eed",
+    "userId": "779501db783372d27c41e31e",
+    "username": "Li Wenhui",
+    "groupNumber": 2,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "拉链具有挡片设计为狗狗挡风防水。",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:37:57.682Z",
+    "updatedAt": "2025-08-06T23:37:57.682Z",
+    "__v": 0
+  },
+  {
+    "_id": "6893e78cfffd7a32515e5ce7",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ef0",
+    "userId": "779501db783372d27c41e31e",
+    "username": "Li Wenhui",
+    "groupNumber": 2,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "\"牢固的内置胸背带设计\n与一些狗狗一扯就会断掉的胸背带不同，我们坚实牢固的胸背带穿过马甲包裹着狗狗的身体，让狗狗的安全得到保障。“",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 2,
+        "createdAt": "2025-08-07T05:32:28.871Z",
+        "_id": "68943a6cfffd7a32515e6f24"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:38:52.700Z",
+    "updatedAt": "2025-08-07T05:32:28.872Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e793fffd7a32515e5cee",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ef9",
+    "userId": "36222902424b6b5e2a2d5177",
+    "username": "You Lianxiang",
+    "groupNumber": 1,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "寒冬漫步...",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:38:59.432Z",
+    "updatedAt": "2025-08-06T23:38:59.432Z",
+    "__v": 0
+  },
+  {
+    "_id": "6893e7c1fffd7a32515e5d26",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ef3",
+    "userId": "779501db783372d27c41e31e",
+    "username": "Li Wenhui",
+    "groupNumber": 2,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "两款时尚颜色供您选择。",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 1,
+        "createdAt": "2025-08-07T03:38:23.004Z",
+        "_id": "68941faffffd7a32515e6757"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:39:45.761Z",
+    "updatedAt": "2025-08-07T03:38:23.008Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e7f4fffd7a32515e5d4f",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51efc",
+    "userId": "36222902424b6b5e2a2d5177",
+    "username": "You Lianxiang",
+    "groupNumber": 1,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "或在寒冷的天气放松一下...",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "36222902424b6b5e2a2d5177",
+        "rank": 1,
+        "createdAt": "2025-08-06T23:55:41.051Z",
+        "_id": "6893eb7dfffd7a32515e61ce"
+      },
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 1,
+        "createdAt": "2025-08-07T03:30:25.865Z",
+        "_id": "68941dd1fffd7a32515e66fd"
+      },
+      {
+        "userId": "dbd9b0a6d957cd7ba6a39b9a",
+        "rank": 2,
+        "createdAt": "2025-08-07T09:52:49.236Z",
+        "_id": "68947771fffd7a32515ea260"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:40:36.768Z",
+    "updatedAt": "2025-08-07T09:52:49.237Z",
+    "__v": 3
+  },
+  {
+    "_id": "6893e80ffffd7a32515e5d67",
+    "sourceTextId": "6890c6b2e6b9f36dd5b51eff",
+    "userId": "36222902424b6b5e2a2d5177",
+    "username": "You Lianxiang",
+    "groupNumber": 1,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "有我们“罩着”您！",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "36222902424b6b5e2a2d5177",
+        "rank": 1,
+        "createdAt": "2025-08-06T23:56:28.867Z",
+        "_id": "6893ebacfffd7a32515e6279"
+      },
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 2,
+        "createdAt": "2025-08-07T03:49:27.432Z",
+        "_id": "68942247fffd7a32515e679a"
+      },
+      {
+        "userId": "dbd9b0a6d957cd7ba6a39b9a",
+        "rank": 1,
+        "createdAt": "2025-08-07T09:53:02.157Z",
+        "_id": "6894777efffd7a32515ea2d9"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:41:03.344Z",
+    "updatedAt": "2025-08-07T09:53:02.158Z",
+    "__v": 3
+  },
+  {
+    "_id": "6893e86efffd7a32515e5da1",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ef0",
+    "userId": "4a2e687e4f763331dda9bdd4",
+    "username": "Han Heyang",
+    "groupNumber": 3,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "安全一体式背带设计\n不同于普通款式，我们的背带牢牢地固定在外套上，不容易被拉扯撕裂，环绕狗狗全身，放心牵引不担心！\n",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 1,
+        "createdAt": "2025-08-07T05:32:29.637Z",
+        "_id": "68943a6dfffd7a32515e6f8d"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:42:38.618Z",
+    "updatedAt": "2025-08-07T05:32:29.637Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e887fffd7a32515e5db9",
+    "sourceTextId": "6890c6b2e6b9f36dd5b51eff",
+    "userId": "779501db783372d27c41e31e",
+    "username": "Li Wenhui",
+    "groupNumber": 2,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "都能满足狗狗的保暖需求！",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "36222902424b6b5e2a2d5177",
+        "rank": 3,
+        "createdAt": "2025-08-06T23:56:40.437Z",
+        "_id": "6893ebb8fffd7a32515e629e"
+      },
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 1,
+        "createdAt": "2025-08-07T03:49:28.455Z",
+        "_id": "68942248fffd7a32515e67bd"
+      },
+      {
+        "userId": "dbd9b0a6d957cd7ba6a39b9a",
+        "rank": 2,
+        "createdAt": "2025-08-07T09:53:05.019Z",
+        "_id": "68947781fffd7a32515ea317"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:43:03.564Z",
+    "updatedAt": "2025-08-07T09:53:05.020Z",
+    "__v": 3
+  },
+  {
+    "_id": "6893e8e3fffd7a32515e5de3",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ef3",
+    "userId": "4a2e687e4f763331dda9bdd4",
+    "username": "Han Heyang",
+    "groupNumber": 3,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "两种时尚配色可选，百搭又好看。",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 2,
+        "createdAt": "2025-08-07T03:38:20.297Z",
+        "_id": "68941facfffd7a32515e6738"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:44:35.229Z",
+    "updatedAt": "2025-08-07T03:38:20.298Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e90afffd7a32515e5e48",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ef6",
+    "userId": "779501db783372d27c41e31e",
+    "username": "Li Wenhui",
+    "groupNumber": 2,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "温暖整个冬天！",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 2,
+        "createdAt": "2025-08-07T03:20:08.284Z",
+        "_id": "68941b68fffd7a32515e6603"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:45:14.323Z",
+    "updatedAt": "2025-08-07T03:20:08.285Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e92afffd7a32515e5e4f",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ef9",
+    "userId": "779501db783372d27c41e31e",
+    "username": "Li Wenhui",
+    "groupNumber": 2,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "无论是寒冬散步...",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 2,
+        "createdAt": "2025-08-07T03:59:03.430Z",
+        "_id": "68942487fffd7a32515e67e4"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:45:46.279Z",
+    "updatedAt": "2025-08-07T03:59:03.430Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e930fffd7a32515e5e56",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ef6",
+    "userId": "4a2e687e4f763331dda9bdd4",
+    "username": "Han Heyang",
+    "groupNumber": 3,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "冬日时光尽享舒适。",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 3,
+        "createdAt": "2025-08-07T03:20:02.653Z",
+        "_id": "68941b62fffd7a32515e65eb"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:45:52.118Z",
+    "updatedAt": "2025-08-07T03:20:02.660Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e941fffd7a32515e5e6e",
+    "sourceTextId": "6890c6b2e6b9f36dd5b51f02",
+    "userId": "36222902424b6b5e2a2d5177",
+    "username": "You Lianxiang",
+    "groupNumber": 1,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "温馨提示：\n*我们的耐用舒适面料具有防水功能，可有效抵御细雨，但不适合在暴雨天气使用。\n尽管在小雨天，长时间的防雨可会使衣服表面被浸湿，但请您放心！接触狗狗毛发的一侧不会被雨水渗透！您家的毛孩子会干爽舒适！\n寒冬必备，给爱宠的保暖神器，即刻拥有！",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 3,
+        "createdAt": "2025-08-07T04:03:17.197Z",
+        "_id": "68942585fffd7a32515e684f"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:46:09.224Z",
+    "updatedAt": "2025-08-07T04:03:17.197Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893e967fffd7a32515e5e93",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51efc",
+    "userId": "779501db783372d27c41e31e",
+    "username": "Li Wenhui",
+    "groupNumber": 2,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "还是天冷时宅家放松...",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 2,
+        "createdAt": "2025-08-07T03:30:24.735Z",
+        "_id": "68941dd0fffd7a32515e66e0"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:46:47.239Z",
+    "updatedAt": "2025-08-07T03:30:24.736Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893ea47fffd7a32515e5f58",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51ef9",
+    "userId": "4a2e687e4f763331dda9bdd4",
+    "username": "Han Heyang",
+    "groupNumber": 3,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "无论是寒风中散步，",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 1,
+        "createdAt": "2025-08-07T03:59:04.564Z",
+        "_id": "68942488fffd7a32515e6829"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:50:31.332Z",
+    "updatedAt": "2025-08-07T03:59:04.565Z",
+    "__v": 1
+  },
+  {
+    "_id": "6893ea4bfffd7a32515e5f63",
+    "sourceTextId": "6890c6b1e6b9f36dd5b51efc",
+    "userId": "4a2e687e4f763331dda9bdd4",
+    "username": "Han Heyang",
+    "groupNumber": 3,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "或是即便寒气侵袭，狗狗也能悠闲自得,\n",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "36222902424b6b5e2a2d5177",
+        "rank": 3,
+        "createdAt": "2025-08-06T23:55:51.900Z",
+        "_id": "6893eb87fffd7a32515e61ed"
+      },
+      {
+        "userId": "dbd9b0a6d957cd7ba6a39b9a",
+        "rank": 1,
+        "createdAt": "2025-08-07T09:52:39.479Z",
+        "_id": "68947767fffd7a32515ea225"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:50:35.738Z",
+    "updatedAt": "2025-08-07T09:52:39.485Z",
+    "__v": 2
+  },
+  {
+    "_id": "6893ea55fffd7a32515e5f6a",
+    "sourceTextId": "6890c6b2e6b9f36dd5b51f02",
+    "userId": "779501db783372d27c41e31e",
+    "username": "Li Wenhui",
+    "groupNumber": 2,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "温馨提示：*这款耐用舒适的面料具有防水功能，能在小雨中保护狗狗，但并不适合在暴雨中使用。\n下小雨时，面料表面可能随着时间略显潮湿，但请放心，水分不会渗透至内层——您的狗狗依然能保持干爽！\n>>> 为狗狗保暖从今日做起，快来选购吧！",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "b859743558631947ffa7921b",
+        "rank": 2,
+        "createdAt": "2025-08-07T04:03:19.333Z",
+        "_id": "68942587fffd7a32515e6876"
+      },
+      {
+        "userId": "dbd9b0a6d957cd7ba6a39b9a",
+        "rank": 1,
+        "createdAt": "2025-08-07T09:53:37.578Z",
+        "_id": "689477a1fffd7a32515ea395"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:50:45.440Z",
+    "updatedAt": "2025-08-07T09:53:37.579Z",
+    "__v": 2
+  },
+  {
+    "_id": "6893ea7bfffd7a32515e5f91",
+    "sourceTextId": "6890c6b2e6b9f36dd5b51eff",
+    "userId": "4a2e687e4f763331dda9bdd4",
+    "username": "Han Heyang",
+    "groupNumber": 3,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "这一件就足够！",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:51:23.161Z",
+    "updatedAt": "2025-08-06T23:51:23.162Z",
+    "__v": 0
+  },
+  {
+    "_id": "6893ebecfffd7a32515e6330",
+    "sourceTextId": "6890c6b2e6b9f36dd5b51f02",
+    "userId": "4a2e687e4f763331dda9bdd4",
+    "username": "Han Heyang",
+    "groupNumber": 3,
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "* 外套采用舒适耐用的防水面料，可有效抵御毛毛细雨，但不适用于暴雨天气。在轻微降雨下，表面可能略有潮湿，但不会渗透到内层，狗狗依然保持干爽舒适。\n>>>快给你的狗狗保暖吧！\n",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": true,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [
+      {
+        "userId": "dbd9b0a6d957cd7ba6a39b9a",
+        "rank": 3,
+        "createdAt": "2025-08-07T09:53:40.970Z",
+        "_id": "689477a4fffd7a32515ea415"
+      }
+    ],
+    "feedback": [],
+    "createdAt": "2025-08-06T23:57:32.763Z",
+    "updatedAt": "2025-08-07T09:53:40.971Z",
+    "__v": 1
+  }
+]

backups/complete-backup-2025-08-10T07-59-20-407Z/subtitles.json

@@ -0,0 +1,608 @@
+[
+  {
+    "_id": "689172dded762dabc93d9c51",
+    "segmentId": 1,
+    "startTime": "00:00:00,640",
+    "endTime": "00:00:02,150",
+    "duration": "1s 509.9999999999998ms",
+    "englishText": "Am I a bad person?",
+    "chineseTranslation": "我是坏人吗？",
+    "isProtected": false,
+    "lastModified": "2025-08-05T23:54:19.250Z",
+    "modificationHistory": [
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:00:08.465Z",
+        "reason": "Time code update",
+        "_id": "689173b8fffd7a32515e365c"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:00:40.532Z",
+        "reason": "Time code update",
+        "_id": "689173d8fffd7a32515e3665"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:00:48.610Z",
+        "reason": "Time code update",
+        "_id": "689173e0fffd7a32515e366c"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:01:06.212Z",
+        "reason": "Time code update",
+        "_id": "689173f2fffd7a32515e3675"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:01:15.209Z",
+        "reason": "Time code update",
+        "_id": "689173fbfffd7a32515e3680"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:01:30.182Z",
+        "reason": "Time code update",
+        "_id": "6891740afffd7a32515e368d"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:01:41.243Z",
+        "reason": "Time code update",
+        "_id": "68917415fffd7a32515e369c"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T05:46:35.281Z",
+        "reason": "Translation update",
+        "_id": "68919abbfffd7a32515e44f3"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T23:54:19.250Z",
+        "reason": "Translation update",
+        "_id": "689299abfffd7a32515e52ba"
+      }
+    ],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.213Z",
+    "updatedAt": "2025-08-05T23:54:19.250Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c52",
+    "segmentId": 2,
+    "startTime": "00:00:06,320",
+    "endTime": "00:00:07,700",
+    "duration": "1s 380ms",
+    "englishText": "Tell me. Am I?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T14:23:18.534Z",
+    "modificationHistory": [
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:00:25.265Z",
+        "reason": "Time code update",
+        "_id": "689173c9fffd7a32515e3660"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T14:23:18.534Z",
+        "reason": "Time code update",
+        "_id": "689213d6fffd7a32515e51c1"
+      }
+    ],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.213Z",
+    "updatedAt": "2025-08-05T14:23:18.534Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c53",
+    "segmentId": 3,
+    "startTime": "00:00:08,350",
+    "endTime": "00:00:09,740",
+    "duration": "1s 390.00000000000045ms",
+    "englishText": "I'm single minded.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T14:23:32.282Z",
+    "modificationHistory": [
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T14:23:32.282Z",
+        "reason": "Time code update",
+        "_id": "689213e4fffd7a32515e51c6"
+      }
+    ],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.213Z",
+    "updatedAt": "2025-08-05T14:23:32.282Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c54",
+    "segmentId": 4,
+    "startTime": "00:00:10,300",
+    "endTime": "00:00:11,680",
+    "duration": "1s 379.9999999999991ms",
+    "englishText": "I'm deceptive.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T03:30:30.066Z",
+    "modificationHistory": [
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:30:13.381Z",
+        "reason": "Time code update",
+        "_id": "68917ac5fffd7a32515e373d"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:30:30.066Z",
+        "reason": "Time code update",
+        "_id": "68917ad6fffd7a32515e3742"
+      }
+    ],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.213Z",
+    "updatedAt": "2025-08-05T03:30:30.066Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c55",
+    "segmentId": 5,
+    "startTime": "00:00:12,050",
+    "endTime": "00:00:13,200",
+    "duration": "1s 149.99999999999864ms",
+    "englishText": "I'm obsessive.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T03:30:59.970Z",
+    "modificationHistory": [
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:30:48.091Z",
+        "reason": "Time code update",
+        "_id": "68917ae8fffd7a32515e3747"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:30:59.970Z",
+        "reason": "Time code update",
+        "_id": "68917af3fffd7a32515e374c"
+      }
+    ],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.213Z",
+    "updatedAt": "2025-08-05T03:30:59.970Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c56",
+    "segmentId": 6,
+    "startTime": "00:00:13,780",
+    "endTime": "00:00:14,710",
+    "duration": "0s 930.0000000000015ms",
+    "englishText": "I'm selfish.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-06T00:42:56.551Z",
+    "modificationHistory": [
+      {
+        "action": "update",
+        "timestamp": "2025-08-06T00:42:56.551Z",
+        "reason": "Time code update",
+        "_id": "6892a510fffd7a32515e53d6"
+      }
+    ],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.213Z",
+    "updatedAt": "2025-08-06T00:42:56.552Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c57",
+    "segmentId": 7,
+    "startTime": "00:00:15,120",
+    "endTime": "00:00:17,200",
+    "duration": "2s 80ms",
+    "englishText": "Does that make me a bad person?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-06T00:42:46.574Z",
+    "modificationHistory": [
+      {
+        "action": "update",
+        "timestamp": "2025-08-06T00:42:19.426Z",
+        "reason": "Time code update",
+        "_id": "6892a4ebfffd7a32515e53bf"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-06T00:42:37.867Z",
+        "reason": "Time code update",
+        "_id": "6892a4fdfffd7a32515e53c6"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-06T00:42:46.574Z",
+        "reason": "Time code update",
+        "_id": "6892a506fffd7a32515e53ce"
+      }
+    ],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.213Z",
+    "updatedAt": "2025-08-06T00:42:46.574Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c58",
+    "segmentId": 8,
+    "startTime": "00:00:18,010",
+    "endTime": "00:00:19,660",
+    "duration": "1s 650ms",
+    "englishText": "Am I a bad person?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T02:56:29.206Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.213Z",
+    "updatedAt": "2025-08-05T02:56:29.213Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c59",
+    "segmentId": 9,
+    "startTime": "00:00:20,870",
+    "endTime": "00:00:21,200",
+    "duration": "0s 329.9999999999983ms",
+    "englishText": "Am I?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T03:02:44.633Z",
+    "modificationHistory": [
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:02:31.358Z",
+        "reason": "Time code update",
+        "_id": "68917447fffd7a32515e36a6"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:02:37.977Z",
+        "reason": "Time code update",
+        "_id": "6891744dfffd7a32515e36ab"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:02:44.633Z",
+        "reason": "Time code update",
+        "_id": "68917454fffd7a32515e36b2"
+      }
+    ],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.213Z",
+    "updatedAt": "2025-08-05T03:02:44.633Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c5a",
+    "segmentId": 10,
+    "startTime": "00:00:23,120",
+    "endTime": "00:00:24,390",
+    "duration": "1s 270ms",
+    "englishText": "I have no empathy.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T02:56:29.206Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.214Z",
+    "updatedAt": "2025-08-05T02:56:29.214Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c5b",
+    "segmentId": 11,
+    "startTime": "00:00:25,540",
+    "endTime": "00:00:27,170",
+    "duration": "1s 630ms",
+    "englishText": "I don't respect you.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T02:56:29.207Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.214Z",
+    "updatedAt": "2025-08-05T02:56:29.214Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c5c",
+    "segmentId": 12,
+    "startTime": "00:00:28,550",
+    "endTime": "00:00:29,880",
+    "duration": "1s 330ms",
+    "englishText": "I'm never satisfied.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T02:56:29.207Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.214Z",
+    "updatedAt": "2025-08-05T02:56:29.214Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c5d",
+    "segmentId": 13,
+    "startTime": "00:00:30,440",
+    "endTime": "00:00:33,180",
+    "duration": "2s 740ms",
+    "englishText": "I have an obsession with power.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T02:56:29.207Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.214Z",
+    "updatedAt": "2025-08-05T02:56:29.214Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c5e",
+    "segmentId": 14,
+    "startTime": "00:00:37,850",
+    "endTime": "00:00:38,950",
+    "duration": "1s 100ms",
+    "englishText": "I'm irrational.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T02:56:29.207Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.214Z",
+    "updatedAt": "2025-08-05T02:56:29.214Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c5f",
+    "segmentId": 15,
+    "startTime": "00:00:39,930",
+    "endTime": "00:00:41,520",
+    "duration": "1s 590ms",
+    "englishText": "I have zero remorse.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T02:56:29.207Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.214Z",
+    "updatedAt": "2025-08-05T02:56:29.214Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c60",
+    "segmentId": 16,
+    "startTime": "00:00:41,770",
+    "endTime": "00:00:43,900",
+    "duration": "2s 130ms",
+    "englishText": "I have no sense of compassion.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T02:56:29.207Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.214Z",
+    "updatedAt": "2025-08-05T02:56:29.214Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c61",
+    "segmentId": 17,
+    "startTime": "00:00:44,480",
+    "endTime": "00:00:46,650",
+    "duration": "2s 170ms",
+    "englishText": "I'm delusional. I'm maniacal.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T02:56:29.207Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.214Z",
+    "updatedAt": "2025-08-05T02:56:29.214Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c62",
+    "segmentId": 18,
+    "startTime": "00:00:46,960",
+    "endTime": "00:00:48,980",
+    "duration": "2s 20ms",
+    "englishText": "You think I'm a bad person?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T02:56:29.207Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.214Z",
+    "updatedAt": "2025-08-05T02:56:29.214Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c63",
+    "segmentId": 19,
+    "startTime": "00:00:49,320",
+    "endTime": "00:00:52,500",
+    "duration": "3s 179.99999999999955ms",
+    "englishText": "Tell me. Tell me. Tell me.\nTell me. Am I?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T03:31:16.927Z",
+    "modificationHistory": [
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:31:16.927Z",
+        "reason": "Time code update",
+        "_id": "68917b04fffd7a32515e3751"
+      }
+    ],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.214Z",
+    "updatedAt": "2025-08-05T03:31:16.927Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c64",
+    "segmentId": 20,
+    "startTime": "00:00:52,990",
+    "endTime": "00:00:54,700",
+    "duration": "1s 710.0000000000009ms",
+    "englishText": "I think I'm better than everyone else.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T03:32:49.204Z",
+    "modificationHistory": [
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:31:48.300Z",
+        "reason": "Time code update",
+        "_id": "68917b24fffd7a32515e3755"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:32:00.689Z",
+        "reason": "Time code update",
+        "_id": "68917b30fffd7a32515e375a"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:32:33.635Z",
+        "reason": "Time code update",
+        "_id": "68917b51fffd7a32515e376d"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:32:49.204Z",
+        "reason": "Time code update",
+        "_id": "68917b61fffd7a32515e3776"
+      }
+    ],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.214Z",
+    "updatedAt": "2025-08-05T03:32:49.204Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c65",
+    "segmentId": 21,
+    "startTime": "00:00:55,300",
+    "endTime": "00:00:57,500",
+    "duration": "2s 200.00000000000273ms",
+    "englishText": "I want to take what's yours and never give it back.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T03:32:17.995Z",
+    "modificationHistory": [
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:21:58.147Z",
+        "reason": "Time code update",
+        "_id": "689178d6fffd7a32515e370d"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:22:11.295Z",
+        "reason": "Time code update",
+        "_id": "689178e3fffd7a32515e3712"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:22:19.995Z",
+        "reason": "Time code update",
+        "_id": "689178ebfffd7a32515e3719"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:22:29.207Z",
+        "reason": "Time code update",
+        "_id": "689178f5fffd7a32515e3722"
+      },
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:32:17.995Z",
+        "reason": "Time code update",
+        "_id": "68917b41fffd7a32515e3763"
+      }
+    ],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.214Z",
+    "updatedAt": "2025-08-05T03:32:17.995Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c66",
+    "segmentId": 22,
+    "startTime": "00:00:57,850",
+    "endTime": "00:01:00,640",
+    "duration": "2s 789.9999999999991ms",
+    "englishText": "What's mine is mine and what's yours is mine.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T03:21:43.226Z",
+    "modificationHistory": [
+      {
+        "action": "update",
+        "timestamp": "2025-08-05T03:21:43.226Z",
+        "reason": "Time code update",
+        "_id": "689178c7fffd7a32515e3709"
+      }
+    ],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.214Z",
+    "updatedAt": "2025-08-05T03:21:43.226Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c67",
+    "segmentId": 23,
+    "startTime": "00:01:06,920",
+    "endTime": "00:01:08,290",
+    "duration": "1s 370ms",
+    "englishText": "Am I a bad person?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T02:56:29.208Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.214Z",
+    "updatedAt": "2025-08-05T02:56:29.214Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c68",
+    "segmentId": 24,
+    "startTime": "00:01:08,840",
+    "endTime": "00:01:10,420",
+    "duration": "1s 580ms",
+    "englishText": "Tell me. Am I?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T02:56:29.208Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.214Z",
+    "updatedAt": "2025-08-05T02:56:29.214Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c69",
+    "segmentId": 25,
+    "startTime": "00:01:21,500",
+    "endTime": "00:01:23,650",
+    "duration": "2s 150ms",
+    "englishText": "Does that make me a bad person?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T02:56:29.208Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.214Z",
+    "updatedAt": "2025-08-05T02:56:29.214Z"
+  },
+  {
+    "_id": "689172dded762dabc93d9c6a",
+    "segmentId": 26,
+    "startTime": "00:01:25,060",
+    "endTime": "00:01:26,900",
+    "duration": "1s 840ms",
+    "englishText": "Tell me. Does it?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-05T02:56:29.208Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-05T02:56:29.214Z",
+    "updatedAt": "2025-08-05T02:56:29.214Z"
+  }
+]

backups/complete-backup-2025-08-10T07-59-20-407Z/subtitlesubmissions.json

@@ -0,0 +1 @@
+[]

backups/complete-backup-2025-08-10T07-59-20-407Z/users.json

@@ -0,0 +1,24 @@
+[
+  {
+    "_id": "688f54a81fdede6af7eb6b14",
+    "email": "hongchang.yu@monash.edu",
+    "__v": 0,
+    "createdAt": "2025-08-03T12:23:03.851Z",
+    "lastActive": "2025-08-03T12:23:03.851Z",
+    "password": "$2a$10$jI6X7HdNN/IkHDvo4nIK.OSwxweid1zLhjXLeeaaHGUZjBGcdra0G",
+    "role": "admin",
+    "targetCultures": [],
+    "username": "Tristan"
+  },
+  {
+    "_id": "688f54a81fdede6af7eb6b15",
+    "email": "student@example.com",
+    "__v": 0,
+    "createdAt": "2025-08-03T12:23:04.253Z",
+    "lastActive": "2025-08-03T12:23:04.253Z",
+    "password": "$2a$10$PJhcfgmQqiwdevAhvUg0ZuWZou68C3R00oWO3yNfEN.uQEaT3GT7G",
+    "role": "student",
+    "targetCultures": [],
+    "username": "student"
+  }
+]

backups/releases/release-2025-08-10T10-33-12-791Z/backend-a2c8b99.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7b1392f0b7e4d5aa0f81a2b4b363392c04917473cd7ed60bccbd45643257968
+size 81151584

backups/releases/release-2025-08-10T10-33-12-791Z/db/sourcetexts.json

@@ -0,0 +1,449 @@
+[
+  {
+    "_id": "688eb20e6660d8ead04d5c3f",
+    "title": "Tutorial Task 1",
+    "content": "The early bird catches the worm.",
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "category": "tutorial",
+    "weekNumber": 1,
+    "translationBrief": "Translate this proverb into Chinese, maintaining its cultural meaning.",
+    "difficulty": "beginner",
+    "tags": [],
+    "targetCultures": [],
+    "isActive": true,
+    "usageCount": 0,
+    "averageRating": 0,
+    "ratingCount": 0,
+    "culturalElements": [],
+    "createdAt": "2025-08-03T00:49:18.853Z",
+    "updatedAt": "2025-08-03T00:49:18.853Z",
+    "__v": 0
+  },
+  {
+    "_id": "688eb20e6660d8ead04d5c41",
+    "title": "Tutorial Task 2",
+    "content": "Actions speak louder than words.",
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "category": "tutorial",
+    "weekNumber": 1,
+    "translationBrief": "Translate this saying into Chinese, preserving its idiomatic nature.",
+    "difficulty": "beginner",
+    "tags": [],
+    "targetCultures": [],
+    "isActive": true,
+    "usageCount": 0,
+    "averageRating": 0,
+    "ratingCount": 0,
+    "culturalElements": [],
+    "createdAt": "2025-08-03T00:49:18.856Z",
+    "updatedAt": "2025-08-03T00:49:18.856Z",
+    "__v": 0
+  },
+  {
+    "_id": "688eb20e6660d8ead04d5c43",
+    "title": "Tutorial Task 3",
+    "content": "A picture is worth a thousand words.",
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "category": "tutorial",
+    "weekNumber": 1,
+    "translationBrief": "Translate this expression into Chinese, keeping its metaphorical meaning.",
+    "difficulty": "beginner",
+    "tags": [],
+    "targetCultures": [],
+    "isActive": true,
+    "usageCount": 0,
+    "averageRating": 0,
+    "ratingCount": 0,
+    "culturalElements": [],
+    "createdAt": "2025-08-03T00:49:18.858Z",
+    "updatedAt": "2025-08-03T00:49:18.858Z",
+    "__v": 0
+  },
+  {
+    "_id": "688eb20e6660d8ead04d5c45",
+    "title": "Tutorial Task 1 - Week 2",
+    "content": "A picture is worth a thousand words.",
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "category": "tutorial",
+    "weekNumber": 2,
+    "translationBrief": "Translate this saying into Chinese, considering the visual context of the image.",
+    "imageUrl": "https://images.unsplash.com/photo-1506905925346-21bda4d32df4?w=800&h=600&fit=crop",
+    "imageAlt": "A beautiful landscape photograph showing mountains and lake",
+    "difficulty": "intermediate",
+    "tags": [],
+    "targetCultures": [],
+    "isActive": true,
+    "usageCount": 0,
+    "averageRating": 0,
+    "ratingCount": 0,
+    "culturalElements": [],
+    "createdAt": "2025-08-03T00:49:18.861Z",
+    "updatedAt": "2025-08-03T00:49:18.861Z",
+    "__v": 0
+  },
+  {
+    "_id": "688eb20e6660d8ead04d5c47",
+    "title": "Tutorial Task 2 - Week 2",
+    "content": "The early bird catches the worm.",
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "category": "tutorial",
+    "weekNumber": 2,
+    "translationBrief": "Translate this proverb into Chinese, considering the visual elements in the image.",
+    "imageUrl": "https://images.unsplash.com/photo-1444464666168-49d633b86797?w=800&h=600&fit=crop",
+    "imageAlt": "A bird perched on a branch during sunrise",
+    "difficulty": "intermediate",
+    "tags": [],
+    "targetCultures": [],
+    "isActive": true,
+    "usageCount": 0,
+    "averageRating": 0,
+    "ratingCount": 0,
+    "culturalElements": [],
+    "createdAt": "2025-08-03T00:49:18.863Z",
+    "updatedAt": "2025-08-03T00:49:18.863Z",
+    "__v": 0
+  },
+  {
+    "_id": "688eb20e6660d8ead04d5c49",
+    "title": "Tutorial Task 3 - Week 2",
+    "content": "Actions speak louder than words.",
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "category": "tutorial",
+    "weekNumber": 2,
+    "translationBrief": "Translate this saying into Chinese, considering the visual context provided.",
+    "imageUrl": "https://images.unsplash.com/photo-1557804506-669a67965ba0?w=800&h=600&fit=crop",
+    "imageAlt": "People working together in a collaborative environment",
+    "difficulty": "intermediate",
+    "tags": [],
+    "targetCultures": [],
+    "isActive": true,
+    "usageCount": 0,
+    "averageRating": 0,
+    "ratingCount": 0,
+    "culturalElements": [],
+    "createdAt": "2025-08-03T00:49:18.864Z",
+    "updatedAt": "2025-08-03T00:49:18.864Z",
+    "__v": 0
+  },
+  {
+    "_id": "688eb20e6660d8ead04d5c4b",
+    "title": "Week 1 Practice 1",
+    "content": "为什么睡前一定要吃夜宵？因为这样才不会做饿梦。",
+    "sourceLanguage": "Chinese",
+    "sourceType": "manual",
+    "category": "weekly-practice",
+    "weekNumber": 1,
+    "translationBrief": "Translate this humorous Chinese text into English, maintaining its wordplay and cultural humor.",
+    "difficulty": "intermediate",
+    "tags": [],
+    "targetCultures": [],
+    "isActive": true,
+    "usageCount": 0,
+    "averageRating": 0,
+    "ratingCount": 0,
+    "culturalElements": [],
+    "createdAt": "2025-08-03T00:49:18.866Z",
+    "updatedAt": "2025-08-03T00:49:18.866Z",
+    "__v": 0
+  },
+  {
+    "_id": "688eb20e6660d8ead04d5c4d",
+    "title": "Week 1 Practice 2",
+    "content": "女娲用什么补天？强扭的瓜。",
+    "sourceLanguage": "Chinese",
+    "sourceType": "manual",
+    "category": "weekly-practice",
+    "weekNumber": 1,
+    "translationBrief": "Translate this Chinese riddle into English, preserving its clever wordplay.",
+    "difficulty": "intermediate",
+    "tags": [],
+    "targetCultures": [],
+    "isActive": true,
+    "usageCount": 0,
+    "averageRating": 0,
+    "ratingCount": 0,
+    "culturalElements": [],
+    "createdAt": "2025-08-03T00:49:18.868Z",
+    "updatedAt": "2025-08-03T00:49:18.868Z",
+    "__v": 0
+  },
+  {
+    "_id": "688eb20e6660d8ead04d5c4f",
+    "title": "Week 1 Practice 3",
+    "content": "你知道如何区分真假大象吗？把他们仍进水中，真相会浮出水面的。",
+    "sourceLanguage": "Chinese",
+    "sourceType": "manual",
+    "category": "weekly-practice",
+    "weekNumber": 1,
+    "translationBrief": "Translate this Chinese joke into English, maintaining its pun and humor.",
+    "difficulty": "intermediate",
+    "tags": [],
+    "targetCultures": [],
+    "isActive": true,
+    "usageCount": 0,
+    "averageRating": 0,
+    "ratingCount": 0,
+    "culturalElements": [],
+    "createdAt": "2025-08-03T00:49:18.869Z",
+    "updatedAt": "2025-08-03T00:49:18.869Z",
+    "__v": 0
+  },
+  {
+    "_id": "688eb20e6660d8ead04d5c51",
+    "title": "Week 1 Practice 4",
+    "content": "What if Soy milk is just regular milk introducing itself in Spanish.",
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "category": "weekly-practice",
+    "weekNumber": 1,
+    "translationBrief": "Translate this English joke into Chinese, preserving its linguistic humor.",
+    "difficulty": "intermediate",
+    "tags": [],
+    "targetCultures": [],
+    "isActive": true,
+    "usageCount": 0,
+    "averageRating": 0,
+    "ratingCount": 0,
+    "culturalElements": [],
+    "createdAt": "2025-08-03T00:49:18.870Z",
+    "updatedAt": "2025-08-03T00:49:18.870Z",
+    "__v": 0
+  },
+  {
+    "_id": "688eb20e6660d8ead04d5c53",
+    "title": "Week 1 Practice 5",
+    "content": "I can't believe I got fired from the calendar factory. All I did was take a day off.",
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "category": "weekly-practice",
+    "weekNumber": 1,
+    "translationBrief": "Translate this English joke into Chinese, maintaining its wordplay humor.",
+    "difficulty": "intermediate",
+    "tags": [],
+    "targetCultures": [],
+    "isActive": true,
+    "usageCount": 0,
+    "averageRating": 0,
+    "ratingCount": 0,
+    "culturalElements": [],
+    "createdAt": "2025-08-03T00:49:18.871Z",
+    "updatedAt": "2025-08-03T00:49:18.871Z",
+    "__v": 0
+  },
+  {
+    "_id": "688eb20e6660d8ead04d5c55",
+    "title": "Week 1 Practice 6",
+    "content": "When life gives you melons, you might be dyslexic.",
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "category": "weekly-practice",
+    "weekNumber": 1,
+    "translationBrief": "Translate this English wordplay into Chinese, preserving its linguistic cleverness.",
+    "difficulty": "intermediate",
+    "tags": [],
+    "targetCultures": [],
+    "isActive": true,
+    "usageCount": 0,
+    "averageRating": 0,
+    "ratingCount": 0,
+    "culturalElements": [],
+    "createdAt": "2025-08-03T00:49:18.872Z",
+    "updatedAt": "2025-08-03T00:49:18.872Z",
+    "__v": 0
+  },
+  {
+    "_id": "688eb20e6660d8ead04d5c57",
+    "title": "Week 2 Practice: Marketing Adaptation",
+    "content": "Adapt this product description: \"Revolutionary technology that changes everything\" for a skeptical audience.",
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "category": "weekly-practice",
+    "weekNumber": 2,
+    "translationBrief": "Make this claim more credible and less hyperbolic for a skeptical, evidence-based audience.",
+    "difficulty": "intermediate",
+    "tags": [],
+    "targetCultures": [],
+    "isActive": true,
+    "usageCount": 0,
+    "averageRating": 0,
+    "ratingCount": 0,
+    "culturalElements": [],
+    "createdAt": "2025-08-03T00:49:18.873Z",
+    "updatedAt": "2025-08-03T13:16:38.390Z",
+    "__v": 0
+  },
+  {
+    "_id": "688eb20e6660d8ead04d5c59",
+    "title": "Week 3 Practice: Emotional Translation",
+    "content": "Translate this emotional expression: \"I am so happy\" for different cultural contexts where emotional expression varies.",
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "category": "weekly-practice",
+    "weekNumber": 3,
+    "translationBrief": "Adapt this expression for cultures that value emotional restraint and those that encourage emotional expression.",
+    "difficulty": "intermediate",
+    "tags": [],
+    "targetCultures": [],
+    "isActive": true,
+    "usageCount": 0,
+    "averageRating": 0,
+    "ratingCount": 0,
+    "culturalElements": [],
+    "createdAt": "2025-08-03T00:49:18.875Z",
+    "updatedAt": "2025-08-03T13:16:38.392Z",
+    "__v": 0
+  },
+  {
+    "_id": "688eb20e6660d8ead04d5c5b",
+    "title": "Week 4 Practice: Humor Translation",
+    "content": "Adapt this joke: \"Why did the chicken cross the road? To get to the other side!\" for a culture that doesn't have this idiom.",
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "category": "weekly-practice",
+    "weekNumber": 4,
+    "translationBrief": "Create a culturally appropriate version that maintains the humor while being accessible to the target culture.",
+    "difficulty": "intermediate",
+    "tags": [],
+    "targetCultures": [],
+    "isActive": true,
+    "usageCount": 0,
+    "averageRating": 0,
+    "ratingCount": 0,
+    "culturalElements": [],
+    "createdAt": "2025-08-03T00:49:18.876Z",
+    "updatedAt": "2025-08-03T13:16:38.393Z",
+    "__v": 0
+  },
+  {
+    "_id": "688eb20e6660d8ead04d5c5d",
+    "title": "Week 5 Practice: Formal vs Informal",
+    "content": "Translate this business communication: \"We would appreciate your prompt response\" for different formality levels.",
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "category": "weekly-practice",
+    "weekNumber": 5,
+    "translationBrief": "Create versions for very formal, moderately formal, and casual business contexts.",
+    "difficulty": "intermediate",
+    "tags": [],
+    "targetCultures": [],
+    "isActive": true,
+    "usageCount": 0,
+    "averageRating": 0,
+    "ratingCount": 0,
+    "culturalElements": [],
+    "createdAt": "2025-08-03T00:49:18.877Z",
+    "updatedAt": "2025-08-03T13:16:38.395Z",
+    "__v": 0
+  },
+  {
+    "_id": "688eb20e6660d8ead04d5c5f",
+    "title": "Week 6 Practice: Cultural Values",
+    "content": "Adapt this value statement: \"Success comes from hard work\" for cultures with different views on success and work.",
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "category": "weekly-practice",
+    "weekNumber": 6,
+    "translationBrief": "Consider cultures that value collaboration over individual achievement, and those that emphasize luck or fate.",
+    "difficulty": "intermediate",
+    "tags": [],
+    "targetCultures": [],
+    "isActive": true,
+    "usageCount": 0,
+    "averageRating": 0,
+    "ratingCount": 0,
+    "culturalElements": [],
+    "createdAt": "2025-08-03T00:49:18.878Z",
+    "updatedAt": "2025-08-03T13:16:38.396Z",
+    "__v": 0
+  },
+  {
+    "_id": "688f6136478f8e71297262a5",
+    "category": "tutorial",
+    "title": "Cultural Adaptation Exercise",
+    "weekNumber": 1,
+    "__v": 0,
+    "averageRating": 0,
+    "content": "Translate the following marketing slogan for a Western audience: \"Our product brings harmony to your life.\" Consider cultural differences in how harmony is perceived.",
+    "createdAt": "2025-08-03T13:16:38.377Z",
+    "culturalElements": [],
+    "difficulty": "intermediate",
+    "isActive": true,
+    "ratingCount": 0,
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "tags": [],
+    "targetCultures": [],
+    "translationBrief": "Adapt this slogan for a Western audience, focusing on individualism and personal achievement rather than collective harmony.",
+    "updatedAt": "2025-08-03T13:16:38.377Z",
+    "usageCount": 0
+  },
+  {
+    "_id": "688f6136478f8e71297262a6",
+    "weekNumber": 1,
+    "title": "Localization Challenge",
+    "category": "tutorial",
+    "__v": 0,
+    "averageRating": 0,
+    "content": "Adapt this restaurant menu item: \"Spicy Dragon Noodles\" for a conservative American audience.",
+    "createdAt": "2025-08-03T13:16:38.384Z",
+    "culturalElements": [],
+    "difficulty": "intermediate",
+    "isActive": true,
+    "ratingCount": 0,
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "tags": [],
+    "targetCultures": [],
+    "translationBrief": "Make this dish more appealing to conservative American diners who might be unfamiliar with Asian cuisine.",
+    "updatedAt": "2025-08-03T13:16:38.384Z",
+    "usageCount": 0
+  },
+  {
+    "_id": "688f6136478f8e71297262a7",
+    "weekNumber": 1,
+    "title": "Brand Voice Translation",
+    "category": "tutorial",
+    "__v": 0,
+    "averageRating": 0,
+    "content": "Translate this luxury brand tagline: \"Excellence in every detail\" for a younger, more casual audience.",
+    "createdAt": "2025-08-03T13:16:38.386Z",
+    "culturalElements": [],
+    "difficulty": "intermediate",
+    "isActive": true,
+    "ratingCount": 0,
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "tags": [],
+    "targetCultures": [],
+    "translationBrief": "Maintain the premium feel while making it more accessible and relatable to younger consumers.",
+    "updatedAt": "2025-08-03T13:16:38.386Z",
+    "usageCount": 0
+  },
+  {
+    "_id": "688f6136478f8e71297262a8",
+    "category": "weekly-practice",
+    "title": "Week 1 Practice: Cultural Nuances",
+    "weekNumber": 1,
+    "__v": 0,
+    "averageRating": 0,
+    "content": "Translate this greeting: \"How are you?\" for different cultural contexts. Consider formality levels and cultural expectations.",
+    "createdAt": "2025-08-03T13:16:38.388Z",
+    "culturalElements": [],
+    "difficulty": "intermediate",
+    "isActive": true,
+    "ratingCount": 0,
+    "sourceLanguage": "English",
+    "sourceType": "manual",
+    "tags": [],
+    "targetCultures": [],
+    "translationBrief": "Adapt this greeting for formal business settings, casual social situations, and family contexts.",
+    "updatedAt": "2025-08-03T13:16:38.388Z",
+    "usageCount": 0
+  }
+]

backups/releases/release-2025-08-10T10-33-12-791Z/db/submissions.json

@@ -0,0 +1,56 @@
+[
+  {
+    "_id": "688821c4bd12424220ef62bf",
+    "sourceTextId": "68876bc88b4948b8d901fb71",
+    "userId": "61fed5b42908334dcf885324",
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "Why raid the fridge right before lights-out? Because if you skip it, sweet dreams turn into bite-mares.",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": false,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [],
+    "feedback": [],
+    "createdAt": "2025-07-29T01:20:04.973Z",
+    "updatedAt": "2025-07-29T01:20:04.977Z",
+    "__v": 0
+  },
+  {
+    "_id": "688821d7bd12424220ef62c6",
+    "sourceTextId": "68876bc88b4948b8d901fb72",
+    "userId": "61fed5b42908334dcf885324",
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "What did the goddess Nuwa use to plug the hole in the sky? A square peg—because even a deity sometimes “fixes” a round hole the hard way.",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": false,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [],
+    "feedback": [],
+    "createdAt": "2025-07-29T01:20:23.396Z",
+    "updatedAt": "2025-07-29T01:20:23.397Z",
+    "__v": 0
+  },
+  {
+    "_id": "688821debd12424220ef62cd",
+    "sourceTextId": "68876bc88b4948b8d901fb73",
+    "userId": "61fed5b42908334dcf885324",
+    "targetCulture": "Western",
+    "targetLanguage": "English",
+    "transcreation": "How can you tell a real elephant from a fake one? Toss them both in the pool—give it a moment and the ele-fact will float to the top.",
+    "explanation": "Translation submission",
+    "culturalAdaptations": [],
+    "isAnonymous": false,
+    "status": "submitted",
+    "difficulty": "intermediate",
+    "votes": [],
+    "feedback": [],
+    "createdAt": "2025-07-29T01:20:30.502Z",
+    "updatedAt": "2025-07-29T01:20:30.502Z",
+    "__v": 0
+  }
+]

backups/releases/release-2025-08-10T10-33-12-791Z/db/subtitles.json

@@ -0,0 +1,392 @@
+[
+  {
+    "_id": "6890e04422f0d04331e9caaf",
+    "segmentId": 1,
+    "startTime": "00:00:00,640",
+    "endTime": "00:00:02,400",
+    "duration": "1s 760ms",
+    "englishText": "Am I a bad person?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.464Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.471Z",
+    "updatedAt": "2025-08-04T16:31:00.471Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cab0",
+    "segmentId": 2,
+    "startTime": "00:00:06,320",
+    "endTime": "00:00:07,860",
+    "duration": "1s 540ms",
+    "englishText": "Tell me. Am I?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.465Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cab1",
+    "segmentId": 3,
+    "startTime": "00:00:08,480",
+    "endTime": "00:00:09,740",
+    "duration": "1s 260ms",
+    "englishText": "I'm single minded.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.465Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cab2",
+    "segmentId": 4,
+    "startTime": "00:00:10,570",
+    "endTime": "00:00:11,780",
+    "duration": "1s 210ms",
+    "englishText": "I'm deceptive.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.465Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cab3",
+    "segmentId": 5,
+    "startTime": "00:00:12,050",
+    "endTime": "00:00:13,490",
+    "duration": "1s 440ms",
+    "englishText": "I'm obsessive.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.465Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cab4",
+    "segmentId": 6,
+    "startTime": "00:00:13,780",
+    "endTime": "00:00:14,910",
+    "duration": "1s 130ms",
+    "englishText": "I'm selfish.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.466Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cab5",
+    "segmentId": 7,
+    "startTime": "00:00:15,120",
+    "endTime": "00:00:17,200",
+    "duration": "2s 80ms",
+    "englishText": "Does that make me a bad person?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.466Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cab6",
+    "segmentId": 8,
+    "startTime": "00:00:18,010",
+    "endTime": "00:00:19,660",
+    "duration": "1s 650ms",
+    "englishText": "Am I a bad person?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.466Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cab7",
+    "segmentId": 9,
+    "startTime": "00:00:20,870",
+    "endTime": "00:00:21,870",
+    "duration": "1s 0ms",
+    "englishText": "Am I?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.466Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cab8",
+    "segmentId": 10,
+    "startTime": "00:00:23,120",
+    "endTime": "00:00:24,390",
+    "duration": "1s 270ms",
+    "englishText": "I have no empathy.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.466Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cab9",
+    "segmentId": 11,
+    "startTime": "00:00:25,540",
+    "endTime": "00:00:27,170",
+    "duration": "1s 630ms",
+    "englishText": "I don't respect you.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.466Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9caba",
+    "segmentId": 12,
+    "startTime": "00:00:28,550",
+    "endTime": "00:00:29,880",
+    "duration": "1s 330ms",
+    "englishText": "I'm never satisfied.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.467Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cabb",
+    "segmentId": 13,
+    "startTime": "00:00:30,440",
+    "endTime": "00:00:33,180",
+    "duration": "2s 740ms",
+    "englishText": "I have an obsession with power.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.467Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cabc",
+    "segmentId": 14,
+    "startTime": "00:00:37,850",
+    "endTime": "00:00:38,950",
+    "duration": "1s 100ms",
+    "englishText": "I'm irrational.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.467Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cabd",
+    "segmentId": 15,
+    "startTime": "00:00:39,930",
+    "endTime": "00:00:41,520",
+    "duration": "1s 590ms",
+    "englishText": "I have zero remorse.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.467Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cabe",
+    "segmentId": 16,
+    "startTime": "00:00:41,770",
+    "endTime": "00:00:43,900",
+    "duration": "2s 130ms",
+    "englishText": "I have no sense of compassion.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.467Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cabf",
+    "segmentId": 17,
+    "startTime": "00:00:44,480",
+    "endTime": "00:00:46,650",
+    "duration": "2s 170ms",
+    "englishText": "I'm delusional. I'm maniacal.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.467Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cac0",
+    "segmentId": 18,
+    "startTime": "00:00:46,960",
+    "endTime": "00:00:48,980",
+    "duration": "2s 20ms",
+    "englishText": "You think I'm a bad person?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.467Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cac1",
+    "segmentId": 19,
+    "startTime": "00:00:49,320",
+    "endTime": "00:00:52,700",
+    "duration": "3s 380ms",
+    "englishText": "Tell me. Tell me. Tell me.\nTell me. Am I?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.467Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cac2",
+    "segmentId": 20,
+    "startTime": "00:00:52,990",
+    "endTime": "00:00:55,136",
+    "duration": "2s 146ms",
+    "englishText": "I think I'm better than everyone else.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.467Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cac3",
+    "segmentId": 21,
+    "startTime": "00:00:55,170",
+    "endTime": "00:00:57,820",
+    "duration": "2s 650ms",
+    "englishText": "I want to take what's yours\nand never give it back.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.467Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.472Z",
+    "updatedAt": "2025-08-04T16:31:00.472Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cac4",
+    "segmentId": 22,
+    "startTime": "00:00:57,840",
+    "endTime": "00:01:00,640",
+    "duration": "2s 800ms",
+    "englishText": "What's mine is mine\nand what's yours is mine.",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.467Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.473Z",
+    "updatedAt": "2025-08-04T16:31:00.473Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cac5",
+    "segmentId": 23,
+    "startTime": "00:01:06,920",
+    "endTime": "00:01:08,290",
+    "duration": "1s 370ms",
+    "englishText": "Am I a bad person?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.467Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.473Z",
+    "updatedAt": "2025-08-04T16:31:00.473Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cac6",
+    "segmentId": 24,
+    "startTime": "00:01:08,840",
+    "endTime": "00:01:10,420",
+    "duration": "1s 580ms",
+    "englishText": "Tell me. Am I?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.468Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.473Z",
+    "updatedAt": "2025-08-04T16:31:00.473Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cac7",
+    "segmentId": 25,
+    "startTime": "00:01:21,500",
+    "endTime": "00:01:23,650",
+    "duration": "2s 150ms",
+    "englishText": "Does that make me a bad person?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.468Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.473Z",
+    "updatedAt": "2025-08-04T16:31:00.473Z"
+  },
+  {
+    "_id": "6890e04422f0d04331e9cac8",
+    "segmentId": 26,
+    "startTime": "00:01:25,060",
+    "endTime": "00:01:26,900",
+    "duration": "1s 840ms",
+    "englishText": "Tell me. Does it?",
+    "chineseTranslation": "",
+    "isProtected": false,
+    "lastModified": "2025-08-04T16:31:00.468Z",
+    "modificationHistory": [],
+    "__v": 0,
+    "createdAt": "2025-08-04T16:31:00.473Z",
+    "updatedAt": "2025-08-04T16:31:00.473Z"
+  }
+]

backups/releases/release-2025-08-10T10-33-12-791Z/db/subtitlesubmissions.json

@@ -0,0 +1 @@
+[]

backups/releases/release-2025-08-10T10-33-12-791Z/db/users.json

@@ -0,0 +1,24 @@
+[
+  {
+    "_id": "688eae46478f8e712972629a",
+    "email": "admin@example.com",
+    "__v": 0,
+    "createdAt": "2025-08-03T00:33:10.838Z",
+    "lastActive": "2025-08-03T00:33:10.838Z",
+    "password": "$2a$10$IDr1Oi6YJA2EaiT6VrFM3OB07m.H0wVypplqv9QSnODe4oz3uvMwm",
+    "role": "admin",
+    "targetCultures": [],
+    "username": "admin"
+  },
+  {
+    "_id": "688eae46478f8e712972629b",
+    "email": "student@example.com",
+    "__v": 0,
+    "createdAt": "2025-08-03T00:33:10.944Z",
+    "lastActive": "2025-08-03T00:33:10.944Z",
+    "password": "$2a$10$S1.tbsA2lEQMtFjWzkBsLuOdllAGvWVSQB6O.FcudbMReHoVTXR/G",
+    "role": "student",
+    "targetCultures": [],
+    "username": "student"
+  }
+]

backups/releases/release-2025-08-10T10-33-12-791Z/frontend-6d6d7c2.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae5267f4cd981c77b481f67a05e56d4a4c4209c382ad63336b84b9df899027a5
+size 69713305

backups/releases/release-2025-08-10T10-33-12-791Z/manifest.json

@@ -0,0 +1,26 @@
+{
+  "createdAt": "2025-08-10T10:33:56.735Z",
+  "tag": "prod-2025-08-10T10-33-12-791Z",
+  "frontend": {
+    "sha": "6d6d7c21d4add826d755ad927b93cb3a4998620f",
+    "branch": "main"
+  },
+  "backend": {
+    "sha": "a2c8b994b45c5578c6d745e9ae63c974ec317bc0",
+    "branch": "main"
+  },
+  "archives": {
+    "frontend": "frontend-6d6d7c2.tar.gz",
+    "backend": "backend-a2c8b99.tar.gz"
+  },
+  "db": {
+    "path": "db",
+    "counts": {
+      "users": 2,
+      "sourcetexts": 21,
+      "submissions": 3,
+      "subtitles": 26,
+      "subtitlesubmissions": 0
+    }
+  }
+}

comprehensive-backup.js

@@ -0,0 +1,350 @@
+const mongoose = require('mongoose');
+const fs = require('fs').promises;
+const path = require('path');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+
+const execAsync = promisify(exec);
+
+// Atlas MongoDB connection string
+const MONGODB_URI = 'mongodb+srv://nothingyu:wSg3lbO1PkHiRMq9@sandbox.ecysggv.mongodb.net/test?retryWrites=true&w=majority&appName=sandbox';
+
+// Connect to MongoDB Atlas
+const connectDB = async () => {
+  try {
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to MongoDB Atlas');
+  } catch (error) {
+    console.error('❌ MongoDB connection error:', error);
+    process.exit(1);
+  }
+};
+
+// Comprehensive Backup System (Data + Code)
+const comprehensiveBackup = {
+  // Create comprehensive backup
+  async createComprehensiveBackup() {
+    try {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupName = `comprehensive-backup-${timestamp}`;
+      
+      console.log(`🚀 Creating comprehensive backup: ${backupName}`);
+      
+      // Create backup directory
+      const backupDir = path.join(__dirname, 'backups', backupName);
+      await fs.mkdir(backupDir, { recursive: true });
+      
+      // 1. BACKUP DATABASE DATA
+      console.log('📊 Backing up database data...');
+      const dbBackup = await this.backupDatabase(backupDir);
+      
+      // 2. BACKUP CODE FILES
+      console.log('💻 Backing up code files...');
+      const codeBackup = await this.backupCodeFiles(backupDir);
+      
+      // 3. BACKUP CONFIGURATION
+      console.log('⚙️ Backing up configuration...');
+      const configBackup = await this.backupConfiguration(backupDir);
+      
+      // 4. CREATE BACKUP MANIFEST
+      console.log('📋 Creating backup manifest...');
+      const manifest = {
+        backupName,
+        timestamp: new Date(),
+        type: 'comprehensive',
+        data: {
+          database: dbBackup,
+          code: codeBackup,
+          configuration: configBackup
+        },
+        totalSize: await this.calculateBackupSize(backupDir),
+        version: '1.0'
+      };
+      
+      await fs.writeFile(path.join(backupDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+      
+      // 5. SAVE BACKUP RECORD TO DATABASE
+      const backupRecord = {
+        backupName,
+        timestamp: new Date(),
+        type: 'comprehensive',
+        location: backupDir,
+        size: manifest.totalSize,
+        status: 'created'
+      };
+      
+      await mongoose.connection.db.collection('backups').insertOne(backupRecord);
+      
+      console.log(`✅ Comprehensive backup created: ${backupName}`);
+      console.log(`📊 Database records: ${dbBackup.totalRecords}`);
+      console.log(`💻 Code files: ${codeBackup.fileCount}`);
+      console.log(`💾 Total size: ${(manifest.totalSize / 1024 / 1024).toFixed(2)} MB`);
+      
+      return backupName;
+      
+    } catch (error) {
+      console.error('❌ Error creating comprehensive backup:', error);
+      throw error;
+    }
+  },
+  
+  // Backup database data
+  async backupDatabase(backupDir) {
+    const collections = ['subtitles', 'sourcetexts', 'submissions', 'users', 'backups'];
+    const dbData = {};
+    let totalRecords = 0;
+    
+    for (const collection of collections) {
+      try {
+        const data = await mongoose.connection.db.collection(collection).find({}).toArray();
+        dbData[collection] = data;
+        totalRecords += data.length;
+        console.log(`  📦 Exported ${data.length} records from ${collection}`);
+      } catch (error) {
+        console.warn(`  ⚠️ Could not export ${collection}:`, error.message);
+      }
+    }
+    
+    const dbBackupPath = path.join(backupDir, 'database.json');
+    await fs.writeFile(dbBackupPath, JSON.stringify(dbData, null, 2));
+    
+    return {
+      totalRecords,
+      collections: Object.keys(dbData),
+      filePath: dbBackupPath
+    };
+  },
+  
+  // Backup code files
+  async backupCodeFiles(backupDir) {
+    const codeDir = path.join(backupDir, 'code');
+    await fs.mkdir(codeDir, { recursive: true });
+    
+    // Define important code directories and files
+    const codePaths = [
+      // Backend code
+      { src: path.join(__dirname), dest: 'backend' },
+      // Frontend code (relative to backend)
+      { src: path.join(__dirname, '../frontend'), dest: 'frontend' },
+      // Root configuration
+      { src: path.join(__dirname, '../../'), dest: 'root' }
+    ];
+    
+    let fileCount = 0;
+    
+    for (const codePath of codePaths) {
+      try {
+        if (await this.pathExists(codePath.src)) {
+          await this.copyDirectory(codePath.src, path.join(codeDir, codePath.dest));
+          const count = await this.countFiles(codePath.src);
+          fileCount += count;
+          console.log(`  💻 Copied ${count} files from ${codePath.dest}`);
+        }
+      } catch (error) {
+        console.warn(`  ⚠️ Could not backup ${codePath.dest}:`, error.message);
+      }
+    }
+    
+    return {
+      fileCount,
+      directories: codePaths.map(p => p.dest),
+      location: codeDir
+    };
+  },
+  
+  // Backup configuration
+  async backupConfiguration(backupDir) {
+    const configDir = path.join(backupDir, 'config');
+    await fs.mkdir(configDir, { recursive: true });
+    
+    const configFiles = [
+      'package.json',
+      'package-lock.json',
+      'Dockerfile',
+      'docker-compose.yml',
+      'nginx.conf',
+      '.gitignore'
+    ];
+    
+    let configCount = 0;
+    
+    for (const configFile of configFiles) {
+      try {
+        const srcPath = path.join(__dirname, configFile);
+        if (await this.pathExists(srcPath)) {
+          const destPath = path.join(configDir, configFile);
+          await fs.copyFile(srcPath, destPath);
+          configCount++;
+          console.log(`  ⚙️ Copied ${configFile}`);
+        }
+      } catch (error) {
+        console.warn(`  ⚠️ Could not copy ${configFile}:`, error.message);
+      }
+    }
+    
+    return {
+      fileCount: configCount,
+      files: configFiles,
+      location: configDir
+    };
+  },
+  
+  // Helper functions
+  async pathExists(path) {
+    try {
+      await fs.access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  
+  async copyDirectory(src, dest) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+      
+      if (entry.isDirectory()) {
+        await this.copyDirectory(srcPath, destPath);
+      } else {
+        await fs.copyFile(srcPath, destPath);
+      }
+    }
+  },
+  
+  async countFiles(dir) {
+    let count = 0;
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      
+      if (entry.isDirectory()) {
+        count += await this.countFiles(fullPath);
+      } else {
+        count++;
+      }
+    }
+    
+    return count;
+  },
+  
+  async calculateBackupSize(backupDir) {
+    const { stdout } = await execAsync(`du -sb "${backupDir}" | cut -f1`);
+    return parseInt(stdout.trim());
+  },
+  
+  // List comprehensive backups
+  async listComprehensiveBackups() {
+    try {
+      console.log('📋 Available comprehensive backups:');
+      
+      const backupCollection = mongoose.connection.db.collection('backups');
+      const backups = await backupCollection.find({ type: 'comprehensive' }).sort({ timestamp: -1 }).toArray();
+      
+      if (backups.length === 0) {
+        console.log('  No comprehensive backups found');
+      } else {
+        backups.forEach(backup => {
+          const date = new Date(backup.timestamp).toLocaleString();
+          const size = (backup.size / 1024 / 1024).toFixed(2);
+          console.log(`  📦 ${backup.backupName} (${size} MB, ${date})`);
+        });
+      }
+      
+    } catch (error) {
+      console.error('❌ Error listing backups:', error);
+    }
+  },
+  
+  // Restore from comprehensive backup
+  async restoreFromBackup(backupName) {
+    try {
+      console.log(`🔄 Restoring from comprehensive backup: ${backupName}`);
+      
+      const backupDir = path.join(__dirname, 'backups', backupName);
+      const manifestPath = path.join(backupDir, 'manifest.json');
+      
+      if (!await this.pathExists(manifestPath)) {
+        throw new Error('Backup manifest not found');
+      }
+      
+      const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+      console.log('📋 Backup manifest:', manifest);
+      
+      // Restore database
+      console.log('📊 Restoring database...');
+      await this.restoreDatabase(backupDir);
+      
+      // Restore code (optional - user confirmation)
+      console.log('💻 Code restoration available');
+      console.log('⚠️ Code restoration will overwrite existing files');
+      console.log('   Run: node restore-code.js <backup-name> to restore code');
+      
+      console.log(`✅ Database restoration completed: ${backupName}`);
+      
+    } catch (error) {
+      console.error('❌ Error restoring from backup:', error);
+    }
+  },
+  
+  // Restore database only
+  async restoreDatabase(backupDir) {
+    const dbBackupPath = path.join(backupDir, 'database.json');
+    const dbData = JSON.parse(await fs.readFile(dbBackupPath, 'utf8'));
+    
+    for (const [collection, data] of Object.entries(dbData)) {
+      try {
+        // Clear existing data
+        await mongoose.connection.db.collection(collection).deleteMany({});
+        
+        // Insert backup data
+        if (data.length > 0) {
+          await mongoose.connection.db.collection(collection).insertMany(data);
+        }
+        
+        console.log(`  ✅ Restored ${data.length} records to ${collection}`);
+      } catch (error) {
+        console.error(`  ❌ Error restoring ${collection}:`, error.message);
+      }
+    }
+  }
+};
+
+// Main function
+const main = async () => {
+  try {
+    console.log('🚀 Starting comprehensive backup system...');
+    
+    // Create comprehensive backup
+    const backupName = await comprehensiveBackup.createComprehensiveBackup();
+    
+    // List backups
+    await comprehensiveBackup.listComprehensiveBackups();
+    
+    console.log('\n🎉 Comprehensive backup system ready!');
+    console.log('\n📋 Available functions:');
+    console.log('  - createComprehensiveBackup(): Backup data + code');
+    console.log('  - listComprehensiveBackups(): List all backups');
+    console.log('  - restoreFromBackup(name): Restore database');
+    console.log('  - restoreCode(name): Restore code files (separate script)');
+    
+    console.log('\n⏰ To set up automated comprehensive backups:');
+    console.log('  1. Add to crontab: 0 2 * * * cd /path/to/backend && node comprehensive-backup.js');
+    console.log('  2. Or run manually: node comprehensive-backup.js');
+    
+  } catch (error) {
+    console.error('❌ Error in comprehensive backup system:', error);
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+};
+
+// Run the system
+connectDB().then(() => {
+  main();
+}); 

create-complete-backup.js

@@ -0,0 +1,192 @@
+const mongoose = require('mongoose');
+const fs = require('fs');
+const path = require('path');
+
+// MongoDB Atlas connection
+const MONGODB_URI = 'mongodb+srv://nothingyu:wSg3lbO1PkHiRMq9@sandbox.ecysggv.mongodb.net/test?retryWrites=true&w=majority&appName=sandbox';
+
+const createCompleteBackup = async () => {
+  try {
+    console.log('🔒 Creating complete backup...');
+    
+    // Connect to MongoDB
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to MongoDB Atlas');
+    
+    // Create backup directory with timestamp
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupDir = path.join(__dirname, 'backups', `complete-backup-${timestamp}`);
+    
+    if (!fs.existsSync(path.dirname(backupDir))) {
+      fs.mkdirSync(path.dirname(backupDir), { recursive: true });
+    }
+    fs.mkdirSync(backupDir, { recursive: true });
+    
+    console.log(`📁 Backup directory: ${backupDir}`);
+    
+    // Collections to backup
+    const collections = [
+      'users',
+      'sourcetexts', 
+      'submissions',
+      'subtitles',
+      'subtitlesubmissions'
+    ];
+    
+    const backupData = {};
+    
+    // Backup each collection
+    for (const collectionName of collections) {
+      console.log(`📦 Backing up ${collectionName}...`);
+      
+      try {
+        const collection = mongoose.connection.db.collection(collectionName);
+        const documents = await collection.find({}).toArray();
+        
+        backupData[collectionName] = documents;
+        
+        // Save to JSON file
+        const filePath = path.join(backupDir, `${collectionName}.json`);
+        fs.writeFileSync(filePath, JSON.stringify(documents, null, 2));
+        
+        console.log(`✅ ${collectionName}: ${documents.length} documents`);
+      } catch (error) {
+        console.log(`⚠️  Warning: Could not backup ${collectionName}: ${error.message}`);
+      }
+    }
+    
+    // Create code backup directory
+    const codeBackupDir = path.join(backupDir, 'code');
+    fs.mkdirSync(codeBackupDir, { recursive: true });
+    
+    // Copy key frontend files
+    const frontendDir = path.join(codeBackupDir, 'frontend');
+    fs.mkdirSync(frontendDir, { recursive: true });
+    
+    const frontendFiles = [
+      '../frontend/client/src/pages/WeeklyPractice.tsx',
+      '../frontend/client/src/pages/TutorialTasks.tsx', 
+      '../frontend/client/src/components/Layout.tsx',
+      '../frontend/client/src/services/api.ts'
+    ];
+    
+    for (const file of frontendFiles) {
+      try {
+        const sourcePath = path.join(__dirname, file);
+        const fileName = path.basename(file);
+        const destPath = path.join(frontendDir, fileName);
+        
+        if (fs.existsSync(sourcePath)) {
+          fs.copyFileSync(sourcePath, destPath);
+          console.log(`📄 Copied frontend: ${fileName}`);
+        }
+      } catch (error) {
+        console.log(`⚠️  Warning: Could not copy ${file}: ${error.message}`);
+      }
+    }
+    
+    // Copy key backend files
+    const backendDir = path.join(codeBackupDir, 'backend');
+    fs.mkdirSync(backendDir, { recursive: true });
+    
+    const backendFiles = [
+      'index.js',
+      'routes/auth.js',
+      'routes/subtitles.js',
+      'routes/subtitleSubmissions.js',
+      'models/SourceText.js',
+      'models/Subtitle.js',
+      'models/SubtitleSubmission.js',
+      'seed-atlas-subtitles.js',
+      'seed-subtitle-submissions.js'
+    ];
+    
+    for (const file of backendFiles) {
+      try {
+        const sourcePath = path.join(__dirname, file);
+        const destPath = path.join(backendDir, file);
+        
+        if (fs.existsSync(sourcePath)) {
+          // Create subdirectories if needed
+          const destDir = path.dirname(destPath);
+          if (!fs.existsSync(destDir)) {
+            fs.mkdirSync(destDir, { recursive: true });
+          }
+          
+          fs.copyFileSync(sourcePath, destPath);
+          console.log(`📄 Copied backend: ${file}`);
+        }
+      } catch (error) {
+        console.log(`⚠️  Warning: Could not copy ${file}: ${error.message}`);
+      }
+    }
+    
+    // Create manifest
+    const manifest = {
+      backupInfo: {
+        timestamp: new Date().toISOString(),
+        backupType: 'Complete Backup',
+        description: 'Full backup including database collections and key code files',
+        version: '1.0'
+      },
+      database: {
+        collections: collections,
+        totalDocuments: Object.values(backupData).reduce((sum, docs) => sum + docs.length, 0)
+      },
+      codeFiles: {
+        frontend: frontendFiles.filter(f => fs.existsSync(path.join(__dirname, f))),
+        backend: backendFiles.filter(f => fs.existsSync(path.join(__dirname, f)))
+      },
+      features: [
+        'Database collections backup',
+        'Key frontend components backup', 
+        'Backend routes and models backup',
+        'Seed data scripts backup',
+        'Manifest with backup details'
+      ],
+      restoreInstructions: {
+        database: 'Use the JSON files to restore collections to MongoDB',
+        code: 'Copy the code files back to their original locations',
+        verification: 'Check manifest.json for backup contents and details'
+      }
+    };
+    
+    const manifestPath = path.join(backupDir, 'manifest.json');
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    
+    console.log('\n🎉 Complete backup created successfully!');
+    console.log(`📁 Location: ${backupDir}`);
+    console.log(`📋 Manifest: ${manifestPath}`);
+    console.log(`📊 Total documents: ${manifest.database.totalDocuments}`);
+    console.log(`📄 Code files: ${manifest.codeFiles.frontend.length + manifest.codeFiles.backend.length}`);
+    
+    // List backup contents
+    console.log('\n📋 Backup Contents:');
+    console.log('Database Collections:');
+    collections.forEach(col => {
+      const count = backupData[col] ? backupData[col].length : 0;
+      console.log(`  - ${col}: ${count} documents`);
+    });
+    
+    console.log('\nCode Files:');
+    console.log('Frontend:');
+    manifest.codeFiles.frontend.forEach(file => {
+      const fileName = path.basename(file);
+      console.log(`  - ${fileName}`);
+    });
+    
+    console.log('Backend:');
+    manifest.codeFiles.backend.forEach(file => {
+      console.log(`  - ${file}`);
+    });
+    
+  } catch (error) {
+    console.error('❌ Backup failed:', error);
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+};
+
+// Run backup
+createCompleteBackup(); 

create-release-bundle.js

@@ -0,0 +1,121 @@
+/*
+ Creates a complete release bundle for fast restore:
+ - Tags frontend and backend repos with an annotated tag
+ - Copies code snapshots (tar.gz) for frontend and backend
+ - Dumps MongoDB collections to JSON (users, sourcetexts, submissions, subtitles, subtitlesubmissions)
+ - Writes a manifest.json with commit SHAs, tag, counts, and timestamps
+
+ Usage: node create-release-bundle.js [--tag TAG_NAME]
+ Requires: MONGODB_URI env (or falls back to local), git available
+*/
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const mongoose = require('mongoose');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const BACKEND_DIR = path.resolve(__dirname);
+const FRONTEND_DIR = path.resolve(__dirname, '../frontend');
+const BACKUPS_DIR = path.join(BACKEND_DIR, 'backups');
+const RELEASES_DIR = path.join(BACKUPS_DIR, 'releases');
+
+const argTag = process.argv.includes('--tag') ? process.argv[process.argv.indexOf('--tag') + 1] : null;
+const ts = new Date().toISOString().replace(/[:.]/g, '-');
+const tagName = argTag || `prod-${ts}`;
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function getGitInfo(repoDir) {
+  const sha = execSync('git rev-parse HEAD', { cwd: repoDir }).toString().trim();
+  const branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd: repoDir }).toString().trim();
+  return { sha, branch };
+}
+
+function tagAndPush(repoDir, tag) {
+  try {
+    execSync(`git tag -a ${tag} -m "Release ${tag}"`, { cwd: repoDir, stdio: 'inherit' });
+  } catch (e) {
+    // if tag exists, continue
+  }
+  // Prefer pushing to 'huggingface' remote if present, else default
+  try {
+    const remotes = execSync('git remote', { cwd: repoDir }).toString().split('\n').map(r => r.trim()).filter(Boolean);
+    if (remotes.includes('huggingface')) {
+      execSync('git push --tags huggingface', { cwd: repoDir, stdio: 'inherit' });
+    } else {
+      execSync('git push --tags', { cwd: repoDir, stdio: 'inherit' });
+    }
+  } catch (e) {
+    console.warn('⚠️  Warning: failed to push tags for', repoDir, '- continuing');
+  }
+}
+
+async function dumpCollections(outDir) {
+  const uri = process.env.MONGODB_URI || 'mongodb://localhost:27017/transcreation-sandbox';
+  await mongoose.connect(uri, { serverSelectionTimeoutMS: 5000 });
+  const conn = mongoose.connection;
+  const collections = ['users', 'sourcetexts', 'submissions', 'subtitles', 'subtitlesubmissions'];
+  const counts = {};
+  for (const name of collections) {
+    try {
+      const docs = await conn.db.collection(name).find({}).toArray();
+      fs.writeFileSync(path.join(outDir, `${name}.json`), JSON.stringify(docs, null, 2));
+      counts[name] = docs.length;
+    } catch (e) {
+      counts[name] = 0;
+    }
+  }
+  await mongoose.disconnect();
+  return counts;
+}
+
+(async () => {
+  console.log('📦 Creating release bundle...');
+  ensureDir(RELEASES_DIR);
+  const bundleDir = path.join(RELEASES_DIR, `release-${ts}`);
+  ensureDir(bundleDir);
+
+  // Git info and tags
+  console.log('🔖 Tagging repositories...');
+  const feInfo = getGitInfo(FRONTEND_DIR);
+  const beInfo = getGitInfo(BACKEND_DIR);
+  tagAndPush(FRONTEND_DIR, tagName);
+  tagAndPush(BACKEND_DIR, tagName);
+
+  // Code archives
+  console.log('🗜️  Archiving code...');
+  const feTar = path.join(bundleDir, `frontend-${feInfo.sha.slice(0,7)}.tar.gz`);
+  const beTar = path.join(bundleDir, `backend-${beInfo.sha.slice(0,7)}.tar.gz`);
+  execSync(`tar -czf "${feTar}" -C "${FRONTEND_DIR}" .`);
+  execSync(`tar -czf "${beTar}" -C "${BACKEND_DIR}" .`);
+
+  // DB dump
+  console.log('💾 Dumping database...');
+  const dbDir = path.join(bundleDir, 'db');
+  ensureDir(dbDir);
+  const counts = await dumpCollections(dbDir);
+
+  // Manifest
+  const manifest = {
+    createdAt: new Date().toISOString(),
+    tag: tagName,
+    frontend: feInfo,
+    backend: beInfo,
+    archives: {
+      frontend: path.basename(feTar),
+      backend: path.basename(beTar)
+    },
+    db: {
+      path: 'db',
+      counts
+    }
+  };
+  fs.writeFileSync(path.join(bundleDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+
+  console.log('\n🎉 Release bundle created');
+  console.log('📁 Location:', bundleDir);
+  console.log('🔖 Tag:', tagName);
+})();
+

create-working-backup.js

@@ -0,0 +1,80 @@
+const fs = require('fs');
+const path = require('path');
+const mongoose = require('mongoose');
+
+// Atlas MongoDB connection string
+const MONGODB_URI = 'mongodb+srv://nothingyu:wSg3lbO1PkHiRMq9@sandbox.ecysggv.mongodb.net/test?retryWrites=true&w=majority&appName=sandbox';
+
+// Create backup with timestamp
+const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+const backupName = `working-version-backup-${timestamp}`;
+const backupDir = path.join(__dirname, 'backups', backupName);
+
+async function createWorkingBackup() {
+  try {
+    console.log('🔄 Creating backup of current working version...');
+    console.log('📁 Backup name:', backupName);
+    
+    // Create backup directory
+    if (!fs.existsSync(path.join(__dirname, 'backups'))) {
+      fs.mkdirSync(path.join(__dirname, 'backups'));
+    }
+    fs.mkdirSync(backupDir);
+    
+    // Connect to MongoDB
+    console.log('🔗 Connecting to MongoDB...');
+    await mongoose.connect(MONGODB_URI);
+    
+    // Backup database collections
+    console.log('📊 Backing up database collections...');
+    const collections = ['users', 'sourcetexts', 'submissions', 'subtitles', 'subtitlesubmissions'];
+    
+    for (const collectionName of collections) {
+      try {
+        const collection = mongoose.connection.db.collection(collectionName);
+        const data = await collection.find({}).toArray();
+        
+        const backupPath = path.join(backupDir, `${collectionName}.json`);
+        fs.writeFileSync(backupPath, JSON.stringify(data, null, 2));
+        console.log(`✅ Backed up ${collectionName}: ${data.length} documents`);
+      } catch (error) {
+        console.log(`⚠️ Could not backup ${collectionName}:`, error.message);
+      }
+    }
+    
+    // Create backup manifest
+    const manifest = {
+      backupName,
+      timestamp: new Date().toISOString(),
+      description: 'Working version backup - subtitle system working correctly',
+      features: [
+        'Fixed subtitle display logic with 0.5s buffer',
+        'Fixed segment 21 and 22 display (60 char limit)',
+        'Simplified subtitle timing logic',
+        'Working subtitle submissions system',
+        'Proper text formatting and line wrapping'
+      ],
+      collections: collections,
+      version: '1.0.0'
+    };
+    
+    fs.writeFileSync(path.join(backupDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+    
+    console.log('✅ Backup completed successfully!');
+    console.log('📁 Backup location:', backupDir);
+    console.log('📋 Manifest created with feature list');
+    
+  } catch (error) {
+    console.error('❌ Backup failed:', error);
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+}
+
+// Run the backup
+if (require.main === module) {
+  createWorkingBackup();
+}
+
+module.exports = { createWorkingBackup }; 

cron-setup-guide.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+
+const fs = require('fs').promises;
+const path = require('path');
+
+// Cron Setup and Backup Usage Guide
+const cronGuide = {
+  // Show cron setup instructions
+  showCronSetup() {
+    console.log('⏰ CRON JOB SETUP GUIDE');
+    console.log('=======================\n');
+    
+    console.log('1. 📝 EDIT CRONTAB:');
+    console.log('   crontab -e');
+    console.log('');
+    
+    console.log('2. 📋 ADD BACKUP JOB (choose one):');
+    console.log('');
+    console.log('   # Daily backup at 2 AM');
+    console.log('   0 2 * * * cd /Users/hongchangyu/Downloads/App\\ Projects/Cultural\\ Shift\\ Sandbox/deploy/backend && node comprehensive-backup.js');
+    console.log('');
+    console.log('   # Weekly backup on Sunday at 3 AM');
+    console.log('   0 3 * * 0 cd /Users/hongchangyu/Downloads/App\\ Projects/Cultural\\ Shift\\ Sandbox/deploy/backend && node comprehensive-backup.js');
+    console.log('');
+    console.log('   # Every 6 hours');
+    console.log('   0 */6 * * * cd /Users/hongchangyu/Downloads/App\\ Projects/Cultural\\ Shift\\ Sandbox/deploy/backend && node comprehensive-backup.js');
+    console.log('');
+    
+    console.log('3. ✅ VERIFY CRON JOBS:');
+    console.log('   crontab -l');
+    console.log('');
+    
+    console.log('4. 📊 CHECK CRON LOGS:');
+    console.log('   tail -f /var/log/cron');
+    console.log('   or');
+    console.log('   grep CRON /var/log/syslog');
+    console.log('');
+  },
+  
+  // Show backup usage instructions
+  showBackupUsage() {
+    console.log('💾 BACKUP USAGE GUIDE');
+    console.log('=====================\n');
+    
+    console.log('📋 CHECK AVAILABLE BACKUPS:');
+    console.log('   node simple-automated-backup.js');
+    console.log('   # Lists all backups with details');
+    console.log('');
+    
+    console.log('🔍 VERIFY BACKUP INTEGRITY:');
+    console.log('   node comprehensive-backup.js');
+    console.log('   # Creates new backup and verifies integrity');
+    console.log('');
+    
+    console.log('📊 BACKUP CONTENTS:');
+    console.log('   - Database: All collections (subtitles, source texts, users)');
+    console.log('   - Code: Frontend and backend files');
+    console.log('   - Configuration: package.json, Dockerfile, etc.');
+    console.log('   - Manifest: Backup metadata and verification info');
+    console.log('');
+    
+    console.log('🔄 RESTORE FROM BACKUP:');
+    console.log('   # Database only (safe)');
+    console.log('   node restore-database.js <backup-name>');
+    console.log('');
+    console.log('   # Full restore (including code)');
+    console.log('   node restore-comprehensive.js <backup-name>');
+    console.log('');
+  },
+  
+  // Show cron job examples
+  showCronExamples() {
+    console.log('📝 CRON JOB EXAMPLES');
+    console.log('====================\n');
+    
+    console.log('⏰ TIME FORMAT: minute hour day month day-of-week command');
+    console.log('');
+    
+    console.log('📅 COMMON SCHEDULES:');
+    console.log('   0 2 * * *     # Daily at 2 AM');
+    console.log('   0 */6 * * *   # Every 6 hours');
+    console.log('   0 3 * * 0     # Weekly on Sunday at 3 AM');
+    console.log('   0 1 1 * *     # Monthly on 1st at 1 AM');
+    console.log('   */30 * * * *  # Every 30 minutes');
+    console.log('');
+    
+    console.log('🔧 BACKUP COMMANDS:');
+    console.log('   # Simple data backup');
+    console.log('   node simple-automated-backup.js');
+    console.log('');
+    console.log('   # Comprehensive backup (data + code)');
+    console.log('   node comprehensive-backup.js');
+    console.log('');
+    console.log('   # With logging');
+    console.log('   node comprehensive-backup.js >> backup.log 2>&1');
+    console.log('');
+  },
+  
+  // Show backup locations
+  showBackupLocations() {
+    console.log('📁 BACKUP LOCATIONS');
+    console.log('===================\n');
+    
+    const backupDir = path.join(__dirname, 'backups');
+    console.log(`📂 Local backups: ${backupDir}`);
+    console.log('');
+    
+    console.log('📋 BACKUP STRUCTURE:');
+    console.log('   backups/');
+    console.log('   ├── comprehensive-backup-2025-08-05T.../');
+    console.log('   │   ├── database.json          # All database data');
+    console.log('   │   ├── code/                  # All source code');
+    console.log('   │   │   ├── backend/           # Backend files');
+    console.log('   │   │   ├── frontend/          # Frontend files');
+    console.log('   │   │   └── root/              # Root config');
+    console.log('   │   ├── config/                # Configuration files');
+    console.log('   │   └── manifest.json          # Backup metadata');
+    console.log('   └── auto-backup-2025-08-05T.../');
+    console.log('       └── database.json          # Data only');
+    console.log('');
+    
+    console.log('💾 BACKUP TYPES:');
+    console.log('   - comprehensive-backup-* : Data + Code + Config');
+    console.log('   - auto-backup-*         : Data only (faster)');
+    console.log('');
+  },
+  
+  // Show how to check backup contents
+  async showBackupContents() {
+    console.log('🔍 CHECKING BACKUP CONTENTS');
+    console.log('===========================\n');
+    
+    const backupDir = path.join(__dirname, 'backups');
+    
+    try {
+      const backups = await fs.readdir(backupDir);
+      
+      if (backups.length === 0) {
+        console.log('❌ No backups found');
+        return;
+      }
+      
+      console.log('📋 Available backups:');
+      for (const backup of backups) {
+        const backupPath = path.join(backupDir, backup);
+        const stats = await fs.stat(backupPath);
+        
+        if (stats.isDirectory()) {
+          console.log(`  📦 ${backup} (${stats.mtime.toLocaleString()})`);
+          
+          // Check if it's a comprehensive backup
+          const manifestPath = path.join(backupPath, 'manifest.json');
+          try {
+            await fs.access(manifestPath);
+            console.log(`    ✅ Comprehensive backup (data + code)`);
+          } catch {
+            console.log(`    📊 Data backup only`);
+          }
+        }
+      }
+      
+    } catch (error) {
+      console.log('❌ Could not read backup directory:', error.message);
+    }
+    
+    console.log('');
+    console.log('🔍 TO EXAMINE A SPECIFIC BACKUP:');
+    console.log('   ls -la backups/comprehensive-backup-*/');
+    console.log('   cat backups/comprehensive-backup-*/manifest.json');
+    console.log('');
+  }
+};
+
+// Main function
+const main = async () => {
+  console.log('🚀 CRON & BACKUP GUIDE');
+  console.log('======================\n');
+  
+  // Show all guides
+  cronGuide.showCronSetup();
+  cronGuide.showBackupUsage();
+  cronGuide.showCronExamples();
+  cronGuide.showBackupLocations();
+  await cronGuide.showBackupContents();
+  
+  console.log('🎯 QUICK START:');
+  console.log('1. Set up cron: crontab -e');
+  console.log('2. Add: 0 2 * * * cd /path/to/backend && node comprehensive-backup.js');
+  console.log('3. Check backups: node simple-automated-backup.js');
+  console.log('4. Restore if needed: node restore-database.js <backup-name>');
+  console.log('');
+  
+  console.log('📞 NEED HELP?');
+  console.log('- Check cron logs: tail -f /var/log/cron');
+  console.log('- Test backup: node comprehensive-backup.js');
+  console.log('- List backups: node simple-automated-backup.js');
+};
+
+// Run the guide
+main(); 

implement-security-enhancements.js

@@ -0,0 +1,315 @@
+const mongoose = require('mongoose');
+const crypto = require('crypto');
+
+// Atlas MongoDB connection string
+const MONGODB_URI = 'mongodb+srv://nothingyu:wSg3lbO1PkHiRMq9@sandbox.ecysggv.mongodb.net/test?retryWrites=true&w=majority&appName=sandbox';
+
+// Connect to MongoDB Atlas
+const connectDB = async () => {
+  try {
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to MongoDB Atlas');
+  } catch (error) {
+    console.error('❌ MongoDB connection error:', error);
+    process.exit(1);
+  }
+};
+
+// Enhanced Subtitle Schema with security features
+const subtitleSchema = new mongoose.Schema({
+  segmentId: { type: Number, required: true, unique: true },
+  startTime: { type: String, required: true },
+  endTime: { type: String, required: true },
+  duration: { type: String, required: true },
+  englishText: { type: String, required: true },
+  chineseTranslation: { type: String, default: '' },
+  isProtected: { type: Boolean, default: false },
+  protectedReason: { type: String, default: '' },
+  lastModified: { type: Date, default: Date.now },
+  modificationHistory: [{ 
+    timestamp: { type: Date, default: Date.now },
+    action: String,
+    previousValue: String,
+    newValue: String,
+    modifiedBy: String
+  }],
+  // New security fields
+  contentChecksum: { type: String, required: true },
+  lastVerified: { type: Date, default: Date.now },
+  verificationHistory: [{
+    timestamp: Date,
+    checksum: String,
+    verifiedBy: String,
+    status: String
+  }],
+  watermark: { type: String, default: '' },
+  accessLog: [{
+    timestamp: Date,
+    userId: String,
+    action: String,
+    ip: String,
+    userAgent: String
+  }]
+});
+
+const Subtitle = mongoose.model('Subtitle', subtitleSchema);
+
+// Security utilities
+const securityUtils = {
+  generateChecksum: (content) => {
+    return crypto.createHash('sha256').update(content).digest('hex');
+  },
+  
+  addWatermark: (text, userId) => {
+    const watermark = Buffer.from(userId || 'system').toString('base64').slice(0, 8);
+    return text + '\u200B' + watermark; // Zero-width space + watermark
+  },
+  
+  extractWatermark: (text) => {
+    const parts = text.split('\u200B');
+    return parts.length > 1 ? parts[1] : null;
+  },
+  
+  validateTimeFormat: (timeString) => {
+    const timePattern = /^\d{2}:\d{2}:\d{2},\d{3}$/;
+    return timePattern.test(timeString);
+  },
+  
+  sanitizeInput: (text) => {
+    // Basic XSS prevention
+    return text
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&#x27;')
+      .replace(/\//g, '&#x2F;');
+  }
+};
+
+// Enhanced protection system
+const enhancedProtection = {
+  async addSecurityFeatures() {
+    try {
+      console.log('🔒 Adding security features to existing subtitles...');
+      
+      const subtitles = await Subtitle.find({});
+      console.log(`📊 Found ${subtitles.length} subtitle segments`);
+      
+      let updatedCount = 0;
+      
+      for (const subtitle of subtitles) {
+        const updates = {};
+        
+        // Generate checksum if not exists
+        if (!subtitle.contentChecksum) {
+          const content = subtitle.englishText + subtitle.startTime + subtitle.endTime;
+          updates.contentChecksum = securityUtils.generateChecksum(content);
+        }
+        
+        // Add watermark if not exists
+        if (!subtitle.watermark) {
+          updates.watermark = securityUtils.addWatermark(subtitle.englishText, 'system');
+        }
+        
+        // Add verification history if empty
+        if (!subtitle.verificationHistory || subtitle.verificationHistory.length === 0) {
+          updates.verificationHistory = [{
+            timestamp: new Date(),
+            checksum: subtitle.contentChecksum || securityUtils.generateChecksum(subtitle.englishText + subtitle.startTime + subtitle.endTime),
+            verifiedBy: 'system',
+            status: 'verified'
+          }];
+        }
+        
+        // Update if any changes needed
+        if (Object.keys(updates).length > 0) {
+          await Subtitle.findByIdAndUpdate(subtitle._id, {
+            ...updates,
+            lastModified: new Date(),
+            $push: {
+              modificationHistory: {
+                timestamp: new Date(),
+                action: 'SECURITY_ENHANCEMENT',
+                previousValue: 'none',
+                newValue: 'security_features_added',
+                modifiedBy: 'system'
+              }
+            }
+          });
+          updatedCount++;
+        }
+      }
+      
+      console.log(`✅ Enhanced ${updatedCount} subtitle segments with security features`);
+      
+      // Verify integrity
+      await this.verifyAllIntegrity();
+      
+    } catch (error) {
+      console.error('❌ Error adding security features:', error);
+    }
+  },
+  
+  async verifyAllIntegrity() {
+    try {
+      console.log('🔍 Verifying integrity of all subtitle segments...');
+      
+      const subtitles = await Subtitle.find({});
+      let verifiedCount = 0;
+      let failedCount = 0;
+      
+      for (const subtitle of subtitles) {
+        const currentChecksum = securityUtils.generateChecksum(
+          subtitle.englishText + subtitle.startTime + subtitle.endTime
+        );
+        
+        if (currentChecksum === subtitle.contentChecksum) {
+          verifiedCount++;
+        } else {
+          failedCount++;
+          console.warn(`⚠️ Integrity check failed for segment ${subtitle.segmentId}`);
+        }
+      }
+      
+      console.log(`✅ Integrity verification complete:`);
+      console.log(`  - Verified: ${verifiedCount} segments`);
+      console.log(`  - Failed: ${failedCount} segments`);
+      
+      if (failedCount > 0) {
+        console.log('⚠️ Some segments failed integrity checks. Consider investigation.');
+      }
+      
+    } catch (error) {
+      console.error('❌ Error during integrity verification:', error);
+    }
+  },
+  
+  async createSecurityLogsCollection() {
+    try {
+      console.log('📝 Creating security logs collection...');
+      
+      const securityLogSchema = new mongoose.Schema({
+        timestamp: { type: Date, default: Date.now },
+        event: { type: String, required: true },
+        details: mongoose.Schema.Types.Mixed,
+        ip: String,
+        userAgent: String,
+        userId: String,
+        severity: { type: String, enum: ['low', 'medium', 'high', 'critical'], default: 'medium' }
+      });
+      
+      const SecurityLog = mongoose.model('SecurityLog', securityLogSchema);
+      
+      // Create index for efficient querying
+      await SecurityLog.createIndexes();
+      
+      console.log('✅ Security logs collection created');
+      
+      // Log initial security enhancement
+      await SecurityLog.create({
+        event: 'SECURITY_ENHANCEMENT_IMPLEMENTED',
+        details: {
+          action: 'Enhanced subtitle protection system',
+          features: ['checksums', 'watermarks', 'integrity_verification'],
+          timestamp: new Date()
+        },
+        severity: 'high'
+      });
+      
+    } catch (error) {
+      console.error('❌ Error creating security logs:', error);
+    }
+  },
+  
+  async createBackupVerification() {
+    try {
+      console.log('💾 Creating backup verification system...');
+      
+      const backupSchema = new mongoose.Schema({
+        backupName: { type: String, required: true, unique: true },
+        timestamp: { type: Date, default: Date.now },
+        collections: [String],
+        totalRecords: Number,
+        checksum: String,
+        status: { type: String, enum: ['created', 'verified', 'restored'], default: 'created' },
+        createdBy: String
+      });
+      
+      const Backup = mongoose.model('Backup', backupSchema);
+      
+      // Create initial backup record
+      const collections = ['subtitles', 'sourcetexts', 'submissions', 'users'];
+      let totalRecords = 0;
+      
+      for (const collection of collections) {
+        const count = await mongoose.connection.db.collection(collection).countDocuments();
+        totalRecords += count;
+      }
+      
+      const backupData = {
+        collections,
+        totalRecords,
+        checksum: securityUtils.generateChecksum(`backup-${Date.now()}`)
+      };
+      
+      await Backup.create({
+        backupName: `security-enhanced-backup-${new Date().toISOString()}`,
+        collections,
+        totalRecords,
+        checksum: backupData.checksum,
+        createdBy: 'system'
+      });
+      
+      console.log('✅ Backup verification system created');
+      console.log(`📊 Backup created with ${totalRecords} total records`);
+      
+    } catch (error) {
+      console.error('❌ Error creating backup verification:', error);
+    }
+  }
+};
+
+// Main implementation function
+const implementSecurityEnhancements = async () => {
+  try {
+    console.log('🚀 Starting security enhancement implementation...');
+    
+    // Step 1: Add security features to existing subtitles
+    await enhancedProtection.addSecurityFeatures();
+    
+    // Step 2: Verify integrity
+    await enhancedProtection.verifyAllIntegrity();
+    
+    // Step 3: Create security logs collection
+    await enhancedProtection.createSecurityLogsCollection();
+    
+    // Step 4: Create backup verification system
+    await enhancedProtection.createBackupVerification();
+    
+    console.log('\n🎉 Security enhancements implemented successfully!');
+    console.log('\n📋 Implemented features:');
+    console.log('  ✅ Content checksums for integrity verification');
+    console.log('  ✅ Invisible watermarks for content tracking');
+    console.log('  ✅ Security logging system');
+    console.log('  ✅ Backup verification system');
+    console.log('  ✅ Input sanitization utilities');
+    console.log('  ✅ Time format validation');
+    
+    console.log('\n🔒 Next steps:');
+    console.log('  1. Implement JWT authentication');
+    console.log('  2. Add rate limiting per user');
+    console.log('  3. Set up monitoring and alerting');
+    console.log('  4. Configure automated security testing');
+    
+  } catch (error) {
+    console.error('❌ Error implementing security enhancements:', error);
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+};
+
+// Run the implementation
+connectDB().then(() => {
+  implementSecurityEnhancements();
+}); 

lock-subtitles.js

@@ -0,0 +1,107 @@
+const mongoose = require('mongoose');
+
+// Atlas MongoDB connection string
+const MONGODB_URI = 'mongodb+srv://nothingyu:wSg3lbO1PkHiRMq9@sandbox.ecysggv.mongodb.net/test?retryWrites=true&w=majority&appName=sandbox';
+
+// Connect to MongoDB Atlas
+const connectDB = async () => {
+  try {
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to MongoDB Atlas');
+  } catch (error) {
+    console.error('❌ MongoDB connection error:', error);
+    process.exit(1);
+  }
+};
+
+// Subtitle Schema (same as in models/Subtitle.js)
+const subtitleSchema = new mongoose.Schema({
+  segmentId: { type: Number, required: true, unique: true },
+  startTime: { type: String, required: true },
+  endTime: { type: String, required: true },
+  duration: { type: String, required: true },
+  englishText: { type: String, required: true },
+  chineseTranslation: { type: String, default: '' },
+  isProtected: { type: Boolean, default: false },
+  protectedReason: { type: String, default: '' },
+  lastModified: { type: Date, default: Date.now },
+  modificationHistory: [{ 
+    timestamp: { type: Date, default: Date.now },
+    action: String,
+    previousValue: String,
+    newValue: String,
+    modifiedBy: String
+  }]
+});
+
+const Subtitle = mongoose.model('Subtitle', subtitleSchema);
+
+const lockSubtitles = async () => {
+  try {
+    console.log('🔒 Starting subtitle protection process...');
+    
+    // Find all subtitle segments
+    const subtitles = await Subtitle.find({});
+    console.log(`📊 Found ${subtitles.length} subtitle segments`);
+    
+    if (subtitles.length === 0) {
+      console.log('❌ No subtitle segments found. Please seed the database first.');
+      return;
+    }
+    
+    // Lock all subtitle segments
+    const updatePromises = subtitles.map(subtitle => 
+      Subtitle.findByIdAndUpdate(
+        subtitle._id,
+        {
+          isProtected: true,
+          protectedReason: 'Original English subtitles and timecodes - critical for course content',
+          lastModified: new Date(),
+          $push: {
+            modificationHistory: {
+              timestamp: new Date(),
+              action: 'PROTECTED',
+              previousValue: 'false',
+              newValue: 'true',
+              modifiedBy: 'system'
+            }
+          }
+        },
+        { new: true }
+      )
+    );
+    
+    const updatedSubtitles = await Promise.all(updatePromises);
+    console.log(`✅ Successfully protected ${updatedSubtitles.length} subtitle segments`);
+    
+    // Verify protection
+    const protectedCount = await Subtitle.countDocuments({ isProtected: true });
+    console.log(`🔒 Verification: ${protectedCount} segments are now protected`);
+    
+    // Show sample of protected segments
+    const sampleProtected = await Subtitle.find({ isProtected: true }).limit(5);
+    console.log('\n📋 Sample of protected segments:');
+    sampleProtected.forEach(subtitle => {
+      console.log(`  Segment ${subtitle.segmentId}: "${subtitle.englishText.substring(0, 50)}..."`);
+    });
+    
+    console.log('\n🎯 Subtitle protection complete!');
+    console.log('📝 Protection details:');
+    console.log('  - All 26 subtitle segments are now protected');
+    console.log('  - Original English text cannot be modified');
+    console.log('  - Timecodes cannot be changed');
+    console.log('  - Chinese translations can still be added/updated');
+    console.log('  - Use unlock-subtitles.js to temporarily disable protection');
+    
+  } catch (error) {
+    console.error('❌ Error protecting subtitles:', error);
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+};
+
+// Run the protection script
+connectDB().then(() => {
+  lockSubtitles();
+}); 

simple-automated-backup.js

@@ -0,0 +1,244 @@
+const mongoose = require('mongoose');
+const fs = require('fs').promises;
+const path = require('path');
+
+// Atlas MongoDB connection string
+const MONGODB_URI = 'mongodb+srv://nothingyu:wSg3lbO1PkHiRMq9@sandbox.ecysggv.mongodb.net/test?retryWrites=true&w=majority&appName=sandbox';
+
+// Connect to MongoDB Atlas
+const connectDB = async () => {
+  try {
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to MongoDB Atlas');
+  } catch (error) {
+    console.error('❌ MongoDB connection error:', error);
+    process.exit(1);
+  }
+};
+
+// Simple Automated Backup System
+const automatedBackup = {
+  // Create backup
+  async createBackup() {
+    try {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupName = `auto-backup-${timestamp}`;
+      
+      console.log(`💾 Creating automated backup: ${backupName}`);
+      
+      // Collections to backup
+      const collections = ['subtitles', 'sourcetexts', 'submissions', 'users'];
+      const backupData = {
+        metadata: {
+          backupName,
+          timestamp: new Date(),
+          collections,
+          totalRecords: 0,
+          version: '1.0',
+          type: 'automated'
+        },
+        data: {}
+      };
+      
+      // Export each collection
+      for (const collection of collections) {
+        try {
+          const data = await mongoose.connection.db.collection(collection).find({}).toArray();
+          backupData.data[collection] = data;
+          backupData.metadata.totalRecords += data.length;
+          console.log(`  📦 Exported ${data.length} records from ${collection}`);
+        } catch (error) {
+          console.warn(`  ⚠️ Could not export ${collection}:`, error.message);
+        }
+      }
+      
+      // Save to backup directory
+      const backupDir = path.join(__dirname, 'backups');
+      await fs.mkdir(backupDir, { recursive: true });
+      
+      const backupPath = path.join(backupDir, `${backupName}.json`);
+      await fs.writeFile(backupPath, JSON.stringify(backupData, null, 2));
+      
+      // Save backup record to database
+      const backupRecord = {
+        backupName,
+        timestamp: new Date(),
+        collections,
+        totalRecords: backupData.metadata.totalRecords,
+        filePath: backupPath,
+        status: 'created',
+        type: 'automated'
+      };
+      
+      await mongoose.connection.db.collection('backups').insertOne(backupRecord);
+      
+      console.log(`✅ Backup created successfully: ${backupName}`);
+      console.log(`📊 Total records: ${backupData.metadata.totalRecords}`);
+      console.log(`💾 File saved: ${backupPath}`);
+      
+      return backupName;
+      
+    } catch (error) {
+      console.error('❌ Error creating backup:', error);
+      throw error;
+    }
+  },
+  
+  // List backups
+  async listBackups() {
+    try {
+      console.log('📋 Available backups:');
+      
+      // List from database
+      const dbBackups = await mongoose.connection.db.collection('backups').find({}).sort({ timestamp: -1 }).toArray();
+      
+      if (dbBackups.length === 0) {
+        console.log('  No backups found in database');
+      } else {
+        console.log('  Database backups:');
+        dbBackups.forEach(backup => {
+          const date = new Date(backup.timestamp).toLocaleString();
+          console.log(`    📦 ${backup.backupName} (${backup.totalRecords} records, ${date})`);
+        });
+      }
+      
+      // List from file system
+      const backupDir = path.join(__dirname, 'backups');
+      try {
+        const files = await fs.readdir(backupDir);
+        const backupFiles = files.filter(file => file.endsWith('.json'));
+        
+        if (backupFiles.length > 0) {
+          console.log('  File system backups:');
+          for (const file of backupFiles) {
+            const filePath = path.join(backupDir, file);
+            const stats = await fs.stat(filePath);
+            console.log(`    💾 ${file} (${(stats.size / 1024).toFixed(2)} KB, ${stats.mtime.toLocaleString()})`);
+          }
+        }
+      } catch (error) {
+        console.log('  No backup directory found');
+      }
+      
+    } catch (error) {
+      console.error('❌ Error listing backups:', error);
+    }
+  },
+  
+  // Clean old backups (keep last 10)
+  async cleanOldBackups() {
+    try {
+      console.log('🧹 Cleaning old backups...');
+      
+      const backupCollection = mongoose.connection.db.collection('backups');
+      const allBackups = await backupCollection.find({}).sort({ timestamp: -1 }).toArray();
+      
+      if (allBackups.length > 10) {
+        const backupsToDelete = allBackups.slice(10);
+        
+        for (const backup of backupsToDelete) {
+          // Delete file
+          try {
+            await fs.unlink(backup.filePath);
+            console.log(`  🗑️ Deleted file: ${backup.backupName}`);
+          } catch (error) {
+            console.warn(`  ⚠️ Could not delete file: ${backup.backupName}`);
+          }
+          
+          // Delete database record
+          await backupCollection.deleteOne({ _id: backup._id });
+          console.log(`  🗑️ Deleted record: ${backup.backupName}`);
+        }
+        
+        console.log(`✅ Cleaned ${backupsToDelete.length} old backups`);
+      } else {
+        console.log('✅ No old backups to clean (keeping all backups)');
+      }
+      
+    } catch (error) {
+      console.error('❌ Error cleaning old backups:', error);
+    }
+  },
+  
+  // Verify backup integrity
+  async verifyBackup(backupName) {
+    try {
+      console.log(`🔍 Verifying backup: ${backupName}`);
+      
+      const backupPath = path.join(__dirname, 'backups', `${backupName}.json`);
+      const backupData = JSON.parse(await fs.readFile(backupPath, 'utf8'));
+      
+      let verifiedCount = 0;
+      let failedCount = 0;
+      
+      for (const [collection, data] of Object.entries(backupData.data)) {
+        try {
+          const currentCount = await mongoose.connection.db.collection(collection).countDocuments();
+          const backupCount = data.length;
+          
+          if (currentCount === backupCount) {
+            verifiedCount++;
+            console.log(`  ✅ ${collection}: ${backupCount} records verified`);
+          } else {
+            failedCount++;
+            console.log(`  ❌ ${collection}: ${backupCount} in backup, ${currentCount} in database`);
+          }
+        } catch (error) {
+          failedCount++;
+          console.log(`  ❌ ${collection}: verification failed`);
+        }
+      }
+      
+      console.log(`🔍 Verification complete:`);
+      console.log(`  - Verified: ${verifiedCount} collections`);
+      console.log(`  - Failed: ${failedCount} collections`);
+      
+      return { verifiedCount, failedCount };
+      
+    } catch (error) {
+      console.error('❌ Error verifying backup:', error);
+    }
+  }
+};
+
+// Main function
+const main = async () => {
+  try {
+    console.log('🚀 Starting automated backup system...');
+    
+    // Create backup
+    const backupName = await automatedBackup.createBackup();
+    
+    // List all backups
+    await automatedBackup.listBackups();
+    
+    // Clean old backups
+    await automatedBackup.cleanOldBackups();
+    
+    // Verify the backup
+    await automatedBackup.verifyBackup(backupName);
+    
+    console.log('\n🎉 Automated backup system ready!');
+    console.log('\n📋 Available functions:');
+    console.log('  - createBackup(): Create new backup');
+    console.log('  - listBackups(): List available backups');
+    console.log('  - cleanOldBackups(): Keep only last 10 backups');
+    console.log('  - verifyBackup(name): Verify backup integrity');
+    
+    console.log('\n⏰ To enable daily automated backups:');
+    console.log('  1. Set up a cron job or scheduled task');
+    console.log('  2. Run: node simple-automated-backup.js');
+    console.log('  3. Or use MongoDB Atlas automatic backups (already enabled)');
+    
+  } catch (error) {
+    console.error('❌ Error in automated backup system:', error);
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+};
+
+// Run the system
+connectDB().then(() => {
+  main();
+}); 

unlock-subtitles.js

@@ -0,0 +1,100 @@
+const mongoose = require('mongoose');
+
+// Atlas MongoDB connection string
+const MONGODB_URI = 'mongodb+srv://nothingyu:wSg3lbO1PkHiRMq9@sandbox.ecysggv.mongodb.net/test?retryWrites=true&w=majority&appName=sandbox';
+
+// Connect to MongoDB Atlas
+const connectDB = async () => {
+  try {
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to MongoDB Atlas');
+  } catch (error) {
+    console.error('❌ MongoDB connection error:', error);
+    process.exit(1);
+  }
+};
+
+// Subtitle Schema (same as in models/Subtitle.js)
+const subtitleSchema = new mongoose.Schema({
+  segmentId: { type: Number, required: true, unique: true },
+  startTime: { type: String, required: true },
+  endTime: { type: String, required: true },
+  duration: { type: String, required: true },
+  englishText: { type: String, required: true },
+  chineseTranslation: { type: String, default: '' },
+  isProtected: { type: Boolean, default: false },
+  protectedReason: { type: String, default: '' },
+  lastModified: { type: Date, default: Date.now },
+  modificationHistory: [{ 
+    timestamp: { type: Date, default: Date.now },
+    action: String,
+    previousValue: String,
+    newValue: String,
+    modifiedBy: String
+  }]
+});
+
+const Subtitle = mongoose.model('Subtitle', subtitleSchema);
+
+const unlockSubtitles = async () => {
+  try {
+    console.log('🔓 Starting subtitle unlock process...');
+    
+    // Find all protected subtitle segments
+    const protectedSubtitles = await Subtitle.find({ isProtected: true });
+    console.log(`📊 Found ${protectedSubtitles.length} protected subtitle segments`);
+    
+    if (protectedSubtitles.length === 0) {
+      console.log('ℹ️ No protected subtitle segments found.');
+      return;
+    }
+    
+    // Unlock all subtitle segments
+    const updatePromises = protectedSubtitles.map(subtitle => 
+      Subtitle.findByIdAndUpdate(
+        subtitle._id,
+        {
+          isProtected: false,
+          protectedReason: '',
+          lastModified: new Date(),
+          $push: {
+            modificationHistory: {
+              timestamp: new Date(),
+              action: 'UNLOCKED',
+              previousValue: 'true',
+              newValue: 'false',
+              modifiedBy: 'admin'
+            }
+          }
+        },
+        { new: true }
+      )
+    );
+    
+    const updatedSubtitles = await Promise.all(updatePromises);
+    console.log(`✅ Successfully unlocked ${updatedSubtitles.length} subtitle segments`);
+    
+    // Verify unlock
+    const unlockedCount = await Subtitle.countDocuments({ isProtected: false });
+    console.log(`🔓 Verification: ${unlockedCount} segments are now unlocked`);
+    
+    console.log('\n⚠️  WARNING: Subtitles are now unlocked!');
+    console.log('📝 Unlock details:');
+    console.log('  - All subtitle segments can now be modified');
+    console.log('  - Original English text can be changed');
+    console.log('  - Timecodes can be updated');
+    console.log('  - Remember to re-lock after modifications');
+    console.log('  - Run lock-subtitles.js to re-protect');
+    
+  } catch (error) {
+    console.error('❌ Error unlocking subtitles:', error);
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+};
+
+// Run the unlock script
+connectDB().then(() => {
+  unlockSubtitles();
+});