Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+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

.gitignore

@@ -0,0 +1,62 @@
+# Dependencies
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Logs
+logs/
+*.log
+
+# Runtime data
+pids/
+*.pid
+*.seed
+*.pid.lock
+
+# Coverage directory used by tools like istanbul
+coverage/
+
+# nyc test coverage
+.nyc_output
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Optional npm cache directory
+.npm
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+
+# IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db 

Dockerfile

@@ -0,0 +1,35 @@
+# Use Node.js 18 Alpine for smaller image size
+FROM node:18-alpine
+
+# Set working directory
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm install --only=production
+
+# Copy server source code
+COPY . ./
+
+# Create a non-root user
+RUN addgroup -g 1001 -S nodejs
+RUN adduser -S nodejs -u 1001
+
+# Change ownership of the app directory
+RUN chown -R nodejs:nodejs /app
+USER nodejs
+
+# Expose port
+EXPOSE 7860
+
+# Health check with longer start period and more retries
+HEALTHCHECK --interval=60s --timeout=10s --start-period=120s --retries=5 \
+  CMD curl -f http://localhost:7860/api/health || exit 1
+
+# Start the application
+# rebuild trigger 2025-09-01T14:18:50Z
+CMD npm start
+
+# rebuild trigger 2025-09-02T03:17:52Z

PROTECTION_SYSTEM_GUIDE.md

@@ -0,0 +1,168 @@
+# 🔒 PROTECTION SYSTEM GUIDE
+
+## Overview
+
+The protection system prevents accidental modification of critical tutorial tasks (Week 1 and Week 2) by implementing a locking mechanism that requires special authorization to modify protected content.
+
+## 🛡️ Current Protection Status
+
+- **Week 1**: 3 tutorial tasks + 6 weekly practice tasks LOCKED
+- **Week 2**: 12 tutorial tasks LOCKED  
+- **Total Protected**: 21 tasks
+- **Unlock Key**: `UNLOCK_WEEK1_WEEK2_2024`
+
+## 📋 Protected Tasks
+
+### Week 1 (9 tasks)
+**Tutorial Tasks (3):**
+1. Tutorial Task 1 - Gulangyu Stone
+2. Tutorial Task 2 - Gulangyu Geology
+3. Tutorial Task 3 - Opium War History
+
+**Weekly Practice Tasks (6):**
+1. Chinese Pun 1
+2. Chinese Pun 2
+3. Chinese Pun 3
+4. English Joke 1
+5. English Joke 2
+6. English Joke 3
+
+### Week 2 (12 tasks)
+1. Tutorial ST 1 - Week 2
+2. Tutorial ST 2 - Week 2
+3. Tutorial ST 3 - Week 2
+4. Tutorial ST 4 - Week 2
+5. Tutorial ST 5 - Week 2
+6. Tutorial ST 6 - Week 2
+7. Tutorial ST 7 - Week 2
+8. Tutorial ST 8 - Week 2
+9. Tutorial ST 9 - Week 2
+10. Tutorial ST 10 - Week 2
+11. Tutorial ST 11 - Week 2
+12. Tutorial ST 12 - Week 2
+
+## 🔧 Available Scripts
+
+### 1. Check Protection Status
+```bash
+node show-protection-status.js
+```
+Shows current protection status of all tutorial tasks.
+
+### 2. Test Protection System
+```bash
+node enhanced-protection-system.js
+```
+Tests the protection system to ensure it's working correctly.
+
+### 3. Lock Tasks
+```bash
+node lock-week1-week2-tasks.js
+```
+Locks Week 1 and Week 2 tutorial tasks (already done).
+
+## 🚫 What's Protected
+
+Protected tasks **CANNOT** be:
+- ✅ Updated (content, images, etc.)
+- ✅ Deleted
+- ✅ Modified in any way
+
+## 🔓 How to Unlock a Protected Task
+
+### Step 1: Get the Task ID
+```bash
+node show-protection-status.js
+```
+Find the task ID from the output.
+
+### Step 2: Use the Unlock Function
+```javascript
+const { unlockProtectedTask } = require('./enhanced-protection-system.js');
+
+// Unlock a specific task
+await unlockProtectedTask('TASK_ID_HERE', 'UNLOCK_WEEK1_WEEK2_2024');
+```
+
+### Step 3: Make Your Changes
+Once unlocked, you can modify the task normally.
+
+### Step 4: Re-lock (Optional)
+After making changes, you can re-lock the task:
+```bash
+node lock-week1-week2-tasks.js
+```
+
+## ✅ Safe Operations
+
+### For Non-Protected Tasks
+Use these functions for safe operations:
+
+```javascript
+const { safeUpdateTask, safeDeleteTask } = require('./enhanced-protection-system.js');
+
+// Safe update
+await safeUpdateTask(taskId, { content: 'New content' }, 'Update reason');
+
+// Safe delete
+await safeDeleteTask(taskId, 'Delete reason');
+```
+
+### For Protected Tasks
+1. **Unlock first**: Use `unlockProtectedTask(taskId, key)`
+2. **Make changes**: Update normally
+3. **Re-lock**: Run the locking script again
+
+## 🚨 Important Notes
+
+### Protection Features
+- ✅ **Automatic Protection**: Week 1 and Week 2 tasks are automatically protected
+- ✅ **Clear Messages**: System provides clear feedback when operations are blocked
+- ✅ **Modification History**: All changes are tracked with timestamps and reasons
+- ✅ **Special Key Required**: Unlock key prevents accidental unlocking
+
+### Safety Measures
+- ✅ **No Automatic Unlocking**: Tasks stay locked until manually unlocked
+- ✅ **Key Verification**: Invalid keys are rejected
+- ✅ **History Tracking**: All modifications are logged
+- ✅ **Safe Functions**: Use `safeUpdateTask()` and `safeDeleteTask()` for protection
+
+## 🔍 Troubleshooting
+
+### Task Won't Update
+**Problem**: Getting "CANNOT UPDATE: Task is PROTECTED" error
+**Solution**: 
+1. Unlock the task: `unlockProtectedTask(taskId, 'UNLOCK_WEEK1_WEEK2_2024')`
+2. Make your changes
+3. Re-lock if needed
+
+### Can't Find Task ID
+**Problem**: Don't know the task ID
+**Solution**: Run `node show-protection-status.js` to see all task IDs
+
+### Invalid Unlock Key
+**Problem**: Getting "Invalid unlock key" error
+**Solution**: Use the correct key: `UNLOCK_WEEK1_WEEK2_2024`
+
+## 📝 Best Practices
+
+1. **Always check protection status** before making changes
+2. **Use safe functions** (`safeUpdateTask`, `safeDeleteTask`) when possible
+3. **Document your changes** with clear reasons
+4. **Re-lock tasks** after making necessary changes
+5. **Keep the unlock key secure** and don't share it publicly
+
+## 🔐 Security Notes
+
+- The unlock key is currently hardcoded for simplicity
+- In production, consider using environment variables or a more secure method
+- The protection system prevents accidental changes but doesn't replace proper backup procedures
+- Always backup your database before making significant changes
+
+## 📞 Support
+
+If you encounter issues with the protection system:
+1. Check the protection status first
+2. Verify you're using the correct task ID
+3. Ensure you're using the correct unlock key
+4. Check the modification history for recent changes 

README.md

@@ -1,12 +1,75 @@
 ---
-title: TransHub Backend
-emoji: 📈
-colorFrom: pink
-colorTo: green
+title: Transcreation Backend
+emoji: 🔧
+colorFrom: blue
+colorTo: indigo
 sdk: docker
 pinned: false
-license: mit
-short_description: Online collaborative translation platform (backend)
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Cultural Shift Sandbox - Backend API
+
+A Node.js/Express backend API for the Cultural Shift Sandbox, a web-based tool for postgraduate translation students to practice transcreation and intercultural mediation.
+
+## Features
+
+- **User Authentication**: Login and registration system
+- **Tutorial Tasks**: Weekly tutorial assignments with translation briefs
+- **Weekly Practice**: Practice exercises with cultural mediation tasks
+- **Submission Management**: Create and manage translation submissions
+- **Voting System**: Vote on peer submissions
+- **Admin Panel**: Manage content and users (admin only)
+- **Search Functionality**: Search through source texts and submissions
+
+## Tech Stack
+
+- **Node.js 18** with Express
+- **MongoDB** with Mongoose ODM
+- **JWT Authentication** (simplified token system)
+- **Rate Limiting** for API protection
+- **CORS** enabled for frontend communication
+- **Docker** for containerization
+
+## Environment Variables
+
+Set these in your Space settings:
+
+- `MONGODB_URI`: Your MongoDB Atlas connection string
+- `NODE_ENV`: `production`
+- `PORT`: `5000` (default)
+
+## API Endpoints
+
+### Authentication
+- `POST /api/auth/register` - User registration
+- `POST /api/auth/login` - User login
+- `GET /api/auth/profile` - Get user profile
+
+### Source Texts
+- `GET /api/source-texts/tutorial-tasks` - Get tutorial tasks
+- `GET /api/source-texts/weekly-practice` - Get weekly practice texts
+- `POST /api/source-texts` - Create new source text (admin)
+
+### Submissions
+- `GET /api/submissions/voteable` - Get submissions for voting
+- `GET /api/submissions/my-submissions` - Get user's submissions
+- `POST /api/submissions` - Create new submission
+- `POST /api/submissions/:id/vote` - Vote on submission
+
+### Search
+- `GET /api/search` - Search source texts and submissions
+
+### Health Check
+- `GET /api/health` - API health status
+- `GET /health` - Simple health check
+
+## Development
+
+This Space serves the backend API for the Cultural Shift Sandbox application. The frontend should be deployed separately and configured to communicate with this API.
+
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference 
+Build trigger: 2025-08-28T12:42:29Z
+
+Build trigger: 2025-09-01T14:21:53Z

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-system.js

@@ -0,0 +1,153 @@
+const mongoose = require('mongoose');
+const fs = require('fs').promises;
+const path = require('path');
+const Submission = require('./models/Submission');
+const SourceText = require('./models/SourceText');
+const User = require('./models/User');
+const MONGODB_URI = 'mongodb+srv://nothingyu:wSg3lbO1PkHiRMq9@sandbox.ecysggv.mongodb.net/?retryWrites=true&w=majority&appName=sandbox';
+
+class BackupSystem {
+  constructor() {
+    this.backupDir = path.join(__dirname, 'backups');
+    this.ensureBackupDir();
+  }
+
+  async ensureBackupDir() {
+    try {
+      await fs.mkdir(this.backupDir, { recursive: true });
+    } catch (error) {
+      console.error('Failed to create backup directory:', error);
+    }
+  }
+
+  async createBackup() {
+    try {
+      console.log('🔄 Creating database backup...');
+      await mongoose.connect(MONGODB_URI);
+
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupData = {
+        timestamp,
+        collections: {}
+      };
+
+      // Backup Users
+      console.log('📋 Backing up users...');
+      const users = await User.find({});
+      backupData.collections.users = users.map(user => user.toObject());
+
+      // Backup SourceTexts
+      console.log('📚 Backing up source texts...');
+      const sourceTexts = await SourceText.find({});
+      backupData.collections.sourceTexts = sourceTexts.map(text => text.toObject());
+
+      // Backup Submissions
+      console.log('📝 Backing up submissions...');
+      const submissions = await Submission.find({});
+      backupData.collections.submissions = submissions.map(sub => sub.toObject());
+
+      // Save backup to file
+      const backupFile = path.join(this.backupDir, `backup-${timestamp}.json`);
+      await fs.writeFile(backupFile, JSON.stringify(backupData, null, 2));
+
+      console.log(`✅ Backup created: ${backupFile}`);
+      console.log(`📊 Backup summary:`);
+      console.log(`  - Users: ${users.length}`);
+      console.log(`  - Source Texts: ${sourceTexts.length}`);
+      console.log(`  - Submissions: ${submissions.length}`);
+
+      return backupFile;
+    } catch (error) {
+      console.error('❌ Backup failed:', error);
+      throw error;
+    } finally {
+      await mongoose.connection.close();
+    }
+  }
+
+  async restoreBackup(backupFile) {
+    try {
+      console.log(`🔄 Restoring from backup: ${backupFile}`);
+      await mongoose.connect(MONGODB_URI);
+
+      const backupData = JSON.parse(await fs.readFile(backupFile, 'utf8'));
+
+      // Clear existing data
+      console.log('🗑️ Clearing existing data...');
+      await User.deleteMany({});
+      await SourceText.deleteMany({});
+      await Submission.deleteMany({});
+
+      // Restore Users
+      console.log('👥 Restoring users...');
+      if (backupData.collections.users) {
+        await User.insertMany(backupData.collections.users);
+      }
+
+      // Restore SourceTexts
+      console.log('📚 Restoring source texts...');
+      if (backupData.collections.sourceTexts) {
+        await SourceText.insertMany(backupData.collections.sourceTexts);
+      }
+
+      // Restore Submissions
+      console.log('📝 Restoring submissions...');
+      if (backupData.collections.submissions) {
+        await Submission.insertMany(backupData.collections.submissions);
+      }
+
+      console.log('✅ Backup restored successfully!');
+    } catch (error) {
+      console.error('❌ Restore failed:', error);
+      throw error;
+    } finally {
+      await mongoose.connection.close();
+    }
+  }
+
+  async listBackups() {
+    try {
+      const files = await fs.readdir(this.backupDir);
+      const backups = files.filter(file => file.startsWith('backup-') && file.endsWith('.json'));
+      
+      console.log('📋 Available backups:');
+      backups.forEach(backup => {
+        console.log(`  - ${backup}`);
+      });
+      
+      return backups;
+    } catch (error) {
+      console.error('❌ Failed to list backups:', error);
+      return [];
+    }
+  }
+
+  async scheduleBackup() {
+    // Create backup every 24 hours
+    setInterval(async () => {
+      try {
+        await this.createBackup();
+        console.log('✅ Scheduled backup completed');
+      } catch (error) {
+        console.error('❌ Scheduled backup failed:', error);
+      }
+    }, 24 * 60 * 60 * 1000); // 24 hours
+  }
+}
+
+// Export for use in other files
+module.exports = BackupSystem;
+
+// If run directly, create a backup
+if (require.main === module) {
+  const backupSystem = new BackupSystem();
+  backupSystem.createBackup()
+    .then(() => {
+      console.log('🎉 Backup completed successfully!');
+      process.exit(0);
+    })
+    .catch(error => {
+      console.error('💥 Backup failed:', error);
+      process.exit(1);
+    });
+} 

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/backup-2025-08-04T06-24-14-836Z.json

@@ -0,0 +1,617 @@
+{
+  "timestamp": "2025-08-04T06-24-14-836Z",
+  "collections": {
+    "users": [
+      {
+        "_id": "688f54a81fdede6af7eb6b14",
+        "email": "admin@example.com",
+        "__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": "admin"
+      },
+      {
+        "_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"
+      }
+    ],
+    "sourceTexts": [
+      {
+        "_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,
+        "culturalElements": [],
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "createdAt": "2025-08-03T00:49:18.875Z",
+        "updatedAt": "2025-08-04T05:15:10.580Z",
+        "__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,
+        "culturalElements": [],
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "createdAt": "2025-08-03T00:49:18.876Z",
+        "updatedAt": "2025-08-04T05:15:10.580Z",
+        "__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,
+        "culturalElements": [],
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "createdAt": "2025-08-03T00:49:18.877Z",
+        "updatedAt": "2025-08-04T05:15:10.580Z",
+        "__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,
+        "culturalElements": [],
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "createdAt": "2025-08-03T00:49:18.878Z",
+        "updatedAt": "2025-08-04T05:15:10.580Z",
+        "__v": 0
+      },
+      {
+        "_id": "689041ded51e5886c0205aaa",
+        "title": "Chinese Pun 1",
+        "content": "为什么睡前一定要吃夜宵？因为这样才不会做饿梦。",
+        "sourceLanguage": "Chinese",
+        "sourceType": "manual",
+        "category": "weekly-practice",
+        "weekNumber": 1,
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:15:10.506Z",
+        "updatedAt": "2025-08-04T05:15:10.506Z"
+      },
+      {
+        "_id": "689041ded51e5886c0205aab",
+        "title": "Chinese Pun 2",
+        "content": "女娲用什么补天？强扭的瓜。",
+        "sourceLanguage": "Chinese",
+        "sourceType": "manual",
+        "category": "weekly-practice",
+        "weekNumber": 1,
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:15:10.506Z",
+        "updatedAt": "2025-08-04T05:15:10.506Z"
+      },
+      {
+        "_id": "689041ded51e5886c0205aac",
+        "title": "Chinese Pun 3",
+        "content": "什么动物最容易摔倒？狐狸，因为它狡猾（脚滑）。",
+        "sourceLanguage": "Chinese",
+        "sourceType": "manual",
+        "category": "weekly-practice",
+        "weekNumber": 1,
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:15:10.506Z",
+        "updatedAt": "2025-08-04T05:15:10.506Z"
+      },
+      {
+        "_id": "689041ded51e5886c0205aad",
+        "title": "English Joke 1",
+        "content": "Why don't scientists trust atoms? Because they make up everything!",
+        "sourceLanguage": "English",
+        "sourceType": "manual",
+        "category": "weekly-practice",
+        "weekNumber": 1,
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:15:10.506Z",
+        "updatedAt": "2025-08-04T05:15:10.506Z"
+      },
+      {
+        "_id": "689041ded51e5886c0205aae",
+        "title": "English Joke 2",
+        "content": "What do you call a fake noodle? An impasta!",
+        "sourceLanguage": "English",
+        "sourceType": "manual",
+        "category": "weekly-practice",
+        "weekNumber": 1,
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:15:10.506Z",
+        "updatedAt": "2025-08-04T05:15:10.506Z"
+      },
+      {
+        "_id": "689041ded51e5886c0205aaf",
+        "title": "English Joke 3",
+        "content": "Why did the scarecrow win an award? Because he was outstanding in his field!",
+        "sourceLanguage": "English",
+        "sourceType": "manual",
+        "category": "weekly-practice",
+        "weekNumber": 1,
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:15:10.506Z",
+        "updatedAt": "2025-08-04T05:15:10.506Z"
+      },
+      {
+        "_id": "68904513483967a3d97c65e5",
+        "title": "Tutorial Task 1 - Gulangyu Stone",
+        "content": "本屿西南临海处，有一奇礁，传为\"鼓浪石\"。\"鼓浪\"一名不仅名出实据且诗意磅礴，因此逐渐取代早前随意粗陋的\"圆洲仔\"，成为本岛雅名。日光岩上现存年代最早的石刻，便是曾任泉州府同知的丁一中，于明代万历元年手书的\"鼓浪洞天\"四字。",
+        "sourceLanguage": "Chinese",
+        "sourceType": "manual",
+        "category": "tutorial",
+        "weekNumber": 1,
+        "translationBrief": "The municipal government of Xiamen plans to launch an international campaign to attract foreign investors and tourists. As part of the campaign, they're commissioning an English translation of a Chinese booklet about the city's history of foreign trade and cultural exchange, in addition to its tourist attractions. You've been provided with the following excerpt for a test translation. They are aware that certain elements in the source text might not work well when translated into English for promotional purposes. So you're given the license to make changes where appropriate, but a list of such changes should be provided for the reference of the commissioner.",
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:28:51.743Z",
+        "updatedAt": "2025-08-04T05:28:51.743Z"
+      },
+      {
+        "_id": "68904513483967a3d97c65e6",
+        "title": "Tutorial Task 2 - Gulangyu Geology",
+        "content": "鼓浪屿的地质由1亿多年前的燕山晚期中粒花岗岩构成。而鼓浪屿的植被似乎比磬石还要坚挺，千奇百怪的树木花草，如天外来客，见隙扎根, 逢��生长。岩有多高，它们就长在多高；石有多峭，它们就长得多俏，近看是翠润点点，杂树生花；远观是青岚片片，染上云间。大自然的鬼斧神工，独钟神秀，把鼓浪屿雕塑成人工造景望尘莫及的纯天然景观。如此地形地貌，再衬之以碧海蓝天，成就了小小鼓浪屿，宛如伊人，在水中央，波光潋滟，旖旎无限的绝世美感。",
+        "sourceLanguage": "Chinese",
+        "sourceType": "manual",
+        "category": "tutorial",
+        "weekNumber": 1,
+        "translationBrief": "The municipal government of Xiamen plans to launch an international campaign to attract foreign investors and tourists. As part of the campaign, they're commissioning an English translation of a Chinese booklet about the city's history of foreign trade and cultural exchange, in addition to its tourist attractions. You've been provided with the following excerpt for a test translation. They are aware that certain elements in the source text might not work well when translated into English for promotional purposes. So you're given the license to make changes where appropriate, but a list of such changes should be provided for the reference of the commissioner.",
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:28:51.743Z",
+        "updatedAt": "2025-08-04T05:28:51.743Z"
+      },
+      {
+        "_id": "68904513483967a3d97c65e7",
+        "title": "Tutorial Task 3 - Opium War History",
+        "content": "鸦片战争期间，英国舰队侵入厦门。随后，厦门被划为\"五口通商\"口岸之一，西方列强得以名正言顺地进驻厦门。传教士、政客、商人等各行各业人等，纷至沓来，把鼓浪屿变成大清国的化外之地，安居天堂。他们在岛上设立现代管理机构，如工部局、会审公堂、理船厅公所等；开办公司、企业、洋行、如大北电报公司、汇丰银行、德记洋行、和记洋行等；创办现代医疗机构推行西医疗法，如救世、博爱，还有为妇女专设的威廉明娜等医院；建造宗教场所传播福音，如福音堂、天主堂、三一堂等。。。",
+        "sourceLanguage": "Chinese",
+        "sourceType": "manual",
+        "category": "tutorial",
+        "weekNumber": 1,
+        "translationBrief": "The municipal government of Xiamen plans to launch an international campaign to attract foreign investors and tourists. As part of the campaign, they're commissioning an English translation of a Chinese booklet about the city's history of foreign trade and cultural exchange, in addition to its tourist attractions. You've been provided with the following excerpt for a test translation. They are aware that certain elements in the source text might not work well when translated into English for promotional purposes. So you're given the license to make changes where appropriate, but a list of such changes should be provided for the reference of the commissioner.",
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:28:51.744Z",
+        "updatedAt": "2025-08-04T05:28:51.744Z"
+      },
+      {
+        "_id": "68904513483967a3d97c65ea",
+        "title": "Tutorial Task 1 - Dog Puffer Jacket",
+        "content": "Dog Puffer Jacket - Premium quality winter wear for your beloved pet.",
+        "sourceLanguage": "English",
+        "sourceType": "manual",
+        "category": "tutorial",
+        "weekNumber": 2,
+        "translationBrief": "You have been asked to translate the following for marketing the product in a country where your LOTE is spoken.",
+        "imageUrl": "https://example.com/dog-puffer-1.jpg",
+        "imageAlt": "Dog Puffer Jacket 1",
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:28:51.846Z",
+        "updatedAt": "2025-08-04T05:28:51.846Z"
+      },
+      {
+        "_id": "68904513483967a3d97c65eb",
+        "title": "Tutorial Task 2 - Dog Puffer Jacket",
+        "content": "Keep your dog warm and stylish with our comfortable puffer jacket.",
+        "sourceLanguage": "English",
+        "sourceType": "manual",
+        "category": "tutorial",
+        "weekNumber": 2,
+        "translationBrief": "You have been asked to translate the following for marketing the product in a country where your LOTE is spoken.",
+        "imageUrl": "https://example.com/dog-puffer-2.jpg",
+        "imageAlt": "Dog Puffer Jacket 2",
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:28:51.846Z",
+        "updatedAt": "2025-08-04T05:28:51.846Z"
+      },
+      {
+        "_id": "68904513483967a3d97c65ec",
+        "title": "Tutorial Task 3 - Dog Puffer Jacket",
+        "content": "Water-resistant material ensures your dog stays dry in any weather.",
+        "sourceLanguage": "English",
+        "sourceType": "manual",
+        "category": "tutorial",
+        "weekNumber": 2,
+        "translationBrief": "You have been asked to translate the following for marketing the product in a country where your LOTE is spoken.",
+        "imageUrl": "https://example.com/dog-puffer-3.jpg",
+        "imageAlt": "Dog Puffer Jacket 3",
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:28:51.846Z",
+        "updatedAt": "2025-08-04T05:28:51.846Z"
+      },
+      {
+        "_id": "68904513483967a3d97c65ed",
+        "title": "Tutorial Task 4 - Dog Puffer Jacket",
+        "content": "Available in multiple sizes to fit dogs of all breeds and ages.",
+        "sourceLanguage": "English",
+        "sourceType": "manual",
+        "category": "tutorial",
+        "weekNumber": 2,
+        "translationBrief": "You have been asked to translate the following for marketing the product in a country where your LOTE is spoken.",
+        "imageUrl": "https://example.com/dog-puffer-4.jpg",
+        "imageAlt": "Dog Puffer Jacket 4",
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:28:51.846Z",
+        "updatedAt": "2025-08-04T05:28:51.846Z"
+      },
+      {
+        "_id": "68904513483967a3d97c65ee",
+        "title": "Tutorial Task 5 - Dog Puffer Jacket",
+        "content": "Easy to put on and take off with secure Velcro fastenings.",
+        "sourceLanguage": "English",
+        "sourceType": "manual",
+        "category": "tutorial",
+        "weekNumber": 2,
+        "translationBrief": "You have been asked to translate the following for marketing the product in a country where your LOTE is spoken.",
+        "imageUrl": "https://example.com/dog-puffer-5.jpg",
+        "imageAlt": "Dog Puffer Jacket 5",
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:28:51.846Z",
+        "updatedAt": "2025-08-04T05:28:51.846Z"
+      },
+      {
+        "_id": "68904513483967a3d97c65ef",
+        "title": "Tutorial Task 6 - Dog Puffer Jacket",
+        "content": "Lightweight design allows for maximum comfort and mobility.",
+        "sourceLanguage": "English",
+        "sourceType": "manual",
+        "category": "tutorial",
+        "weekNumber": 2,
+        "translationBrief": "You have been asked to translate the following for marketing the product in a country where your LOTE is spoken.",
+        "imageUrl": "https://example.com/dog-puffer-6.jpg",
+        "imageAlt": "Dog Puffer Jacket 6",
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:28:51.846Z",
+        "updatedAt": "2025-08-04T05:28:51.846Z"
+      },
+      {
+        "_id": "68904513483967a3d97c65f0",
+        "title": "Tutorial Task 7 - Dog Puffer Jacket",
+        "content": "Reflective strips for visibility during evening walks.",
+        "sourceLanguage": "English",
+        "sourceType": "manual",
+        "category": "tutorial",
+        "weekNumber": 2,
+        "translationBrief": "You have been asked to translate the following for marketing the product in a country where your LOTE is spoken.",
+        "imageUrl": "https://example.com/dog-puffer-7.jpg",
+        "imageAlt": "Dog Puffer Jacket 7",
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:28:51.847Z",
+        "updatedAt": "2025-08-04T05:28:51.847Z"
+      },
+      {
+        "_id": "68904513483967a3d97c65f1",
+        "title": "Tutorial Task 8 - Dog Puffer Jacket",
+        "content": "Machine washable for easy care and maintenance.",
+        "sourceLanguage": "English",
+        "sourceType": "manual",
+        "category": "tutorial",
+        "weekNumber": 2,
+        "translationBrief": "You have been asked to translate the following for marketing the product in a country where your LOTE is spoken.",
+        "imageUrl": "https://example.com/dog-puffer-8.jpg",
+        "imageAlt": "Dog Puffer Jacket 8",
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:28:51.847Z",
+        "updatedAt": "2025-08-04T05:28:51.847Z"
+      },
+      {
+        "_id": "68904513483967a3d97c65f2",
+        "title": "Tutorial Task 9 - Dog Puffer Jacket",
+        "content": "Durable construction ensures long-lasting performance.",
+        "sourceLanguage": "English",
+        "sourceType": "manual",
+        "category": "tutorial",
+        "weekNumber": 2,
+        "translationBrief": "You have been asked to translate the following for marketing the product in a country where your LOTE is spoken.",
+        "imageUrl": "https://example.com/dog-puffer-9.jpg",
+        "imageAlt": "Dog Puffer Jacket 9",
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:28:51.847Z",
+        "updatedAt": "2025-08-04T05:28:51.847Z"
+      },
+      {
+        "_id": "68904513483967a3d97c65f3",
+        "title": "Tutorial Task 10 - Dog Puffer Jacket",
+        "content": "Perfect for cold weather protection during outdoor activities.",
+        "sourceLanguage": "English",
+        "sourceType": "manual",
+        "category": "tutorial",
+        "weekNumber": 2,
+        "translationBrief": "You have been asked to translate the following for marketing the product in a country where your LOTE is spoken.",
+        "imageUrl": "https://example.com/dog-puffer-10.jpg",
+        "imageAlt": "Dog Puffer Jacket 10",
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:28:51.847Z",
+        "updatedAt": "2025-08-04T05:28:51.847Z"
+      },
+      {
+        "_id": "68904513483967a3d97c65f4",
+        "title": "Tutorial Task 11 - Dog Puffer Jacket",
+        "content": "Breathable fabric prevents overheating during active play.",
+        "sourceLanguage": "English",
+        "sourceType": "manual",
+        "category": "tutorial",
+        "weekNumber": 2,
+        "translationBrief": "You have been asked to translate the following for marketing the product in a country where your LOTE is spoken.",
+        "imageUrl": "https://example.com/dog-puffer-11.jpg",
+        "imageAlt": "Dog Puffer Jacket 11",
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:28:51.847Z",
+        "updatedAt": "2025-08-04T05:28:51.847Z"
+      },
+      {
+        "_id": "68904513483967a3d97c65f5",
+        "title": "Tutorial Task 12 - Dog Puffer Jacket",
+        "content": "Stylish design that complements your dog's personality.",
+        "sourceLanguage": "English",
+        "sourceType": "manual",
+        "category": "tutorial",
+        "weekNumber": 2,
+        "translationBrief": "You have been asked to translate the following for marketing the product in a country where your LOTE is spoken.",
+        "imageUrl": "https://example.com/dog-puffer-12.jpg",
+        "imageAlt": "Dog Puffer Jacket 12",
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "__v": 0,
+        "createdAt": "2025-08-04T05:28:51.847Z",
+        "updatedAt": "2025-08-04T05:28:51.847Z"
+      },
+      {
+        "_id": "6890456c7488d1d08d79de66",
+        "title": "Week 2 Weekly Practice - Nike Video",
+        "content": "Nike video with subtitles for translation practice. Video features Nike advertising content with multiple segments for subtitle translation.",
+        "sourceLanguage": "English",
+        "sourceType": "manual",
+        "category": "weekly-practice",
+        "weekNumber": 2,
+        "difficulty": "intermediate",
+        "tags": [],
+        "targetCultures": [],
+        "isActive": true,
+        "usageCount": 0,
+        "averageRating": 0,
+        "ratingCount": 0,
+        "isCurrent": false,
+        "culturalElements": [],
+        "createdAt": "2025-08-04T05:30:20.760Z",
+        "updatedAt": "2025-08-04T05:30:20.760Z",
+        "__v": 0
+      }
+    ],
+    "submissions": []
+  }
+}

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:cd7316df6f9d14c57bbc956d6ef7101e513ed2fb947986ac501c5225c6a229a3
+size 133

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:d681c1aa709ca7e6283dc4f33915c3446c21b226915d9c5c2026b4ee92a60f39
+size 133

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(); 

enhanced-protection-system.js

@@ -0,0 +1,270 @@
+const mongoose = require('mongoose');
+const SourceText = require('./models/SourceText');
+
+// MongoDB connection
+const MONGODB_URI = process.env.MONGODB_URI || 'mongodb+srv://nothingyu:wSg3lbO1PkHiRMq9@sandbox.ecysggv.mongodb.net/?retryWrites=true&w=majority&appName=sandbox';
+
+// ENHANCED PROTECTION FUNCTIONS
+
+async function safeUpdateTask(taskId, updates, reason = 'No reason provided') {
+  try {
+    console.log('🌐 Connecting to MongoDB...');
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to MongoDB');
+
+    const task = await SourceText.findById(taskId);
+    
+    if (!task) {
+      console.log(`❌ Task with ID ${taskId} not found`);
+      return false;
+    }
+
+    if (task.isProtected) {
+      console.log(`🚫 CANNOT UPDATE: Task "${task.title}" is PROTECTED`);
+      console.log(`   Reason: ${task.protectedReason}`);
+      console.log(`   To update this task, you must first unlock it with the special key`);
+      return false;
+    }
+
+    // Safe to update
+    const updatedTask = await SourceText.findByIdAndUpdate(
+      taskId,
+      { 
+        ...updates,
+        lastModified: new Date(),
+        modificationHistory: [
+          ...(task.modificationHistory || []),
+          {
+            action: 'UPDATED',
+            timestamp: new Date(),
+            reason: reason
+          }
+        ]
+      },
+      { new: true }
+    );
+
+    console.log(`✅ Updated task: ${updatedTask.title}`);
+    return true;
+
+  } catch (error) {
+    console.error('❌ Error updating task:', error);
+    return false;
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+}
+
+async function safeDeleteTask(taskId, reason = 'No reason provided') {
+  try {
+    console.log('🌐 Connecting to MongoDB...');
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to MongoDB');
+
+    const task = await SourceText.findById(taskId);
+    
+    if (!task) {
+      console.log(`❌ Task with ID ${taskId} not found`);
+      return false;
+    }
+
+    if (task.isProtected) {
+      console.log(`🚫 CANNOT DELETE: Task "${task.title}" is PROTECTED`);
+      console.log(`   Reason: ${task.protectedReason}`);
+      console.log(`   To delete this task, you must first unlock it with the special key`);
+      return false;
+    }
+
+    // Safe to delete
+    const deletedTask = await SourceText.findByIdAndDelete(taskId);
+    console.log(`✅ Deleted task: ${deletedTask.title}`);
+    return true;
+
+  } catch (error) {
+    console.error('❌ Error deleting task:', error);
+    return false;
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+}
+
+async function unlockProtectedTask(taskId, unlockKey) {
+  try {
+    console.log('🌐 Connecting to MongoDB...');
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to MongoDB');
+
+    // Simple unlock key - in production, use a more secure method
+    const VALID_UNLOCK_KEY = 'UNLOCK_WEEK1_WEEK2_2024';
+    
+    if (unlockKey !== VALID_UNLOCK_KEY) {
+      console.log('❌ Invalid unlock key. Protected tasks cannot be unlocked.');
+      return false;
+    }
+
+    const task = await SourceText.findById(taskId);
+    
+    if (!task) {
+      console.log(`❌ Task with ID ${taskId} not found`);
+      return false;
+    }
+
+    if (!task.isProtected) {
+      console.log(`⚠️  Task "${task.title}" is not protected`);
+      return false;
+    }
+
+    const updatedTask = await SourceText.findByIdAndUpdate(
+      taskId,
+      { 
+        isProtected: false,
+        protectedReason: null,
+        lastModified: new Date(),
+        modificationHistory: [
+          ...(task.modificationHistory || []),
+          {
+            action: 'UNLOCKED',
+            timestamp: new Date(),
+            reason: 'Task unlocked with valid key'
+          }
+        ]
+      },
+      { new: true }
+    );
+
+    console.log(`✅ Unlocked task: ${updatedTask.title}`);
+    return true;
+
+  } catch (error) {
+    console.error('❌ Error unlocking task:', error);
+    return false;
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+}
+
+async function showProtectedTasks() {
+  try {
+    console.log('🌐 Connecting to MongoDB...');
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to MongoDB');
+
+    const protectedTasks = await SourceText.find({ 
+      isProtected: true 
+    }).sort({ weekNumber: 1, title: 1 });
+    
+    console.log(`\n🔒 PROTECTED TASKS (${protectedTasks.length} total):`);
+    
+    protectedTasks.forEach((task, index) => {
+      console.log(`${index + 1}. Week ${task.weekNumber} - ${task.title}`);
+      console.log(`   ID: ${task._id}`);
+      console.log(`   Protected: ${task.isProtected ? 'YES' : 'NO'}`);
+      console.log(`   Reason: ${task.protectedReason}`);
+      console.log(`   Last Modified: ${task.lastModified}`);
+      console.log('---');
+    });
+
+  } catch (error) {
+    console.error('❌ Error showing protected tasks:', error);
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+}
+
+async function testEnhancedProtection() {
+  try {
+    console.log('🌐 Connecting to MongoDB...');
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to MongoDB');
+
+    // Find a protected task to test
+    const protectedTask = await SourceText.findOne({ 
+      isProtected: true,
+      weekNumber: 1
+    });
+
+    if (!protectedTask) {
+      console.log('❌ No protected tasks found');
+      return;
+    }
+
+    console.log(`\n🧪 TESTING ENHANCED PROTECTION SYSTEM:`);
+    console.log(`   Task: ${protectedTask.title}`);
+    console.log(`   ID: ${protectedTask._id}`);
+    console.log(`   Protected: ${protectedTask.isProtected ? 'YES' : 'NO'}`);
+    console.log(`   Reason: ${protectedTask.protectedReason}`);
+
+    // Test 1: Try to update a protected task using safe function
+    console.log('\n🔒 TEST 1: Attempting to update protected task using safe function...');
+    const updateResult = await safeUpdateTask(
+      protectedTask._id, 
+      { content: 'This should not work!' },
+      'Test update'
+    );
+    
+    if (!updateResult) {
+      console.log('✅ PROTECTION WORKING: Update was prevented');
+    } else {
+      console.log('❌ PROTECTION FAILED: Task was updated despite being protected!');
+    }
+
+    // Test 2: Try to delete a protected task using safe function
+    console.log('\n🔒 TEST 2: Attempting to delete protected task using safe function...');
+    const deleteResult = await safeDeleteTask(
+      protectedTask._id, 
+      'Test deletion'
+    );
+    
+    if (!deleteResult) {
+      console.log('✅ PROTECTION WORKING: Deletion was prevented');
+    } else {
+      console.log('❌ PROTECTION FAILED: Task was deleted despite being protected!');
+    }
+
+    // Test 3: Show how to safely unlock a task
+    console.log('\n🔓 TEST 3: Demonstrating unlock process...');
+    console.log('   To unlock a protected task, you need the special key:');
+    console.log('   Key: UNLOCK_WEEK1_WEEK2_2024');
+    console.log('   Usage: unlockProtectedTask(taskId, key)');
+
+    // Test 4: Show current protection status
+    console.log('\n📊 PROTECTION STATUS:');
+    const allProtectedTasks = await SourceText.find({ isProtected: true });
+    const week1Protected = allProtectedTasks.filter(t => t.weekNumber === 1).length;
+    const week2Protected = allProtectedTasks.filter(t => t.weekNumber === 2).length;
+    
+    console.log(`   Week 1 protected tasks: ${week1Protected}`);
+    console.log(`   Week 2 protected tasks: ${week2Protected}`);
+    console.log(`   Total protected tasks: ${allProtectedTasks.length}`);
+
+    console.log('\n🎉 ENHANCED PROTECTION SYSTEM TEST COMPLETE');
+    console.log('\n📋 PROTECTION SUMMARY:');
+    console.log('   ✅ Week 1 and Week 2 tutorial tasks are LOCKED');
+    console.log('   ✅ Protected tasks cannot be accidentally modified');
+    console.log('   ✅ Special key required to unlock tasks');
+    console.log('   ✅ Modification history is tracked');
+    console.log('   ✅ Use safeUpdateTask() and safeDeleteTask() functions');
+
+  } catch (error) {
+    console.error('❌ Error testing enhanced protection system:', error);
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+}
+
+// Export functions for safe operations
+module.exports = {
+  safeUpdateTask,
+  safeDeleteTask,
+  unlockProtectedTask,
+  showProtectedTasks,
+  testEnhancedProtection
+};
+
+// Run the enhanced test
+testEnhancedProtection(); 

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();
+}); 

index.js

@@ -0,0 +1,289 @@
+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');
+const weeklyPracticeFilesRoutes = require('./routes/weeklyPracticeFiles');
+const dictionaryRoutes = require('./routes/dictionary');
+const icibaRoutes = require('./routes/iciba');
+const oneRoutes = require('./routes/one');
+const mtRoutes = require('./routes/mt');
+const slidesRoutes = require('./routes/slides');
+const messagesRoutes = require('./routes/messages');
+const linksRoutes = require('./routes/links');
+const docsRoutes = require('./routes/docs');
+
+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);
+app.use('/api/weekly-practice-files', weeklyPracticeFilesRoutes);
+app.use('/api/dictionary', dictionaryRoutes);
+app.use('/api/iciba', icibaRoutes);
+app.use('/api/one', oneRoutes);
+app.use('/api/mt', mtRoutes);
+app.use('/api/slides', slidesRoutes);
+app.use('/api/messages', messagesRoutes);
+app.use('/api/links', linksRoutes);
+app.use('/api/docs', docsRoutes);
+
+// 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}`);
+  // Seed default links if empty (best-effort)
+  (async () => {
+    try {
+      const Link = require('./models/Link');
+      const count = await Link.countDocuments();
+      if (count === 0) {
+        await Link.insertMany([
+          { title: 'AI工具集', url: 'https://ai-bot.cn', desc: 'AI tools directory and learning resources.' },
+          { title: 'Proz.com', url: 'https://www.proz.com', desc: 'Translators community and job marketplace.' },
+          { title: 'Translators without Borders', url: 'https://translatorswithoutborders.org', desc: 'Volunteer translation for humanitarian causes.' },
+          { title: 'TED Translator', url: 'https://www.ted.com/participate/translate', desc: 'Volunteer to translate TED talks.' },
+          { title: 'Matecat', url: 'https://www.matecat.com', desc: 'Free web-based CAT tool with TM/MT support.' }
+        ]);
+        console.log('Seeded default Useful Links');
+      }
+    } catch (e) {
+      console.warn('Unable to seed Useful Links:', e?.message);
+    }
+  })();
+  
+  // 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);
+  }
+}); 

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();
+}); 

lock-week1-week2-tasks.js

@@ -0,0 +1,244 @@
+const mongoose = require('mongoose');
+const SourceText = require('./models/SourceText');
+
+// MongoDB connection
+const MONGODB_URI = process.env.MONGODB_URI || 'mongodb+srv://nothingyu:wSg3lbO1PkHiRMq9@sandbox.ecysggv.mongodb.net/?retryWrites=true&w=majority&appName=sandbox';
+
+async function lockWeek1Week2Tasks() {
+  try {
+    console.log('🌐 Connecting to MongoDB...');
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to MongoDB');
+
+    // Find all Week 1 and Week 2 tutorial tasks
+    const week1Tasks = await SourceText.find({ 
+      category: 'tutorial', 
+      weekNumber: 1 
+    }).sort({ title: 1 });
+    
+    const week2Tasks = await SourceText.find({ 
+      category: 'tutorial', 
+      weekNumber: 2 
+    }).sort({ title: 1 });
+
+    console.log(`📋 Found ${week1Tasks.length} Week 1 tutorial tasks`);
+    console.log(`📋 Found ${week2Tasks.length} Week 2 tutorial tasks`);
+
+    // Lock Week 1 tasks
+    console.log('\n🔒 Locking Week 1 tutorial tasks...');
+    let lockedWeek1Count = 0;
+    for (const task of week1Tasks) {
+      const updatedTask = await SourceText.findByIdAndUpdate(
+        task._id,
+        { 
+          isProtected: true,
+          protectedReason: 'Week 1 tutorial tasks are locked to prevent accidental changes',
+          lastModified: new Date(),
+          modificationHistory: [
+            {
+              action: 'LOCKED',
+              timestamp: new Date(),
+              reason: 'Week 1 tutorial tasks locked for protection'
+            }
+          ]
+        },
+        { new: true }
+      );
+      console.log(`✅ Locked: ${updatedTask.title}`);
+      lockedWeek1Count++;
+    }
+
+    // Lock Week 2 tasks
+    console.log('\n🔒 Locking Week 2 tutorial tasks...');
+    let lockedWeek2Count = 0;
+    for (const task of week2Tasks) {
+      const updatedTask = await SourceText.findByIdAndUpdate(
+        task._id,
+        { 
+          isProtected: true,
+          protectedReason: 'Week 2 tutorial tasks are locked to prevent accidental changes',
+          lastModified: new Date(),
+          modificationHistory: [
+            {
+              action: 'LOCKED',
+              timestamp: new Date(),
+              reason: 'Week 2 tutorial tasks locked for protection'
+            }
+          ]
+        },
+        { new: true }
+      );
+      console.log(`✅ Locked: ${updatedTask.title}`);
+      lockedWeek2Count++;
+    }
+
+    console.log(`\n🎉 LOCKING COMPLETE:`);
+    console.log(`   Week 1: ${lockedWeek1Count} tasks locked`);
+    console.log(`   Week 2: ${lockedWeek2Count} tasks locked`);
+
+    // Verify locked tasks
+    console.log('\n📋 Verification - Locked tasks:');
+    const allLockedTasks = await SourceText.find({ 
+      isProtected: true 
+    }).sort({ weekNumber: 1, title: 1 });
+    
+    allLockedTasks.forEach((task, index) => {
+      console.log(`${index + 1}. Week ${task.weekNumber} - ${task.title}`);
+      console.log(`   Protected: ${task.isProtected ? 'YES' : 'NO'}`);
+      console.log(`   Reason: ${task.protectedReason}`);
+    });
+
+    console.log(`\n📊 Total locked tasks: ${allLockedTasks.length}`);
+
+  } catch (error) {
+    console.error('❌ Error locking tasks:', error);
+    process.exit(1);
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+}
+
+// SAFE UPDATE FUNCTIONS WITH PROTECTION CHECKS
+
+async function safeUpdateProtectedTask(taskId, updates, reason = 'No reason provided') {
+  try {
+    console.log('🌐 Connecting to MongoDB...');
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to MongoDB');
+
+    const task = await SourceText.findById(taskId);
+    
+    if (!task) {
+      console.log(`❌ Task with ID ${taskId} not found`);
+      return;
+    }
+
+    if (task.isProtected) {
+      console.log(`🚫 CANNOT UPDATE: Task "${task.title}" is PROTECTED`);
+      console.log(`   Reason: ${task.protectedReason}`);
+      console.log(`   To update this task, you must first unlock it with a special key`);
+      return;
+    }
+
+    // Safe to update
+    const updatedTask = await SourceText.findByIdAndUpdate(
+      taskId,
+      { 
+        ...updates,
+        lastModified: new Date(),
+        modificationHistory: [
+          ...(task.modificationHistory || []),
+          {
+            action: 'UPDATED',
+            timestamp: new Date(),
+            reason: reason
+          }
+        ]
+      },
+      { new: true }
+    );
+
+    console.log(`✅ Updated task: ${updatedTask.title}`);
+
+  } catch (error) {
+    console.error('❌ Error updating task:', error);
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+}
+
+async function unlockProtectedTask(taskId, unlockKey) {
+  try {
+    console.log('🌐 Connecting to MongoDB...');
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to MongoDB');
+
+    // Simple unlock key - in production, use a more secure method
+    const VALID_UNLOCK_KEY = 'UNLOCK_WEEK1_WEEK2_2024';
+    
+    if (unlockKey !== VALID_UNLOCK_KEY) {
+      console.log('❌ Invalid unlock key. Protected tasks cannot be unlocked.');
+      return;
+    }
+
+    const task = await SourceText.findById(taskId);
+    
+    if (!task) {
+      console.log(`❌ Task with ID ${taskId} not found`);
+      return;
+    }
+
+    if (!task.isProtected) {
+      console.log(`⚠️  Task "${task.title}" is not protected`);
+      return;
+    }
+
+    const updatedTask = await SourceText.findByIdAndUpdate(
+      taskId,
+      { 
+        isProtected: false,
+        protectedReason: null,
+        lastModified: new Date(),
+        modificationHistory: [
+          ...(task.modificationHistory || []),
+          {
+            action: 'UNLOCKED',
+            timestamp: new Date(),
+            reason: 'Task unlocked with valid key'
+          }
+        ]
+      },
+      { new: true }
+    );
+
+    console.log(`✅ Unlocked task: ${updatedTask.title}`);
+
+  } catch (error) {
+    console.error('❌ Error unlocking task:', error);
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+}
+
+async function showProtectedTasks() {
+  try {
+    console.log('🌐 Connecting to MongoDB...');
+    await mongoose.connect(MONGODB_URI);
+    console.log('✅ Connected to MongoDB');
+
+    const protectedTasks = await SourceText.find({ 
+      isProtected: true 
+    }).sort({ weekNumber: 1, title: 1 });
+    
+    console.log(`\n🔒 PROTECTED TASKS (${protectedTasks.length} total):`);
+    
+    protectedTasks.forEach((task, index) => {
+      console.log(`${index + 1}. Week ${task.weekNumber} - ${task.title}`);
+      console.log(`   ID: ${task._id}`);
+      console.log(`   Protected: ${task.isProtected ? 'YES' : 'NO'}`);
+      console.log(`   Reason: ${task.protectedReason}`);
+      console.log(`   Last Modified: ${task.lastModified}`);
+      console.log('---');
+    });
+
+  } catch (error) {
+    console.error('❌ Error showing protected tasks:', error);
+  } finally {
+    await mongoose.disconnect();
+    console.log('🔌 Disconnected from MongoDB');
+  }
+}
+
+// Export functions for safe operations
+module.exports = {
+  lockWeek1Week2Tasks,
+  safeUpdateProtectedTask,
+  unlockProtectedTask,
+  showProtectedTasks
+};
+
+// Run the locking
+lockWeek1Week2Tasks(); 

middleware/auth.js

@@ -0,0 +1,38 @@
+const auth = (req, res, next) => {
+  try {
+    const token = req.header('Authorization')?.replace('Bearer ', '');
+    const userRole = req.header('user-role');
+    
+    if (!token) {
+      return res.status(401).json({
+        success: false,
+        message: 'No token provided'
+      });
+    }
+
+    // Check if token is in the simplified format (user_ or visitor_)
+    if (token.startsWith('user_') || token.startsWith('visitor_')) {
+      // For simplified system, include user role from header
+      const userInfo = req.header('user-info');
+      req.user = { 
+        token,
+        role: userRole || 'visitor', // Default to visitor if no role provided
+        userInfo: userInfo ? JSON.parse(userInfo) : {}
+      };
+      next();
+    } else {
+      return res.status(401).json({
+        success: false,
+        message: 'Invalid token format'
+      });
+    }
+  } catch (error) {
+    console.error('Auth middleware error:', error);
+    res.status(401).json({
+      success: false,
+      message: 'Invalid token'
+    });
+  }
+};
+
+module.exports = auth; 

models/AccessSession.js

@@ -0,0 +1,18 @@
+const mongoose = require('mongoose');
+
+const accessSessionSchema = new mongoose.Schema({
+  email: { type: String, index: true },
+  role: { type: String, enum: ['student', 'instructor', 'admin', 'visitor'], index: true },
+  startAt: { type: Date, default: Date.now, index: true },
+  lastSeen: { type: Date, default: Date.now, index: true },
+  userAgent: { type: String },
+  ip: { type: String },
+  path: { type: String }
+}, { timestamps: true });
+
+// Compound index for querying active sessions by email + startAt
+accessSessionSchema.index({ email: 1, startAt: -1 });
+
+module.exports = mongoose.model('AccessSession', accessSessionSchema);
+
+

models/GroupDoc.js

@@ -0,0 +1,17 @@
+const mongoose = require('mongoose');
+
+const groupDocSchema = new mongoose.Schema({
+  weekNumber: { type: Number, required: true, index: true },
+  groupNumber: { type: Number, required: true, index: true },
+  docId: { type: String, required: true, unique: true },
+  docUrl: { type: String, required: true },
+  title: { type: String },
+  createdBy: { type: String },
+  createdAt: { type: Date, default: Date.now }
+}, { timestamps: true });
+
+groupDocSchema.index({ weekNumber: 1, groupNumber: 1 }, { unique: true });
+
+module.exports = mongoose.model('GroupDoc', groupDocSchema);
+
+

models/Link.js

@@ -0,0 +1,13 @@
+const mongoose = require('mongoose');
+
+const LinkSchema = new mongoose.Schema({
+  title: { type: String, required: true },
+  url: { type: String, required: true },
+  desc: { type: String, default: '' },
+  category: { type: String, default: '' },
+  order: { type: Number, default: 0 }
+}, { timestamps: true });
+
+module.exports = mongoose.model('Link', LinkSchema);
+
+