Upload 45 files

App.tsx

@@ -16,7 +16,6 @@ const SchoolList = React.lazy(() => import('./pages/SchoolList').then(module =>
 const Games = React.lazy(() => import('./pages/Games').then(module => ({ default: module.Games })));
 const AttendancePage = React.lazy(() => import('./pages/Attendance').then(module => ({ default: module.AttendancePage })));
 const Profile = React.lazy(() => import('./pages/Profile').then(module => ({ default: module.Profile })));
-const Wishes = React.lazy(() => import('./pages/Wishes').then(module => ({ default: module.Wishes }))); // NEW
 
 import { Login } from './pages/Login';
 import { User, UserRole } from './types';
@@ -24,7 +23,6 @@ import { api } from './services/api';
 import { AlertTriangle, Loader2 } from 'lucide-react';
 
 class ErrorBoundary extends React.Component<{children: React.ReactNode}, {hasError: boolean, error: Error | null}> {
-  // ... (existing code)
   constructor(props: any) {
     super(props);
     this.state = { hasError: false, error: null };
@@ -125,7 +123,6 @@ const AppContent: React.FC = () => {
       case 'games': return <Games />; 
       case 'attendance': return <AttendancePage />;
       case 'profile': return <Profile />;
-      case 'wishes': return <Wishes />; // NEW
       default: return <Dashboard onNavigate={(view) => setCurrentView(view)} />;
     }
   };
@@ -143,8 +140,7 @@ const AppContent: React.FC = () => {
     schools: '学校维度管理',
     games: '互动教学中心',
     attendance: '考勤管理',
-    profile: '个人中心',
-    wishes: '许愿 & 反馈中心' // NEW
+    profile: '个人中心'
   };
 
   if (loading) return <div className="min-h-screen flex items-center justify-center bg-gray-50 text-blue-600">加载中...</div>;
@@ -165,7 +161,7 @@ const AppContent: React.FC = () => {
       <div className="flex-1 flex flex-col w-full">
         <Header user={currentUser!} title={viewTitles[currentView] || '智慧校园'} onMenuClick={() => setSidebarOpen(true)}/>
         <main className="flex-1 overflow-x-hidden overflow-y-auto bg-gray-50 p-4 md:p-6 w-full">
-          <div className="max-w-7xl mx-auto w-full h-full">
+          <div className="max-w-7xl mx-auto w-full">
             <Suspense fallback={<PageLoading />}>{renderContent()}</Suspense>
           </div>
         </main>

components/Sidebar.tsx

@@ -1,6 +1,6 @@
 
 import React from 'react';
-import { LayoutDashboard, Users, BookOpen, GraduationCap, Settings, LogOut, FileText, School, UserCog, Palette, X, Building, Gamepad2, CalendarCheck, UserCircle, MessageCircle } from 'lucide-react';
+import { LayoutDashboard, Users, BookOpen, GraduationCap, Settings, LogOut, FileText, School, UserCog, Palette, X, Building, Gamepad2, CalendarCheck, UserCircle } from 'lucide-react';
 import { UserRole } from '../types';
 
 interface SidebarProps {
@@ -19,7 +19,6 @@ export const Sidebar: React.FC<SidebarProps> = ({ currentView, onChangeView, use
     { id: 'dashboard', label: '工作台', icon: LayoutDashboard, roles: [UserRole.ADMIN, UserRole.PRINCIPAL, UserRole.TEACHER, UserRole.STUDENT] },
     { id: 'attendance', label: '考勤管理', icon: CalendarCheck, roles: [UserRole.TEACHER, UserRole.PRINCIPAL] }, 
     { id: 'games', label: '互动教学', icon: Gamepad2, roles: [UserRole.TEACHER, UserRole.STUDENT] }, // Removed PRINCIPAL
-    { id: 'wishes', label: '许愿 & 反馈', icon: MessageCircle, roles: [UserRole.ADMIN, UserRole.PRINCIPAL, UserRole.TEACHER, UserRole.STUDENT] }, // NEW
     { id: 'students', label: '学生管理', icon: Users, roles: [UserRole.ADMIN, UserRole.PRINCIPAL, UserRole.TEACHER] },
     { id: 'classes', label: '班级管理', icon: School, roles: [UserRole.ADMIN, UserRole.PRINCIPAL] },
     { id: 'schools', label: '学校管理', icon: Building, roles: [UserRole.ADMIN] }, // Only Super Admin can manage schools

models.js

@@ -1,260 +1,195 @@
 
-// IN-MEMORY DATABASE ENGINE (MOCK MONGOOSE)
-// This allows the app to run without a real MongoDB connection.
+const mongoose = require('mongoose');
+
+// ... (Previous Models: School, User, Student, Course, Score, ClassModel, SubjectModel, ExamModel, ScheduleModel, ConfigModel, NotificationModel, GameSessionModel, StudentRewardModel, LuckyDrawConfigModel, GameMonsterConfigModel, GameZenConfigModel)
+
+const SchoolSchema = new mongoose.Schema({ name: String, code: String });
+const School = mongoose.model('School', SchoolSchema);
+
+const UserSchema = new mongoose.Schema({ 
+    username: String, 
+    password: String, 
+    trueName: String, 
+    phone: String, 
+    email: String, 
+    schoolId: String, 
+    role: String, 
+    status: String, 
+    avatar: String, 
+    createTime: Date, 
+    teachingSubject: String, 
+    homeroomClass: String, 
+    studentNo: String, 
+    parentName: String, 
+    parentPhone: String, 
+    address: String, 
+    gender: String, 
+    seatNo: String, 
+    idCard: String,
+    classApplication: { 
+        type: { type: String }, 
+        targetClass: String, 
+        status: String 
+    } 
+});
+const User = mongoose.model('User', UserSchema);
+
+const StudentSchema = new mongoose.Schema({ 
+    schoolId: String, 
+    studentNo: String, 
+    seatNo: String, 
+    name: String, 
+    gender: String, 
+    birthday: String, 
+    idCard: String, 
+    phone: String, 
+    className: String, 
+    status: String, 
+    parentName: String, 
+    parentPhone: String, 
+    address: String, 
+    teamId: String, 
+    drawAttempts: { type: Number, default: 0 }, 
+    dailyDrawLog: { date: String, count: { type: Number, default: 0 } }, 
+    flowerBalance: { type: Number, default: 0 } 
+});
+const Student = mongoose.model('Student', StudentSchema);
+
+const CourseSchema = new mongoose.Schema({ 
+    schoolId: String, 
+    courseCode: String, 
+    courseName: String, 
+    className: String, 
+    teacherName: String, 
+    teacherId: String, 
+    credits: Number, 
+    capacity: Number, 
+    enrolled: Number 
+});
+CourseSchema.index({ schoolId: 1, className: 1, courseName: 1 }, { unique: true });
+const Course = mongoose.model('Course', CourseSchema);
+
+const ScoreSchema = new mongoose.Schema({ schoolId: String, studentName: String, studentNo: String, courseName: String, score: Number, semester: String, type: String, examName: String, status: String });
+const Score = mongoose.model('Score', ScoreSchema);
+
+const ClassSchema = new mongoose.Schema({ 
+    schoolId: String, 
+    grade: String, 
+    className: String, 
+    teacherName: String, 
+    homeroomTeacherIds: [String] 
+});
+const ClassModel = mongoose.model('Class', ClassSchema);
+
+const SubjectSchema = new mongoose.Schema({ schoolId: String, name: String, code: String, color: String, excellenceThreshold: Number, thresholds: { type: Map, of: Number } });
+const SubjectModel = mongoose.model('Subject', SubjectSchema);
+
+const ExamSchema = new mongoose.Schema({ schoolId: String, name: String, date: String, type: String, semester: String });
+const ExamModel = mongoose.model('Exam', ExamSchema);
+
+const ScheduleSchema = new mongoose.Schema({ schoolId: String, className: String, teacherName: String, subject: String, dayOfWeek: Number, period: Number });
+const ScheduleModel = mongoose.model('Schedule', ScheduleSchema);
+
+const ConfigSchema = new mongoose.Schema({ 
+    key: String, 
+    systemName: String, 
+    semester: String, 
+    semesters: [String], 
+    allowRegister: Boolean, 
+    allowAdminRegister: Boolean, 
+    allowPrincipalRegister: Boolean,
+    allowStudentRegister: Boolean, 
+    maintenanceMode: Boolean, 
+    emailNotify: Boolean 
+});
+const ConfigModel = mongoose.model('Config', ConfigSchema);
+
+const NotificationSchema = new mongoose.Schema({ schoolId: String, targetRole: String, targetUserId: String, title: String, content: String, type: String, createTime: { type: Date, default: Date.now } });
+const NotificationModel = mongoose.model('Notification', NotificationSchema);
+
+const GameSessionSchema = new mongoose.Schema({ schoolId: String, className: String, isEnabled: Boolean, maxSteps: Number, teams: [{ id: String, name: String, score: Number, avatar: String, color: String, members: [String] }], rewardsConfig: [{ scoreThreshold: Number, rewardType: String, rewardName: String, rewardValue: Number, achievementId: String }] });
+const GameSessionModel = mongoose.model('GameSession', GameSessionSchema);
+
+const StudentRewardSchema = new mongoose.Schema({ schoolId: String, studentId: String, studentName: String, rewardType: String, name: String, count: { type: Number, default: 1 }, status: String, source: String, createTime: { type: Date, default: Date.now }, ownerId: String });
+const StudentRewardModel = mongoose.model('StudentReward', StudentRewardSchema);
+
+const LuckyDrawConfigSchema = new mongoose.Schema({ schoolId: String, className: String, ownerId: String, prizes: [{ id: String, name: String, probability: Number, count: Number, icon: String }], dailyLimit: Number, cardCount: Number, defaultPrize: String, consolationWeight: { type: Number, default: 0 } });
+const LuckyDrawConfigModel = mongoose.model('LuckyDrawConfig', LuckyDrawConfigSchema);
+
+const GameMonsterConfigSchema = new mongoose.Schema({ 
+    schoolId: String, 
+    className: String, 
+    ownerId: String,
+    duration: { type: Number, default: 300 },
+    sensitivity: { type: Number, default: 25 },
+    difficulty: { type: Number, default: 5 },
+    useKeyboardMode: { type: Boolean, default: false },
+    rewardConfig: {
+        enabled: Boolean,
+        type: { type: String }, 
+        val: String,
+        count: Number
+    }
+});
+const GameMonsterConfigModel = mongoose.model('GameMonsterConfig', GameMonsterConfigSchema);
+
+const GameZenConfigSchema = new mongoose.Schema({ 
+    schoolId: String, 
+    className: String, 
+    ownerId: String,
+    durationMinutes: { type: Number, default: 40 },
+    threshold: { type: Number, default: 30 },
+    passRate: { type: Number, default: 90 },
+    rewardConfig: {
+        enabled: Boolean,
+        type: { type: String },
+        val: String,
+        count: Number
+    }
+});
+const GameZenConfigModel = mongoose.model('GameZenConfig', GameZenConfigSchema);
+
+// Updated Achievement Schema with addedBy
+const AchievementConfigSchema = new mongoose.Schema({ 
+    schoolId: String, 
+    className: String, 
+    achievements: [{ 
+        id: String, 
+        name: String, 
+        icon: String, 
+        points: Number, 
+        description: String,
+        addedBy: String,
+        addedByName: String
+    }], 
+    // Legacy support, rules now moving to TeacherExchangeConfig
+    exchangeRules: [{ id: String, cost: Number, rewardType: String, rewardName: String, rewardValue: Number }] 
+});
+const AchievementConfigModel = mongoose.model('AchievementConfig', AchievementConfigSchema);
+
+// NEW: Independent Teacher Exchange Rules
+const TeacherExchangeConfigSchema = new mongoose.Schema({
+    schoolId: String,
+    teacherId: String,
+    teacherName: String,
+    rules: [{ id: String, cost: Number, rewardType: String, rewardName: String, rewardValue: Number }]
+});
+const TeacherExchangeConfigModel = mongoose.model('TeacherExchangeConfig', TeacherExchangeConfigSchema);
+
+const StudentAchievementSchema = new mongoose.Schema({ schoolId: String, studentId: String, studentName: String, achievementId: String, achievementName: String, achievementIcon: String, semester: String, createTime: { type: Date, default: Date.now } });
+const StudentAchievementModel = mongoose.model('StudentAchievement', StudentAchievementSchema);
+
+const AttendanceSchema = new mongoose.Schema({ schoolId: String, studentId: String, studentName: String, className: String, date: String, status: String, checkInTime: Date });
+const AttendanceModel = mongoose.model('Attendance', AttendanceSchema);
+
+const LeaveRequestSchema = new mongoose.Schema({ schoolId: String, studentId: String, studentName: String, className: String, reason: String, startDate: String, endDate: String, status: { type: String, default: 'Pending' }, createTime: { type: Date, default: Date.now } });
+const LeaveRequestModel = mongoose.model('LeaveRequest', LeaveRequestSchema);
+
+const SchoolCalendarSchema = new mongoose.Schema({ schoolId: String, className: String, type: String, startDate: String, endDate: String, name: String });
+const SchoolCalendarModel = mongoose.model('SchoolCalendar', SchoolCalendarSchema);
 
-class MockQuery {
-    constructor(data) {
-        this.data = data;
-    }
-
-    sort(criteria) {
-        const keys = Object.keys(criteria);
-        if (keys.length === 0) return this;
-        const key = keys[0];
-        const dir = criteria[key]; // 1 or -1
-        
-        this.data.sort((a, b) => {
-            const valA = a[key] || 0;
-            const valB = b[key] || 0;
-            if (valA < valB) return -1 * dir;
-            if (valA > valB) return 1 * dir;
-            return 0;
-        });
-        return this;
-    }
-
-    limit(n) {
-        this.data = this.data.slice(0, n);
-        return this;
-    }
-
-    skip(n) {
-        this.data = this.data.slice(n);
-        return this;
-    }
-
-    then(resolve, reject) {
-        resolve(this.data);
-    }
-}
-
-class MockModel {
-    constructor(name) {
-        this.name = name;
-        this.store = [];
-    }
-
-    // Helper to check if a document matches a filter
-    _matches(doc, filter) {
-        if (!filter) return true;
-        for (const key of Object.keys(filter)) {
-            const criteria = filter[key];
-            
-            // Handle $or
-            if (key === '$or') {
-                if (!Array.isArray(criteria)) continue;
-                // If ANY condition in $or is true, pass
-                if (!criteria.some(cond => this._matches(doc, cond))) return false;
-                continue;
-            }
-
-            const docVal = doc[key];
-
-            // Handle Complex Operators
-            if (criteria && typeof criteria === 'object' && !Array.isArray(criteria) && !(criteria instanceof RegExp)) {
-                if (criteria.$in) {
-                    // { field: { $in: [...] } }
-                    // docVal could be a single value or an array
-                    const allowed = criteria.$in.map(String);
-                    if (Array.isArray(docVal)) {
-                        if (!docVal.some(v => allowed.includes(String(v)))) return false;
-                    } else {
-                        if (!allowed.includes(String(docVal))) return false;
-                    }
-                } else if (criteria.$ne !== undefined) {
-                    if (String(docVal) === String(criteria.$ne)) return false;
-                } else if (criteria.$regex) {
-                    const re = new RegExp(criteria.$regex, criteria.$options);
-                    if (!re.test(docVal)) return false;
-                }
-            } else if (criteria instanceof RegExp) {
-                if (!criteria.test(docVal)) return false;
-            } else {
-                // Simple Equality
-                if (String(docVal) !== String(criteria)) return false;
-            }
-        }
-        return true;
-    }
-
-    async find(filter = {}) {
-        const res = this.store.filter(item => this._matches(item, filter));
-        // Return a copy to mimic DB returning new objects
-        return new MockQuery(JSON.parse(JSON.stringify(res)));
-    }
-
-    async findOne(filter = {}) {
-        const item = this.store.find(item => this._matches(item, filter));
-        return item ? JSON.parse(JSON.stringify(item)) : null;
-    }
-
-    async findById(id) {
-        const item = this.store.find(i => i._id === id);
-        return item ? JSON.parse(JSON.stringify(item)) : null;
-    }
-
-    async create(data) {
-        const newItem = { 
-            ...data, 
-            _id: Date.now().toString() + Math.random().toString(36).substr(2, 5), 
-            createTime: data.createTime || new Date().toISOString() 
-        };
-        this.store.push(newItem);
-        return newItem;
-    }
-
-    async findByIdAndUpdate(id, update, options) {
-        const idx = this.store.findIndex(i => i._id === id);
-        if (idx === -1) {
-            if (options?.upsert) {
-                return this.create({ _id: id, ...update });
-            }
-            return null;
-        }
-
-        // Handle $inc operator
-        if (update.$inc) {
-            for (const key in update.$inc) {
-                // Simple path support
-                if (key.includes('.')) {
-                    // Try to handle simple "prizes.$.count" logic roughly or ignore
-                    // For this mock, we skip complex array updates via $inc
-                    continue; 
-                }
-                this.store[idx][key] = (this.store[idx][key] || 0) + update.$inc[key];
-            }
-            delete update.$inc;
-        }
-
-        // Merge other fields
-        Object.assign(this.store[idx], update);
-        return this.store[idx];
-    }
-
-    async findOneAndUpdate(filter, update, options) {
-        let idx = this.store.findIndex(item => this._matches(item, filter));
-        
-        if (idx === -1) {
-            if (options?.upsert) {
-                return this.create({ ...filter, ...update });
-            }
-            return null;
-        }
-
-        Object.assign(this.store[idx], update);
-        return this.store[idx];
-    }
-
-    async findByIdAndDelete(id) {
-        const idx = this.store.findIndex(i => i._id === id);
-        if (idx !== -1) {
-            const deleted = this.store[idx];
-            this.store.splice(idx, 1);
-            return deleted;
-        }
-        return null;
-    }
-
-    async findOneAndDelete(filter) {
-        const idx = this.store.findIndex(item => this._matches(item, filter));
-        if (idx !== -1) {
-            const deleted = this.store[idx];
-            this.store.splice(idx, 1);
-            return deleted;
-        }
-        return null;
-    }
-
-    async deleteOne(filter) {
-        return this.findOneAndDelete(filter);
-    }
-
-    async deleteMany(filter) {
-        const initialLen = this.store.length;
-        this.store = this.store.filter(item => !this._matches(item, filter));
-        return { deletedCount: initialLen - this.store.length };
-    }
-
-    async countDocuments(filter) {
-        return this.store.filter(item => this._matches(item, filter)).length;
-    }
-
-    async insertMany(docs) {
-        const newItems = docs.map(d => ({
-            ...d,
-            _id: Date.now().toString() + Math.random().toString(36).substr(2, 5),
-            createTime: d.createTime || new Date().toISOString()
-        }));
-        this.store.push(...newItems);
-        return newItems;
-    }
-
-    async updateOne(filter, update) {
-        // Simple update one (mocking basic $inc or $set)
-        const idx = this.store.findIndex(item => this._matches(item, filter));
-        if (idx !== -1) {
-            if (update.$inc) {
-                for (const k in update.$inc) {
-                    // Very basic nested support for specific app case: "prizes.$.count"
-                    // If filter matched a nested array element, this gets complicated in Mock.
-                    // Fallback: If we can't find the key, ignore.
-                    if (k.includes('.')) continue; 
-                    this.store[idx][k] = (this.store[idx][k] || 0) + update.$inc[k];
-                }
-                delete update.$inc;
-            }
-            Object.assign(this.store[idx], update);
-            return { modifiedCount: 1 };
-        }
-        return { modifiedCount: 0 };
-    }
-
-    async updateMany(filter, update) {
-        let count = 0;
-        this.store.forEach(item => {
-            if (this._matches(item, filter)) {
-                Object.assign(item, update);
-                count++;
-            }
-        });
-        return { modifiedCount: count };
-    }
-}
-
-// Export Instances
 module.exports = {
-    School: new MockModel('School'),
-    User: new MockModel('User'),
-    Student: new MockModel('Student'),
-    Course: new MockModel('Course'),
-    Score: new MockModel('Score'),
-    ClassModel: new MockModel('Class'),
-    SubjectModel: new MockModel('Subject'),
-    ExamModel: new MockModel('Exam'),
-    ScheduleModel: new MockModel('Schedule'),
-    ConfigModel: new MockModel('Config'),
-    NotificationModel: new MockModel('Notification'),
-    GameSessionModel: new MockModel('GameSession'),
-    StudentRewardModel: new MockModel('StudentReward'),
-    LuckyDrawConfigModel: new MockModel('LuckyDrawConfig'),
-    GameMonsterConfigModel: new MockModel('GameMonsterConfig'),
-    GameZenConfigModel: new MockModel('GameZenConfig'),
-    AchievementConfigModel: new MockModel('AchievementConfig'),
-    TeacherExchangeConfigModel: new MockModel('TeacherExchangeConfig'),
-    StudentAchievementModel: new MockModel('StudentAchievement'),
-    AttendanceModel: new MockModel('Attendance'),
-    LeaveRequestModel: new MockModel('LeaveRequest'),
-    SchoolCalendarModel: new MockModel('SchoolCalendarEntry'),
-    WishModel: new MockModel('Wish'),
-    FeedbackModel: new MockModel('Feedback')
+    School, User, Student, Course, Score, ClassModel, SubjectModel, ExamModel, ScheduleModel,
+    ConfigModel, NotificationModel, GameSessionModel, StudentRewardModel, LuckyDrawConfigModel, GameMonsterConfigModel, GameZenConfigModel,
+    AchievementConfigModel, TeacherExchangeConfigModel, StudentAchievementModel, AttendanceModel, LeaveRequestModel, SchoolCalendarModel
 };

pages/CourseList.tsx

@@ -169,7 +169,7 @@ export const CourseList: React.FC = () => {
                           <div className="flex gap-2 pt-2 border-t border-gray-50">
                              <button onClick={() => { 
                                  setFormData({ 
-                                     courseCode: c.courseCode || '', 
+                                     courseCode: c.courseCode, 
                                      courseName: c.courseName, 
                                      teacherName: c.teacherName, 
                                      teacherId: c.teacherId || '',

server.js

@@ -1,982 +1,849 @@
 
+// ... existing imports
+const { 
+    School, User, Student, Course, Score, ClassModel, SubjectModel, ExamModel, ScheduleModel,
+    ConfigModel, NotificationModel, GameSessionModel, StudentRewardModel, LuckyDrawConfigModel, GameMonsterConfigModel, GameZenConfigModel,
+    AchievementConfigModel, TeacherExchangeConfigModel, StudentAchievementModel, AttendanceModel, LeaveRequestModel, SchoolCalendarModel
+} = require('./models');
+
+// ... (existing setup code, middleware, connectDB, helpers) ...
 const express = require('express');
-// const mongoose = require('mongoose'); // REMOVED: Using In-Memory DB
+const mongoose = require('mongoose');
 const cors = require('cors');
 const bodyParser = require('body-parser');
 const path = require('path');
-const compression = require('compression');
+const compression = require('compression'); 
 
-// Import In-Memory Models
-const { 
-    School, User, Student, Course, Score, ClassModel, SubjectModel, ExamModel, ScheduleModel,
-    ConfigModel, NotificationModel, GameSessionModel, StudentRewardModel, LuckyDrawConfigModel, GameMonsterConfigModel, GameZenConfigModel,
-    AchievementConfigModel, TeacherExchangeConfigModel, StudentAchievementModel, AttendanceModel, LeaveRequestModel, SchoolCalendarModel,
-    WishModel, FeedbackModel
-} = require('./models');
+// ... constants
+const PORT = 7860;
+const MONGO_URI = 'mongodb+srv://dv890a:db8822723@chatpro.gw3v0v7.mongodb.net/chatpro?retryWrites=true&w=majority&appName=chatpro&authSource=admin';
 
 const app = express();
-const PORT = process.env.PORT || 7860;
-
-// Middleware
-app.use(cors());
 app.use(compression());
-app.use(bodyParser.json({ limit: '10mb' }));
-app.use(bodyParser.urlencoded({ extended: true, limit: '10mb' }));
-
-// --- DATABASE INITIALIZATION (MOCK) ---
-// Initialize a default admin user if none exists
-const initDB = async () => {
-    console.log('Using In-Memory Database');
-    const admin = await User.findOne({ username: 'admin' });
-    if (!admin) {
-        await User.create({
-            username: 'admin',
-            password: 'admin',
-            role: 'ADMIN',
-            status: 'active',
-            trueName: '系统管理员'
-        });
-        console.log('Default Admin Created: admin / admin');
+app.use(cors());
+app.use(bodyParser.json({ limit: '10mb' })); 
+app.use(express.static(path.join(__dirname, 'dist'), {
+  setHeaders: (res, filePath) => {
+    if (filePath.endsWith('.html')) {
+      res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+    } else {
+      res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
     }
+  }
+}));
+
+const InMemoryDB = { schools: [], users: [], isFallback: false };
+const connectDB = async () => {
+  try {
+    await mongoose.connect(MONGO_URI, { serverSelectionTimeoutMS: 30000 });
+    console.log('✅ MongoDB 连接成功 (Real Data)');
+  } catch (err) {
+    console.error('❌ MongoDB 连接失败:', err.message);
+    InMemoryDB.isFallback = true;
+  }
 };
-initDB();
-
-// --- Helpers ---
-const injectSchoolId = (req, data) => {
-    const schoolId = req.headers['x-school-id'];
-    if (schoolId) data.schoolId = schoolId;
-    return data;
+connectDB();
+
+const getQueryFilter = (req) => { 
+  const s = req.headers['x-school-id']; 
+  const role = req.headers['x-user-role'];
+  if (role === 'PRINCIPAL') {
+      if (!s) return { _id: null }; 
+      return { schoolId: s };
+  }
+  if (!s) return {};
+  return { 
+    $or: [
+      { schoolId: s },
+      { schoolId: { $exists: false } },
+      { schoolId: null }
+    ]
+  }; 
 };
+const injectSchoolId = (req, b) => ({ ...b, schoolId: req.headers['x-school-id'] });
 
-const getQueryFilter = (req) => {
-    const schoolId = req.headers['x-school-id'];
-    return schoolId ? { schoolId } : {};
+const getGameOwnerFilter = async (req) => {
+    const role = req.headers['x-user-role'];
+    const username = req.headers['x-user-username'];
+    if (role === 'TEACHER') {
+        const user = await User.findOne({ username });
+        return { ownerId: user ? user._id.toString() : 'unknown' };
+    }
+    return {};
 };
 
-// --- AUTH ROUTES ---
-app.post('/api/auth/login', async (req, res) => {
-    const { username, password } = req.body;
-    const user = await User.findOne({ username, password });
-    if (user) {
-        if (user.status === 'banned') return res.status(403).json({ error: 'BANNED' });
-        if (user.status === 'pending') return res.status(403).json({ error: 'PENDING_APPROVAL' });
-        res.json(user);
+const getAutoSemester = () => {
+    const now = new Date();
+    const month = now.getMonth() + 1; 
+    const year = now.getFullYear();
+    if (month >= 8 || month === 1) {
+        const startYear = month === 1 ? year - 1 : year;
+        return `${startYear}-${startYear + 1}学年 第一学期`;
     } else {
-        res.status(401).json({ error: 'INVALID_PASSWORD' });
-    }
-});
-
-app.post('/api/auth/register', async (req, res) => {
-    try {
-        if (req.body.role === 'STUDENT' && !req.body.username) {
-            const count = await User.countDocuments({ role: 'STUDENT' });
-            const year = new Date().getFullYear();
-            req.body.username = `${year}${String(count + 1).padStart(4, '0')}`;
-            req.body.password = '123456';
-            req.body.studentNo = req.body.username;
-        }
-        
-        const newUser = await User.create({ ...req.body, status: 'pending' });
-        
-        if (req.body.role === 'STUDENT') {
-            await Student.create(injectSchoolId({ headers: { 'x-school-id': req.body.schoolId } }, {
-                name: req.body.trueName,
-                studentNo: req.body.username,
-                className: req.body.homeroomClass,
-                seatNo: req.body.seatNo,
-                gender: req.body.gender,
-                phone: req.body.phone,
-                parentName: req.body.parentName,
-                parentPhone: req.body.parentPhone,
-                address: req.body.address,
-                idCard: req.body.idCard,
-                status: 'Enrolled'
-            }));
-        }
-        
-        res.json(newUser);
-    } catch (e) {
-        res.status(400).json({ error: 'CONFLICT', message: e.message });
+        const startYear = year - 1;
+        return `${startYear}-${startYear + 1}学年 第二学期`;
     }
-});
-
-app.get('/api/auth/me', async (req, res) => {
-    res.json({ message: "Session check passed" });
-});
-
-app.post('/api/auth/update-profile', async (req, res) => {
-    const { userId, ...updates } = req.body;
-    if (updates.newPassword) {
-        const user = await User.findById(userId);
-        if (user.password !== updates.currentPassword) {
-            return res.status(400).json({ error: 'INVALID_PASSWORD' });
-        }
-        updates.password = updates.newPassword;
-        delete updates.newPassword;
-        delete updates.currentPassword;
-    }
-    const updated = await User.findByIdAndUpdate(userId, updates, { new: true });
-    res.json(updated);
-});
-
-// --- SCHOOL ROUTES ---
-app.get('/api/schools', async (req, res) => {
-    const schools = await School.find();
-    res.json(schools);
-});
-app.get('/api/public/schools', async (req, res) => {
-    const schools = await School.find(); // Mock: Return all, simple projection handled by client if needed or mocked
-    const projected = schools.map(s => ({ name: s.name, code: s.code, _id: s._id }));
-    res.json(projected);
-});
-app.post('/api/schools', async (req, res) => {
-    const s = await School.create(req.body);
-    res.json(s);
-});
-app.put('/api/schools/:id', async (req, res) => {
-    await School.findByIdAndUpdate(req.params.id, req.body);
-    res.json({ success: true });
-});
-app.delete('/api/schools/:id', async (req, res) => {
-    const sid = req.params.id;
-    await School.findByIdAndDelete(sid);
-    await User.deleteMany({ schoolId: sid });
-    await Student.deleteMany({ schoolId: sid });
-    res.json({ success: true });
-});
-
-// --- PUBLIC CONFIG & META ---
-app.get('/api/public/config', async (req, res) => {
-    const config = await ConfigModel.findOne(getQueryFilter(req));
-    res.json(config || {});
-});
-app.get('/api/public/meta', async (req, res) => {
-    const { schoolId } = req.query;
-    if (!schoolId) return res.json({});
-    const [classes, subjects] = await Promise.all([
-        ClassModel.find({ schoolId }),
-        SubjectModel.find({ schoolId })
-    ]);
-    res.json({ classes, subjects });
-});
+};
 
-// --- CONFIG ---
-app.get('/api/config', async (req, res) => {
-    const config = await ConfigModel.findOne(getQueryFilter(req));
-    res.json(config || {});
-});
-app.post('/api/config', async (req, res) => {
-    const filter = getQueryFilter(req);
-    const data = injectSchoolId(req, req.body);
-    await ConfigModel.findOneAndUpdate(filter, data, { upsert: true });
-    res.json({ success: true });
-});
+const generateStudentNo = async () => {
+    const year = new Date().getFullYear();
+    const random = Math.floor(100000 + Math.random() * 900000); 
+    return `${year}${random}`;
+};
 
-// --- USERS ---
-app.get('/api/users', async (req, res) => {
-    const { role, global } = req.query;
-    const filter = global === 'true' ? {} : getQueryFilter(req);
-    if (role) filter.role = role;
-    const users = await User.find(filter);
-    res.json(users);
-});
-app.put('/api/users/:id', async (req, res) => {
-    await User.findByIdAndUpdate(req.params.id, req.body);
-    res.json({ success: true });
-});
-app.delete('/api/users/:id', async (req, res) => {
-    await User.findByIdAndDelete(req.params.id);
-    res.json({ success: true });
-});
-app.post('/api/users/class-application', async (req, res) => {
-    const { userId, type, targetClass, action } = req.body;
-    if (action === 'APPLY') {
-        await User.findByIdAndUpdate(userId, { 
-            classApplication: { type, targetClass, status: 'PENDING' } 
-        });
-    } else if (action === 'APPROVE') {
-        if (type === 'CLAIM') {
-            await User.findByIdAndUpdate(userId, { 
-                homeroomClass: targetClass, 
-                classApplication: null 
-            });
-        } else {
-            await User.findByIdAndUpdate(userId, { 
-                homeroomClass: '', 
-                classApplication: null 
-            });
-        }
-    } else {
-        await User.findByIdAndUpdate(userId, { classApplication: null });
-    }
-    res.json({ success: true });
-});
+// ... (Existing Routes: Auth, Users, Students, Classes, etc.) ...
+// Insert helper route for fetching teachers of a class
 app.get('/api/classes/:className/teachers', async (req, res) => {
     const { className } = req.params;
-    // Decode className just in case
-    const decodedName = decodeURIComponent(className);
-    const filter = getQueryFilter(req);
-    
-    // Manual complex query simulation for Mock DB
-    // $or logic needs to be handled by the Mock Model if supported, or manually
-    const teachers = await User.find({
-        ...filter,
-        role: 'TEACHER',
-        $or: [
-            { homeroomClass: decodedName }
-        ]
-    });
+    const schoolId = req.headers['x-school-id'];
     
-    const courses = await Course.find({ className: decodedName, ...filter });
-    const courseTeacherIds = courses.map(c => c.teacherId).filter(Boolean);
-    const courseTeachers = await User.find({ _id: { $in: courseTeacherIds } });
+    // Normalize helper: remove all spaces for loose matching
+    const normalize = (s) => (s || '').replace(/\s+/g, '');
+    const searchName = normalize(decodeURIComponent(className));
     
-    // Dedup manually
-    const all = [...teachers, ...courseTeachers];
-    const uniqueMap = new Map();
-    all.forEach(u => uniqueMap.set(u._id, u));
-    res.json(Array.from(uniqueMap.values()));
-});
+    const teacherIds = new Set();
+    const teacherNamesToResolve = new Set();
 
-// --- STUDENTS ---
-app.get('/api/students', async (req, res) => {
-    const students = await Student.find(getQueryFilter(req));
-    res.json(students);
-});
-app.post('/api/students', async (req, res) => {
-    const data = injectSchoolId(req, req.body);
-    if (!data.studentNo) {
-        const count = await Student.countDocuments(getQueryFilter(req));
-        data.studentNo = `S${Date.now().toString().slice(-6)}${count}`;
-    }
-    const s = await Student.create(data);
-    res.json(s);
-});
-app.put('/api/students/:id', async (req, res) => {
-    await Student.findByIdAndUpdate(req.params.id, req.body);
-    res.json({ success: true });
-});
-app.delete('/api/students/:id', async (req, res) => {
-    await Student.findByIdAndDelete(req.params.id);
-    res.json({ success: true });
-});
-app.post('/api/students/promote', async (req, res) => {
-    const { teacherFollows } = req.body;
-    const filter = getQueryFilter(req);
-    const students = await Student.find(filter);
-    let count = 0;
-    
-    const gradeMap = {
-        '一年级': '二年级', '二年级': '三年级', '三年级': '四年级',
-        '四年级': '五年级', '五年级': '六年级', '六年级': '毕业',
-        '初一': '初二', '初二': '初三', '初三': '毕业',
-        '高一': '高二', '高二': '高三', '高三': '毕业',
-        '七年级': '八年级', '八年级': '九年级', '九年级': '毕业'
-    };
+    try {
+        // 1. Get Homeroom Teachers (Iterate to robustly match concatenated grade+class)
+        const allClasses = await ClassModel.find({ schoolId });
+        const matchedClass = allClasses.find(c => {
+             // Match either full "GradeClass" or just "Class" if that's how it's stored
+             const full = normalize(c.grade + c.className);
+             const sub = normalize(c.className);
+             return full === searchName || sub === searchName;
+        });
 
-    for (const s of students) {
-        const match = s.className.match(/^(.+?)([\(（]?\d+[）\)]?班)$/);
-        if (match) {
-            const currentGrade = match[1];
-            const suffix = match[2];
-            const nextGrade = gradeMap[currentGrade];
-            
-            if (nextGrade) {
-                if (nextGrade === '毕业') {
-                    s.status = 'Graduated';
-                } else {
-                    s.className = nextGrade + suffix;
-                }
-                // In mock, objects are ref, but lets be safe
-                await Student.findByIdAndUpdate(s._id, s);
-                count++;
+        if (matchedClass) {
+            if (matchedClass.homeroomTeacherIds && matchedClass.homeroomTeacherIds.length > 0) {
+                matchedClass.homeroomTeacherIds.forEach(id => teacherIds.add(id));
+            }
+            // Fallback: If only name string exists (legacy data)
+            if (matchedClass.teacherName) {
+                 matchedClass.teacherName.split(/[,，]/).forEach(n => {
+                     if(n.trim()) teacherNamesToResolve.add(n.trim());
+                 });
             }
         }
-    }
-    
-    if (teacherFollows) {
-        const teachers = await User.find({ ...filter, role: 'TEACHER' });
-        for (const t of teachers) {
-            if (t.homeroomClass) {
-                const match = t.homeroomClass.match(/^(.+?)([\(（]?\d+[）\)]?班)$/);
-                if (match) {
-                    const nextG = gradeMap[match[1]];
-                    if (nextG && nextG !== '毕业') {
-                        t.homeroomClass = nextG + match[2];
-                        await User.findByIdAndUpdate(t._id, t);
-                    }
+        
+        // 2. Get Subject Teachers from Courses
+        const allCourses = await Course.find({ schoolId });
+        allCourses.forEach(c => {
+            // Check normalized name
+            if (normalize(c.className) === searchName) {
+                if (c.teacherId) {
+                    teacherIds.add(c.teacherId);
+                } else if (c.teacherName) {
+                    // Fallback: If teacherId is missing, assume name is correct
+                    teacherNamesToResolve.add(c.teacherName);
                 }
             }
+        });
+
+        // 3. Resolve Teacher Names to IDs (Fallback mechanism)
+        if (teacherNamesToResolve.size > 0) {
+            const names = Array.from(teacherNamesToResolve);
+            // Find users where trueName matches these names
+            const users = await User.find({
+                schoolId,
+                role: 'TEACHER',
+                $or: [
+                    { trueName: { $in: names } },
+                    { username: { $in: names } } // Just in case name is stored as username
+                ]
+            });
+            users.forEach(u => teacherIds.add(u._id.toString()));
         }
-    }
 
-    res.json({ count });
-});
-app.post('/api/students/transfer', async (req, res) => {
-    const { studentId, targetClass } = req.body;
-    await Student.findByIdAndUpdate(studentId, { className: targetClass });
-    res.json({ success: true });
-});
+        if (teacherIds.size === 0) return res.json([]);
 
-// --- CLASSES ---
-app.get('/api/classes', async (req, res) => {
-    const classes = await ClassModel.find(getQueryFilter(req));
-    res.json(classes);
-});
-app.post('/api/classes', async (req, res) => {
-    const data = injectSchoolId(req, req.body);
-    await ClassModel.create(data);
-    res.json({ success: true });
-});
-app.delete('/api/classes/:id', async (req, res) => {
-    await ClassModel.findByIdAndDelete(req.params.id);
-    res.json({ success: true });
-});
-app.put('/api/classes/:id', async (req, res) => {
-    await ClassModel.findByIdAndUpdate(req.params.id, req.body);
-    res.json({ success: true });
+        // UPDATED: Include teachingSubject in the response
+        const teachers = await User.find({ _id: { $in: Array.from(teacherIds) } }, 'trueName username _id teachingSubject');
+        res.json(teachers);
+    } catch (e) {
+        console.error("Error fetching teachers", e);
+        res.json([]);
+    }
 });
 
-// --- COURSES ---
-app.get('/api/courses', async (req, res) => {
-    const courses = await Course.find(getQueryFilter(req));
-    res.json(courses);
-});
-app.post('/api/courses', async (req, res) => {
-    const data = injectSchoolId(req, req.body);
-    const exists = await Course.findOne({ 
-        schoolId: data.schoolId, 
-        className: data.className, 
-        courseName: data.courseName 
-    });
-    if (exists) return res.status(400).json({ error: 'DUPLICATE' });
-    await Course.create(data);
-    res.json({ success: true });
-});
-app.put('/api/courses/:id', async (req, res) => {
-    await Course.findByIdAndUpdate(req.params.id, req.body);
-    res.json({ success: true });
-});
-app.delete('/api/courses/:id', async (req, res) => {
-    await Course.findByIdAndDelete(req.params.id);
-    res.json({ success: true });
+// ... (Rest of the file follows)
+// ...
+app.get('/api/games/lucky-config', async (req, res) => {
+   const filter = getQueryFilter(req);
+   // If explicit ownerId passed (e.g. from student view), use it.
+   // Otherwise if Teacher, force own ID.
+   if (req.query.ownerId) {
+       filter.ownerId = req.query.ownerId;
+   } else {
+       const ownerFilter = await getGameOwnerFilter(req);
+       Object.assign(filter, ownerFilter);
+   }
+   
+   if (req.query.className) filter.className = req.query.className;
+   
+   const config = await LuckyDrawConfigModel.findOne(filter);
+   res.json(config || null); // Return null if not found instead of default
+});
+// ... (Rest of games routes unchanged except achievement/exchange below) ...
+
+// ACHIEVEMENT ROUTES
+app.get('/api/achievements/config', async (req, res) => {
+    const { className } = req.query;
+    const filter = getQueryFilter(req);
+    if (className) filter.className = className;
+    res.json(await AchievementConfigModel.findOne(filter));
 });
 
-// --- SCORES ---
-app.get('/api/scores', async (req, res) => {
-    const scores = await Score.find(getQueryFilter(req));
-    res.json(scores);
-});
-app.post('/api/scores', async (req, res) => {
+app.post('/api/achievements/config', async (req, res) => {
     const data = injectSchoolId(req, req.body);
-    await Score.create(data);
-    res.json({ success: true });
-});
-app.put('/api/scores/:id', async (req, res) => {
-    await Score.findByIdAndUpdate(req.params.id, req.body);
-    res.json({ success: true });
-});
-app.delete('/api/scores/:id', async (req, res) => {
-    await Score.findByIdAndDelete(req.params.id);
+    await AchievementConfigModel.findOneAndUpdate(
+        { className: data.className, ...getQueryFilter(req) }, 
+        data, 
+        { upsert: true }
+    );
     res.json({ success: true });
 });
 
-// --- SUBJECTS ---
-app.get('/api/subjects', async (req, res) => {
-    const subjects = await SubjectModel.find(getQueryFilter(req));
-    res.json(subjects);
-});
-app.post('/api/subjects', async (req, res) => {
-    const data = injectSchoolId(req, req.body);
-    await SubjectModel.create(data);
-    res.json({ success: true });
-});
-app.put('/api/subjects/:id', async (req, res) => {
-    await SubjectModel.findByIdAndUpdate(req.params.id, req.body);
-    res.json({ success: true });
-});
-app.delete('/api/subjects/:id', async (req, res) => {
-    await SubjectModel.findByIdAndDelete(req.params.id);
-    res.json({ success: true });
-});
+// NEW: Teacher Exchange Rules Routes
+app.get('/api/achievements/teacher-rules', async (req, res) => {
+    const filter = getQueryFilter(req);
+    // If getting for specific teacher (e.g. student viewing shop), allow query param
+    // If no query param and user is teacher, return their own
+    if (req.query.teacherId) {
+        filter.teacherId = req.query.teacherId;
+    } else if (req.headers['x-user-role'] === 'TEACHER') {
+        const user = await User.findOne({ username: req.headers['x-user-username'] });
+        if (user) filter.teacherId = user._id.toString();
+    }
+    
+    // Support getting MULTIPLE teachers (for student shop view)
+    if (req.query.teacherIds) {
+        const ids = req.query.teacherIds.split(',');
+        delete filter.teacherId;
+        filter.teacherId = { $in: ids };
+        const configs = await TeacherExchangeConfigModel.find(filter);
+        return res.json(configs);
+    }
 
-// --- EXAMS ---
-app.get('/api/exams', async (req, res) => {
-    const exams = await ExamModel.find(getQueryFilter(req));
-    res.json(exams);
+    const config = await TeacherExchangeConfigModel.findOne(filter);
+    res.json(config || { rules: [] });
 });
-app.post('/api/exams', async (req, res) => {
+
+app.post('/api/achievements/teacher-rules', async (req, res) => {
     const data = injectSchoolId(req, req.body);
-    await ExamModel.findOneAndUpdate(
-        { schoolId: data.schoolId, name: data.name },
+    const user = await User.findOne({ username: req.headers['x-user-username'] });
+    if (!user) return res.status(404).json({ error: 'User not found' });
+    
+    data.teacherId = user._id.toString();
+    data.teacherName = user.trueName || user.username;
+    
+    await TeacherExchangeConfigModel.findOneAndUpdate(
+        { teacherId: data.teacherId, ...getQueryFilter(req) },
         data,
         { upsert: true }
     );
     res.json({ success: true });
 });
 
-// --- SCHEDULES ---
-app.get('/api/schedules', async (req, res) => {
-    const filter = getQueryFilter(req);
-    const { className, teacherName, grade } = req.query;
-    if (className) filter.className = className;
-    if (teacherName) filter.teacherName = teacherName;
-    if (grade) filter.className = { $regex: new RegExp(`^${grade}`) };
-    
-    const schedules = await ScheduleModel.find(filter);
-    res.json(schedules);
+app.get('/api/achievements/student', async (req, res) => {
+    const { studentId, semester } = req.query;
+    const filter = { studentId };
+    if (semester) filter.semester = semester;
+    res.json(await StudentAchievementModel.find(filter).sort({ createTime: -1 }));
 });
-app.post('/api/schedules', async (req, res) => {
-    const data = injectSchoolId(req, req.body);
-    await ScheduleModel.findOneAndDelete({ 
-        schoolId: data.schoolId, 
-        className: data.className, 
-        dayOfWeek: data.dayOfWeek, 
-        period: data.period 
+
+app.post('/api/achievements/grant', async (req, res) => {
+    const { studentId, achievementId, semester } = req.body;
+    const sId = req.headers['x-school-id'];
+    
+    const student = await Student.findById(studentId);
+    if (!student) return res.status(404).json({ error: 'Student not found' });
+    
+    const config = await AchievementConfigModel.findOne({ className: student.className, schoolId: sId });
+    const achievement = config?.achievements.find(a => a.id === achievementId);
+    
+    if (!achievement) return res.status(404).json({ error: 'Achievement not found' });
+    
+    // Add Record
+    await StudentAchievementModel.create({
+        schoolId: sId,
+        studentId,
+        studentName: student.name,
+        achievementId: achievement.id,
+        achievementName: achievement.name,
+        achievementIcon: achievement.icon,
+        semester,
+        createTime: new Date()
     });
-    await ScheduleModel.create(data);
-    res.json({ success: true });
-});
-app.delete('/api/schedules', async (req, res) => {
-    const filter = getQueryFilter(req);
-    const { className, dayOfWeek, period } = req.query;
-    await ScheduleModel.deleteOne({ ...filter, className, dayOfWeek: Number(dayOfWeek), period: Number(period) });
+    
+    // Add Points (Flowers)
+    await Student.findByIdAndUpdate(studentId, { $inc: { flowerBalance: achievement.points } });
+    
     res.json({ success: true });
 });
 
-// --- ATTENDANCE ---
-app.get('/api/attendance', async (req, res) => {
-    const filter = getQueryFilter(req);
-    const { className, date, studentId } = req.query;
-    if (date) filter.date = date;
-    if (studentId) filter.studentId = studentId;
+app.post('/api/achievements/exchange', async (req, res) => {
+    const { studentId, ruleId, teacherId } = req.body; // Added teacherId to identify which rule set
+    const sId = req.headers['x-school-id'];
     
-    if (className) {
-        const students = await Student.find({ ...getQueryFilter(req), className });
-        const ids = students.map(s => s._id.toString());
-        filter.studentId = { $in: ids };
+    const student = await Student.findById(studentId);
+    if (!student) return res.status(404).json({ error: 'Student not found' });
+    
+    // Find rule in Teacher Config first
+    let rule = null;
+    let ownerId = null; // To track who receives the redemption request
+
+    if (teacherId) {
+        const tConfig = await TeacherExchangeConfigModel.findOne({ teacherId, schoolId: sId });
+        rule = tConfig?.rules.find(r => r.id === ruleId);
+        ownerId = teacherId;
+    } else {
+        // Fallback for legacy class-based rules (if any remain)
+        const config = await AchievementConfigModel.findOne({ className: student.className, schoolId: sId });
+        rule = config?.exchangeRules?.find(r => r.id === ruleId);
     }
-    const list = await AttendanceModel.find(filter);
-    res.json(list);
-});
-app.post('/api/attendance/check-in', async (req, res) => {
-    const { studentId, date } = req.body;
-    const existing = await AttendanceModel.findOne({ studentId, date });
-    if (!existing) {
-        await AttendanceModel.create({
-            studentId, date, status: 'Present', checkInTime: new Date()
-        });
+    
+    if (!rule) return res.status(404).json({ error: 'Rule not found' });
+    
+    if (student.flowerBalance < rule.cost) {
+        return res.status(400).json({ error: 'INSUFFICIENT_FUNDS', message: '小红花余额不足' });
     }
-    res.json({ success: true });
-});
-app.post('/api/attendance/batch', async (req, res) => {
-    const { className, date } = req.body;
-    const students = await Student.find({ ...getQueryFilter(req), className });
     
-    const existing = await AttendanceModel.find({ 
-        studentId: { $in: students.map(s => s._id) },
-        date 
-    });
-    const existingIds = new Set(existing.map(e => e.studentId));
+    // Deduct Flowers
+    await Student.findByIdAndUpdate(studentId, { $inc: { flowerBalance: -rule.cost } });
     
-    const toInsert = students
-        .filter(s => !existingIds.has(s._id.toString()))
-        .map(s => ({
-            studentId: s._id,
-            date,
-            status: 'Present',
-            checkInTime: new Date()
-        }));
+    // Add Reward Record
+    await StudentRewardModel.create({
+        schoolId: sId,
+        studentId,
+        studentName: student.name,
+        rewardType: rule.rewardType, // ITEM or DRAW_COUNT
+        name: rule.rewardName,
+        count: rule.rewardValue,
+        status: rule.rewardType === 'DRAW_COUNT' ? 'REDEEMED' : 'PENDING',
+        source: '积分兑换',
+        ownerId: ownerId, // Important: Shows up in teacher's reward list
+        createTime: new Date()
+    });
     
-    if (toInsert.length > 0) {
-        await AttendanceModel.insertMany(toInsert);
+    // If Draw Count, add attempts immediately
+    if (rule.rewardType === 'DRAW_COUNT') {
+        await Student.findByIdAndUpdate(studentId, { $inc: { drawAttempts: rule.rewardValue } });
     }
-    res.json({ success: true });
-});
-app.put('/api/attendance/update', async (req, res) => {
-    const { studentId, date, status } = req.body;
-    await AttendanceModel.findOneAndUpdate(
-        { studentId, date }, 
-        { status, checkInTime: new Date() }, 
-        { upsert: true }
-    );
-    res.json({ success: true });
-});
-app.post('/api/leave', async (req, res) => {
-    const data = injectSchoolId(req, req.body);
-    await LeaveRequestModel.create(data);
+    
     res.json({ success: true });
 });
 
-// --- CALENDAR ---
-app.get('/api/attendance/calendar', async (req, res) => {
-    const filter = getQueryFilter(req);
-    if (req.query.className) filter.className = req.query.className;
-    const entries = await SchoolCalendarModel.find(filter);
-    res.json(entries);
-});
-app.post('/api/attendance/calendar', async (req, res) => {
-    const data = injectSchoolId(req, req.body);
-    await SchoolCalendarModel.create(data);
-    res.json({ success: true });
+// ... (Rest of existing routes from server.js - copy exact content or use existing file)
+app.get('/api/auth/me', async (req, res) => {
+    const username = req.headers['x-user-username'];
+    if (!username) return res.status(401).json({ error: 'Unauthorized' });
+    const user = await User.findOne({ username });
+    if (!user) return res.status(404).json({ error: 'User not found' });
+    res.json(user);
 });
-app.delete('/api/attendance/calendar/:id', async (req, res) => {
-    await SchoolCalendarModel.findByIdAndDelete(req.params.id);
-    res.json({ success: true });
+app.post('/api/auth/update-profile', async (req, res) => {
+    const { userId, trueName, phone, avatar, currentPassword, newPassword } = req.body;
+    try {
+        const user = await User.findById(userId);
+        if (!user) return res.status(404).json({ error: 'User not found' });
+        if (newPassword) {
+            if (user.password !== currentPassword) return res.status(401).json({ error: 'INVALID_PASSWORD', message: '旧密码错误' });
+            user.password = newPassword;
+        }
+        if (trueName) user.trueName = trueName;
+        if (phone) user.phone = phone;
+        if (avatar) user.avatar = avatar;
+        await user.save();
+        if (user.role === 'STUDENT') await Student.findOneAndUpdate({ studentNo: user.studentNo }, { name: user.trueName || user.username, phone: user.phone });
+        res.json({ success: true, user });
+    } catch (e) { res.status(500).json({ error: e.message }); }
 });
-
-// --- STATS ---
-app.get('/api/stats', async (req, res) => {
-    const filter = getQueryFilter(req);
-    const [stus, courses, scores] = await Promise.all([
-        Student.countDocuments(filter),
-        Course.countDocuments(filter),
-        Score.find(filter)
-    ]);
-    const avg = scores.length ? (scores.reduce((a,b)=>a+b.score,0)/scores.length).toFixed(1) : 0;
-    const exc = scores.length ? ((scores.filter(s=>s.score>=90).length/scores.length)*100).toFixed(1)+'%' : '0%';
-    
-    res.json({
-        studentCount: stus,
-        courseCount: courses,
-        avgScore: avg,
-        excellentRate: exc
-    });
+app.post('/api/auth/register', async (req, res) => {
+    const { role, username, password, schoolId, trueName, seatNo } = req.body;
+    const className = req.body.className || req.body.homeroomClass; 
+    try {
+        if (role === 'STUDENT') {
+            if (!trueName || !className) return res.status(400).json({ error: 'MISSING_FIELDS', message: '姓名和班级不能为空' });
+            const cleanName = trueName.trim();
+            const cleanClass = className.trim();
+            const existingProfile = await Student.findOne({ schoolId, name: { $regex: new RegExp(`^${cleanName}$`, 'i') }, className: cleanClass });
+            let finalUsername = '';
+            if (existingProfile) {
+                if (existingProfile.studentNo && existingProfile.studentNo.length > 5) finalUsername = existingProfile.studentNo;
+                else { finalUsername = await generateStudentNo(); existingProfile.studentNo = finalUsername; await existingProfile.save(); }
+                const userExists = await User.findOne({ username: finalUsername, schoolId });
+                if (userExists) return res.status(409).json({ error: userExists.status === 'active' ? 'ACCOUNT_EXISTS' : 'ACCOUNT_PENDING', message: '账号已存在' });
+            } else finalUsername = await generateStudentNo();
+            await User.create({ username: finalUsername, password, role: 'STUDENT', trueName: cleanName, schoolId, status: 'pending', homeroomClass: cleanClass, studentNo: finalUsername, seatNo: seatNo || '', parentName: req.body.parentName, parentPhone: req.body.parentPhone, address: req.body.address, idCard: req.body.idCard, gender: req.body.gender || 'Male', createTime: new Date() });
+            return res.json({ username: finalUsername });
+        } 
+        const existing = await User.findOne({ username });
+        if (existing) return res.status(409).json({ error: 'USERNAME_EXISTS', message: '用户名已存在' });
+        await User.create({...req.body, status: 'pending', createTime: new Date()});
+        res.json({ username });
+    } catch(e) { res.status(500).json({ error: e.message }); }
 });
-
-// --- NOTIFICATIONS ---
-app.get('/api/notifications', async (req, res) => {
-    const { userId, role } = req.query;
+app.get('/api/users', async (req, res) => {
     const filter = getQueryFilter(req);
-    const notifs = await NotificationModel.find({
-        ...filter,
-        $or: [
-            { targetUserId: userId },
-            { targetRole: role },
-            { targetRole: 'ALL' }
-        ]
-    }).sort({ createTime: -1 }).limit(20);
-    res.json(notifs);
-});
-
-// --- GAMES ---
-app.get('/api/games/mountain', async (req, res) => {
-    const sess = await GameSessionModel.findOne({ ...getQueryFilter(req), className: req.query.className });
-    res.json(sess);
-});
-app.post('/api/games/mountain', async (req, res) => {
-    const data = injectSchoolId(req, req.body);
-    await GameSessionModel.findOneAndUpdate(
-        { schoolId: data.schoolId, className: data.className },
-        data,
-        { upsert: true }
-    );
-    res.json({ success: true });
-});
-app.get('/api/games/lucky-config', async (req, res) => {
-    const { className, ownerId } = req.query;
-    const config = await LuckyDrawConfigModel.findOne({ ...getQueryFilter(req), className, ownerId });
-    res.json(config);
+    if (req.headers['x-user-role'] === 'PRINCIPAL') filter.role = { $ne: 'ADMIN' };
+    if (req.query.role) filter.role = req.query.role;
+    res.json(await User.find(filter).sort({ createTime: -1 })); 
 });
-app.post('/api/games/lucky-config', async (req, res) => {
-    const data = injectSchoolId(req, req.body);
-    await LuckyDrawConfigModel.findOneAndUpdate(
-        { schoolId: data.schoolId, className: data.className, ownerId: data.ownerId },
-        data,
-        { upsert: true }
-    );
-    res.json({ success: true });
+app.put('/api/users/:id', async (req, res) => {
+    const userId = req.params.id;
+    const updates = req.body;
+    try {
+        const user = await User.findById(userId);
+        if (!user) return res.status(404).json({ error: 'User not found' });
+        if (user.status !== 'active' && updates.status === 'active' && user.role === 'STUDENT') {
+            await Student.findOneAndUpdate({ studentNo: user.studentNo, schoolId: user.schoolId }, { $set: { schoolId: user.schoolId, studentNo: user.studentNo, seatNo: user.seatNo, name: user.trueName, className: user.homeroomClass, gender: user.gender || 'Male', parentName: user.parentName, parentPhone: user.parentPhone, address: user.address, idCard: user.idCard, status: 'Enrolled', birthday: '2015-01-01' } }, { upsert: true, new: true });
+        }
+        await User.findByIdAndUpdate(userId, updates);
+        res.json({});
+    } catch (e) { res.status(500).json({ error: e.message }); }
 });
-app.post('/api/games/lucky-draw', async (req, res) => {
-    const { studentId } = req.body;
-    const student = await Student.findById(studentId);
-    if (!student || (student.drawAttempts || 0) <= 0) {
-        return res.status(400).json({ error: 'NO_ATTEMPTS' });
+app.post('/api/users/class-application', async (req, res) => {
+    const { userId, type, targetClass, action } = req.body; 
+    const userRole = req.headers['x-user-role'];
+    const schoolId = req.headers['x-school-id'];
+    if (action === 'APPLY') {
+        try {
+            const user = await User.findById(userId);
+            if(!user) return res.status(404).json({error:'User not found'});
+            await User.findByIdAndUpdate(userId, { classApplication: { type: type, targetClass: targetClass || '', status: 'PENDING' } });
+            await NotificationModel.create({ schoolId, targetRole: 'ADMIN', title: '新的班主任任免申请', content: `${user.trueName || user.username} 申请 ${type === 'CLAIM' ? '任教' : '卸任'}，请及时处理。`, type: 'warning' });
+            return res.json({ success: true });
+        } catch (e) { return res.status(500).json({ error: e.message }); }
     }
-    
-    student.drawAttempts = (student.drawAttempts || 0) - 1;
-    await Student.findByIdAndUpdate(student._id, student); // Persist manually in mock
-    
-    const config = await LuckyDrawConfigModel.findOne({ 
-        schoolId: student.schoolId, 
-        className: student.className 
-    }); 
-    
-    let result = { prize: '再接再厉', rewardType: 'CONSOLATION' };
-    
-    if (config) {
-        const rand = Math.random() * 100;
-        let cumulative = 0;
-        const totalWeight = config.prizes.reduce((a,b)=>a+b.probability,0) + (config.consolationWeight || 0);
-        const normalizedRand = rand * (totalWeight / 100);
-        
-        for (const p of config.prizes) {
-            cumulative += p.probability;
-            if (normalizedRand <= cumulative) {
-                if (p.count > 0) {
-                    result = { prize: p.name, rewardType: 'ITEM' };
-                    // Decrement count
-                    p.count -= 1;
-                    await LuckyDrawConfigModel.findByIdAndUpdate(config._id, config);
-                    
-                    await StudentRewardModel.create({
-                        schoolId: student.schoolId,
-                        studentId: student._id,
-                        studentName: student.name,
-                        rewardType: 'ITEM',
-                        name: p.name,
-                        status: 'PENDING',
-                        source: '幸运抽奖',
-                        count: 1
-                    });
+    if (userRole === 'ADMIN' || userRole === 'PRINCIPAL') {
+        const user = await User.findById(userId);
+        if (!user || !user.classApplication) return res.status(404).json({ error: 'Application not found' });
+        const appType = user.classApplication.type;
+        const appTarget = user.classApplication.targetClass;
+        if (action === 'APPROVE') {
+            const updates = { classApplication: null };
+            const classes = await ClassModel.find({ schoolId });
+            if (appType === 'CLAIM') {
+                updates.homeroomClass = appTarget;
+                const matchedClass = classes.find(c => (c.grade + c.className) === appTarget);
+                if (matchedClass) {
+                    const teacherIds = matchedClass.homeroomTeacherIds || [];
+                    if (!teacherIds.includes(userId)) {
+                        teacherIds.push(userId);
+                        const teachers = await User.find({ _id: { $in: teacherIds } });
+                        const names = teachers.map(t => t.trueName || t.username).join(', ');
+                        await ClassModel.findByIdAndUpdate(matchedClass._id, { homeroomTeacherIds: teacherIds, teacherName: names });
+                    }
+                }
+            } else if (appType === 'RESIGN') {
+                updates.homeroomClass = '';
+                const matchedClass = classes.find(c => (c.grade + c.className) === user.homeroomClass);
+                if (matchedClass) {
+                    const teacherIds = (matchedClass.homeroomTeacherIds || []).filter(id => id !== userId);
+                    const teachers = await User.find({ _id: { $in: teacherIds } });
+                    const names = teachers.map(t => t.trueName || t.username).join(', ');
+                    await ClassModel.findByIdAndUpdate(matchedClass._id, { homeroomTeacherIds: teacherIds, teacherName: names });
                 }
-                break;
             }
-        }
-        
-        if (result.rewardType === 'CONSOLATION') {
-             result.prize = config.defaultPrize || '再接再厉';
-             await StudentRewardModel.create({
-                schoolId: student.schoolId,
-                studentId: student._id,
-                studentName: student.name,
-                rewardType: 'CONSOLATION',
-                name: result.prize,
-                status: 'REDEEMED',
-                source: '幸运抽奖'
-            });
-        }
+            await User.findByIdAndUpdate(userId, updates);
+        } else await User.findByIdAndUpdate(userId, { 'classApplication.status': 'REJECTED' });
+        return res.json({ success: true });
     }
-    res.json(result);
+    res.status(403).json({ error: 'Permission denied' });
 });
-app.post('/api/games/grant-reward', async (req, res) => {
-    const data = injectSchoolId(req, req.body);
-    const { studentId, count, rewardType } = data;
-    
-    const student = await Student.findById(studentId);
-    if (!student) return res.status(404).json({ error: 'Student not found' });
-
-    if (rewardType === 'DRAW_COUNT') {
-        student.drawAttempts = (student.drawAttempts || 0) + count;
-        await Student.findByIdAndUpdate(studentId, student);
-        
-        await StudentRewardModel.create({
-            schoolId: student.schoolId,
-            studentId,
-            studentName: student.name,
-            rewardType: 'DRAW_COUNT',
-            name: '抽奖券',
-            count,
-            status: 'REDEEMED',
-            source: '老师发放'
-        });
-    } else {
-        await StudentRewardModel.create({
-            schoolId: student.schoolId,
-            studentId,
-            studentName: student.name,
-            rewardType: 'ITEM',
-            name: data.name,
-            count,
-            status: 'PENDING',
-            source: '老师发放'
-        });
+app.post('/api/students/promote', async (req, res) => {
+    const { teacherFollows } = req.body; 
+    const sId = req.headers['x-school-id'];
+    const GRADE_MAP = { '一年级': '二年级', '二年级': '三年级', '三年级': '四年级', '四年级': '五年级', '五年级': '六年级', '六年级': '毕业', '初一': '初二', '七年级': '八年级', '初二': '初三', '八年级': '九年级', '初三': '毕业', '九年级': '毕业', '高一': '高二', '高二': '高三', '高三': '毕业' };
+    const classes = await ClassModel.find(getQueryFilter(req));
+    let promotedCount = 0;
+    for (const cls of classes) {
+        const currentGrade = cls.grade;
+        const nextGrade = GRADE_MAP[currentGrade] || currentGrade;
+        const suffix = cls.className; 
+        if (nextGrade === '毕业') {
+             const oldFullClass = cls.grade + cls.className;
+             await Student.updateMany({ className: oldFullClass, ...getQueryFilter(req) }, { status: 'Graduated', className: '已毕业' });
+             if (teacherFollows && cls.homeroomTeacherIds?.length) { await User.updateMany({ _id: { $in: cls.homeroomTeacherIds }, schoolId: sId }, { homeroomClass: '' }); await ClassModel.findByIdAndUpdate(cls._id, { teacherName: '', homeroomTeacherIds: [] }); }
+        } else {
+             const oldFullClass = cls.grade + cls.className;
+             const newFullClass = nextGrade + suffix; 
+             await ClassModel.findOneAndUpdate({ grade: nextGrade, className: suffix, schoolId: sId }, { schoolId: sId, grade: nextGrade, className: suffix, teacherName: teacherFollows ? cls.teacherName : undefined, homeroomTeacherIds: teacherFollows ? cls.homeroomTeacherIds : [] }, { upsert: true });
+             const result = await Student.updateMany({ className: oldFullClass, status: 'Enrolled', ...getQueryFilter(req) }, { className: newFullClass });
+             promotedCount += result.modifiedCount;
+             if (teacherFollows && cls.homeroomTeacherIds?.length) { await User.updateMany({ _id: { $in: cls.homeroomTeacherIds }, schoolId: sId, homeroomClass: oldFullClass }, { homeroomClass: newFullClass }); await ClassModel.findByIdAndUpdate(cls._id, { teacherName: '', homeroomTeacherIds: [] }); }
+        }
     }
-    res.json({ success: true });
+    res.json({ success: true, count: promotedCount });
+});
+app.post('/api/games/lucky-config', async (req, res) => {
+   const data = injectSchoolId(req, req.body);
+   if (req.headers['x-user-role'] === 'TEACHER') {
+       const user = await User.findOne({ username: req.headers['x-user-username'] });
+       data.ownerId = user ? user._id.toString() : null;
+   }
+   await LuckyDrawConfigModel.findOneAndUpdate({ className: data.className, ...getQueryFilter(req), ownerId: data.ownerId }, data, { upsert: true });
+   res.json({ success: true });
+});
+app.post('/api/games/lucky-draw', async (req, res) => {
+   const { studentId } = req.body; 
+   const schoolId = req.headers['x-school-id'];
+   const userRole = req.headers['x-user-role'];
+   try {
+      const student = await Student.findById(studentId);
+      if (!student) return res.status(404).json({ error: 'Student not found' });
+      let configFilter = { className: student.className, schoolId };
+      if (userRole === 'TEACHER') {
+          const user = await User.findOne({ username: req.headers['x-user-username'] });
+          configFilter.ownerId = user ? user._id.toString() : null;
+      }
+      const config = await LuckyDrawConfigModel.findOne(configFilter);
+      const prizes = config?.prizes || [];
+      const defaultPrize = config?.defaultPrize || '再接再厉';
+      const dailyLimit = config?.dailyLimit || 3;
+      const consolationWeight = config?.consolationWeight || 0;
+      const availablePrizes = prizes.filter(p => (p.count === undefined || p.count > 0));
+      if (availablePrizes.length === 0 && consolationWeight === 0) return res.status(400).json({ error: 'POOL_EMPTY', message: '奖品库存不足' });
+      if (userRole === 'STUDENT') {
+          if (student.drawAttempts <= 0) return res.status(403).json({ error: '次数不足', message: '您的抽奖次数已用完' });
+          const today = new Date().toISOString().split('T')[0];
+          let dailyLog = student.dailyDrawLog || { date: today, count: 0 };
+          if (dailyLog.date !== today) dailyLog = { date: today, count: 0 };
+          if (dailyLog.count >= dailyLimit) return res.status(403).json({ error: 'DAILY_LIMIT_REACHED', message: `今日抽奖次数已达上限 (${dailyLimit}次)` });
+          dailyLog.count += 1;
+          student.drawAttempts -= 1;
+          student.dailyDrawLog = dailyLog;
+          await student.save();
+      } else {
+          if (student.drawAttempts <= 0) return res.status(403).json({ error: '次数不足', message: '该学生抽奖次数已用完' });
+          student.drawAttempts -= 1;
+          await student.save();
+      }
+      let totalWeight = consolationWeight;
+      availablePrizes.forEach(p => totalWeight += (p.probability || 0));
+      let random = Math.random() * totalWeight;
+      let selectedPrize = defaultPrize;
+      let rewardType = 'CONSOLATION'; 
+      let matchedPrize = null;
+      for (const p of availablePrizes) {
+          random -= (p.probability || 0);
+          if (random <= 0) { matchedPrize = p; break; }
+      }
+      if (matchedPrize) {
+         selectedPrize = matchedPrize.name;
+         rewardType = 'ITEM'; 
+         if (config._id) await LuckyDrawConfigModel.updateOne({ _id: config._id, "prizes.id": matchedPrize.id }, { $inc: { "prizes.$.count": -1 } });
+      }
+      let ownerId = config?.ownerId;
+      await StudentRewardModel.create({ schoolId, studentId, studentName: student.name, rewardType, name: selectedPrize, count: 1, status: 'PENDING', source: '幸运大抽奖', ownerId });
+      res.json({ prize: selectedPrize, rewardType });
+   } catch (e) { res.status(500).json({ error: e.message }); }
 });
-
-// Monster & Zen Configs
 app.get('/api/games/monster-config', async (req, res) => {
-    const config = await GameMonsterConfigModel.findOne(getQueryFilter(req));
-    res.json(config);
+    const filter = getQueryFilter(req);
+    const ownerFilter = await getGameOwnerFilter(req);
+    if (req.query.className) filter.className = req.query.className;
+    Object.assign(filter, ownerFilter);
+    const config = await GameMonsterConfigModel.findOne(filter);
+    res.json(config || {});
 });
 app.post('/api/games/monster-config', async (req, res) => {
     const data = injectSchoolId(req, req.body);
-    await GameMonsterConfigModel.findOneAndUpdate(
-        { schoolId: data.schoolId, className: data.className },
-        data,
-        { upsert: true }
-    );
+    if (req.headers['x-user-role'] === 'TEACHER') {
+       const user = await User.findOne({ username: req.headers['x-user-username'] });
+       data.ownerId = user ? user._id.toString() : null;
+    }
+    await GameMonsterConfigModel.findOneAndUpdate({ className: data.className, ...getQueryFilter(req), ownerId: data.ownerId }, data, { upsert: true });
     res.json({ success: true });
 });
 app.get('/api/games/zen-config', async (req, res) => {
-    const config = await GameZenConfigModel.findOne(getQueryFilter(req));
-    res.json(config);
+    const filter = getQueryFilter(req);
+    const ownerFilter = await getGameOwnerFilter(req);
+    if (req.query.className) filter.className = req.query.className;
+    Object.assign(filter, ownerFilter);
+    const config = await GameZenConfigModel.findOne(filter);
+    res.json(config || {});
 });
 app.post('/api/games/zen-config', async (req, res) => {
     const data = injectSchoolId(req, req.body);
-    await GameZenConfigModel.findOneAndUpdate(
-        { schoolId: data.schoolId, className: data.className },
-        data,
-        { upsert: true }
-    );
-    res.json({ success: true });
-});
-
-// --- ACHIEVEMENTS ---
-app.get('/api/achievements/config', async (req, res) => {
-    const config = await AchievementConfigModel.findOne({ ...getQueryFilter(req), className: req.query.className });
-    res.json(config);
-});
-app.post('/api/achievements/config', async (req, res) => {
-    const data = injectSchoolId(req, req.body);
-    await AchievementConfigModel.findOneAndUpdate(
-        { schoolId: data.schoolId, className: data.className },
-        data,
-        { upsert: true }
-    );
-    res.json({ success: true });
-});
-app.get('/api/achievements/student', async (req, res) => {
-    const { studentId, semester } = req.query;
-    const filter = { studentId };
-    if (semester) filter.semester = semester;
-    const list = await StudentAchievementModel.find(filter);
-    res.json(list);
-});
-app.post('/api/achievements/grant', async (req, res) => {
-    const { studentId, achievementId, semester } = req.body;
-    const student = await Student.findById(studentId);
-    const config = await AchievementConfigModel.findOne({ schoolId: student.schoolId, className: student.className });
-    const ach = config.achievements.find(a => a.id === achievementId);
-    
-    if (ach) {
-        await StudentAchievementModel.create({
-            schoolId: student.schoolId,
-            studentId,
-            achievementId,
-            achievementName: ach.name,
-            achievementIcon: ach.icon,
-            points: ach.points,
-            semester,
-            createTime: new Date()
-        });
-        
-        student.flowerBalance = (student.flowerBalance || 0) + ach.points;
-        await Student.findByIdAndUpdate(studentId, student);
+    if (req.headers['x-user-role'] === 'TEACHER') {
+       const user = await User.findOne({ username: req.headers['x-user-username'] });
+       data.ownerId = user ? user._id.toString() : null;
     }
+    await GameZenConfigModel.findOneAndUpdate({ className: data.className, ...getQueryFilter(req), ownerId: data.ownerId }, data, { upsert: true });
     res.json({ success: true });
 });
-app.get('/api/achievements/teacher-rules', async (req, res) => {
+app.get('/api/games/mountain', async (req, res) => { res.json(await GameSessionModel.findOne({...getQueryFilter(req), className: req.query.className})); });
+app.post('/api/games/mountain', async (req, res) => { 
+    const { className } = req.body;
+    const sId = req.headers['x-school-id'];
+    const role = req.headers['x-user-role'];
     const username = req.headers['x-user-username'];
-    if (username) {
+    if (role === 'TEACHER') {
         const user = await User.findOne({ username });
-        if (user) {
-            const rules = await TeacherExchangeConfigModel.findOne({ teacherId: user._id });
-            return res.json(rules || { rules: [] });
-        }
-    }
-    if (req.query.teacherIds) {
-        const ids = req.query.teacherIds.split(',');
-        const list = await TeacherExchangeConfigModel.find({ teacherId: { $in: ids } });
-        return res.json(list);
+        const cls = await ClassModel.findOne({ schoolId: sId, $expr: { $eq: [{ $concat: ["$grade", "$className"] }, className] } });
+        if (!cls) return res.status(404).json({ error: 'Class not found' });
+        const allowedIds = cls.homeroomTeacherIds || [];
+        if (!allowedIds.includes(user._id.toString())) return res.status(403).json({ error: 'PERMISSION_DENIED', message: '只有班主任可以操作登峰游戏' });
     }
-    res.json({});
+    await GameSessionModel.findOneAndUpdate({ className, ...getQueryFilter(req) }, injectSchoolId(req, req.body), {upsert:true}); 
+    res.json({}); 
 });
-app.post('/api/achievements/teacher-rules', async (req, res) => {
-    const username = req.headers['x-user-username'];
-    if (username) {
-        const user = await User.findOne({ username });
-        if (user) {
-            const data = { ...req.body, teacherId: user._id, teacherName: user.trueName || user.username };
-            await TeacherExchangeConfigModel.findOneAndUpdate({ teacherId: user._id }, data, { upsert: true });
-            return res.json({ success: true });
-        }
+app.get('/api/rewards', async (req, res) => { 
+    const filter = getQueryFilter(req);
+    if (req.headers['x-user-role'] === 'TEACHER') {
+       const user = await User.findOne({ username: req.headers['x-user-username'] });
+       if (user) filter.ownerId = user._id.toString();
     }
-    res.status(400).json({ error: 'User not found' });
-});
-app.post('/api/achievements/exchange', async (req, res) => {
-    const { studentId, ruleId, teacherId } = req.body;
-    
-    // Find Rule from specific Teacher Config
-    const config = await TeacherExchangeConfigModel.findOne({ teacherId });
-    const rule = config?.rules.find(r => r.id === ruleId);
-    const student = await Student.findById(studentId);
-
-    if (!rule || !student) return res.status(404).json({ error: 'Data not found' });
-    if ((student.flowerBalance || 0) < rule.cost) return res.status(400).json({ error: 'Insufficient balance' });
-
-    // Deduct Balance
-    student.flowerBalance = (student.flowerBalance || 0) - rule.cost;
-    await Student.findByIdAndUpdate(studentId, student);
-
-    // Grant Reward
-    if (rule.rewardType === 'DRAW_COUNT') {
-        student.drawAttempts = (student.drawAttempts || 0) + rule.rewardValue;
-        await Student.findByIdAndUpdate(studentId, student);
-        
-        await StudentRewardModel.create({
-            schoolId: student.schoolId,
-            studentId,
-            studentName: student.name,
-            rewardType: 'DRAW_COUNT',
-            name: rule.rewardName,
-            count: rule.rewardValue,
-            status: 'REDEEMED',
-            source: '小红花兑换'
-        });
-    } else {
-        await StudentRewardModel.create({
-            schoolId: student.schoolId,
-            studentId,
-            studentName: student.name,
-            rewardType: 'ITEM',
-            name: rule.rewardName,
-            count: rule.rewardValue,
-            status: 'PENDING',
-            source: '小红花兑换'
-        });
+    if(req.query.studentId) filter.studentId = req.query.studentId;
+    if (req.query.className) {
+        const classStudents = await Student.find({ className: req.query.className, ...getQueryFilter(req) }, '_id');
+        filter.studentId = { $in: classStudents.map(s => s._id.toString()) };
     }
-    res.json({ success: true });
-});
-
-// --- REWARDS ---
-app.get('/api/rewards', async (req, res) => {
-    const { studentId, scope, className, page = 1, limit = 20 } = req.query;
-    const filter = getQueryFilter(req);
-    
-    if (studentId) filter.studentId = studentId;
     if (req.query.excludeType) filter.rewardType = { $ne: req.query.excludeType };
-
-    if (scope === 'class' && className) {
-        const students = await Student.find({ className, ...getQueryFilter(req) });
-        const ids = students.map(s => s._id);
-        filter.studentId = { $in: ids };
-    }
-
+    const page = parseInt(req.query.page) || 1;
+    const limit = parseInt(req.query.limit) || 20;
     const skip = (page - 1) * limit;
     const total = await StudentRewardModel.countDocuments(filter);
-    const list = await StudentRewardModel.find(filter).sort({ createTime: -1 }).skip(skip).limit(Number(limit));
-    res.json({ list, total });
+    const list = await StudentRewardModel.find(filter).sort({createTime:-1}).skip(skip).limit(limit);
+    res.json({ list, total }); 
 });
-app.post('/api/rewards', async (req, res) => {
+app.post('/api/rewards', async (req, res) => { 
     const data = injectSchoolId(req, req.body);
-    await StudentRewardModel.create(data);
-    res.json({ success: true });
-});
-app.put('/api/rewards/:id', async (req, res) => {
-    await StudentRewardModel.findByIdAndUpdate(req.params.id, req.body);
-    res.json({ success: true });
+    if (!data.count) data.count = 1;
+    if (req.headers['x-user-role'] === 'TEACHER') {
+       const user = await User.findOne({ username: req.headers['x-user-username'] });
+       data.ownerId = user ? user._id.toString() : null;
+    }
+    if(data.rewardType==='DRAW_COUNT') { data.status='REDEEMED'; await Student.findByIdAndUpdate(data.studentId, {$inc:{drawAttempts:data.count}}); }
+    await StudentRewardModel.create(data); 
+    res.json({}); 
+});
+app.post('/api/games/grant-reward', async (req, res) => { 
+    const { studentId, count, rewardType, name } = req.body;
+    const finalCount = count || 1;
+    const finalName = name || (rewardType === 'DRAW_COUNT' ? '抽奖券' : '奖品');
+    let ownerId = null;
+    if (req.headers['x-user-role'] === 'TEACHER') {
+       const user = await User.findOne({ username: req.headers['x-user-username'] });
+       ownerId = user ? user._id.toString() : null;
+    }
+    if (rewardType === 'DRAW_COUNT') await Student.findByIdAndUpdate(studentId, { $inc: { drawAttempts: finalCount } });
+    await StudentRewardModel.create({ schoolId: req.headers['x-school-id'], studentId, studentName: (await Student.findById(studentId)).name, rewardType, name: finalName, count: finalCount, status: rewardType === 'DRAW_COUNT' ? 'REDEEMED' : 'PENDING', source: '教师发放', ownerId });
+    res.json({}); 
 });
-app.delete('/api/rewards/:id', async (req, res) => {
-    await StudentRewardModel.findByIdAndDelete(req.params.id);
+app.put('/api/classes/:id', async (req, res) => {
+    const classId = req.params.id;
+    const { grade, className, teacherName, homeroomTeacherIds } = req.body;
+    const sId = req.headers['x-school-id'];
+    const oldClass = await ClassModel.findById(classId);
+    if (!oldClass) return res.status(404).json({ error: 'Class not found' });
+    const newFullClass = grade + className;
+    const oldFullClass = oldClass.grade + oldClass.className;
+    const oldTeacherIds = oldClass.homeroomTeacherIds || [];
+    const newTeacherIds = homeroomTeacherIds || [];
+    const removedIds = oldTeacherIds.filter(id => !newTeacherIds.includes(id));
+    if (removedIds.length > 0) await User.updateMany({ _id: { $in: removedIds }, schoolId: sId }, { homeroomClass: '' });
+    if (newTeacherIds.length > 0) await User.updateMany({ _id: { $in: newTeacherIds }, schoolId: sId }, { homeroomClass: newFullClass });
+    let displayTeacherName = teacherName;
+    if (newTeacherIds.length > 0) {
+        const teachers = await User.find({ _id: { $in: newTeacherIds } });
+        displayTeacherName = teachers.map(t => t.trueName || t.username).join(', ');
+    }
+    await ClassModel.findByIdAndUpdate(classId, { grade, className, teacherName: displayTeacherName, homeroomTeacherIds: newTeacherIds });
+    if (oldFullClass !== newFullClass) {
+        await Student.updateMany({ className: oldFullClass, schoolId: sId }, { className: newFullClass });
+        await User.updateMany({ homeroomClass: oldFullClass, schoolId: sId }, { homeroomClass: newFullClass });
+    }
     res.json({ success: true });
 });
-app.post('/api/rewards/:id/redeem', async (req, res) => {
-    await StudentRewardModel.findByIdAndUpdate(req.params.id, { status: 'REDEEMED' });
-    res.json({ success: true });
+app.post('/api/classes', async (req, res) => { 
+    const data = injectSchoolId(req, req.body);
+    const { homeroomTeacherIds } = req.body;
+    if (homeroomTeacherIds && homeroomTeacherIds.length > 0) {
+        const teachers = await User.find({ _id: { $in: homeroomTeacherIds } });
+        data.teacherName = teachers.map(t => t.trueName || t.username).join(', ');
+    }
+    await ClassModel.create(data);
+    if (homeroomTeacherIds && homeroomTeacherIds.length > 0) await User.updateMany({ _id: { $in: homeroomTeacherIds }, schoolId: data.schoolId }, { homeroomClass: data.grade + data.className });
+    res.json({}); 
 });
-
-// --- WISH TREE ROUTES ---
-app.get('/api/wishes', async (req, res) => {
+app.get('/api/courses', async (req, res) => { 
     const filter = getQueryFilter(req);
-    const { studentId, teacherId, status } = req.query;
-    if (studentId) filter.studentId = studentId;
-    if (teacherId) filter.teacherId = teacherId;
-    if (status) filter.status = status;
-    
-    // Sort: Pending first, then by time
-    const wishes = await WishModel.find(filter).sort({ status: -1, createTime: -1 });
-    res.json(wishes);
+    if (req.query.teacherId) filter.teacherId = req.query.teacherId;
+    res.json(await Course.find(filter)); 
 });
-
-app.post('/api/wishes', async (req, res) => {
+app.post('/api/courses', async (req, res) => { 
     const data = injectSchoolId(req, req.body);
-    const existing = await WishModel.findOne({ 
-        studentId: data.studentId, 
-        status: 'PENDING' 
-    });
-    if (existing) {
-        return res.status(400).json({ error: 'LIMIT_REACHED', message: '您还有一个未实现的愿望，请耐心等待实现后再许愿。' });
-    }
-    await WishModel.create(data);
-    res.json({ success: true });
+    try { await Course.create(data); res.json({}); } catch(e) { if (e.code === 11000) return res.status(409).json({ error: 'DUPLICATE', message: '该班级该科目已有任课老师' }); res.status(500).json({ error: e.message }); }
 });
-
-app.post('/api/wishes/:id/fulfill', async (req, res) => {
-    await WishModel.findByIdAndUpdate(req.params.id, { 
-        status: 'FULFILLED', 
-        fulfillTime: new Date() 
-    });
-    res.json({ success: true });
+app.get('/api/public/schools', async (req, res) => { res.json(await School.find({}, 'name code _id')); });
+app.get('/api/public/config', async (req, res) => { 
+    const currentSem = getAutoSemester();
+    let config = await ConfigModel.findOne({ key: 'main' });
+    if (config) {
+        let semesters = config.semesters || [];
+        if (!semesters.includes(currentSem)) { semesters.unshift(currentSem); config.semesters = semesters; config.semester = currentSem; await ConfigModel.updateOne({ key: 'main' }, { semesters, semester: currentSem }); }
+    } else { config = { key: 'main', allowRegister: true, semester: currentSem, semesters: [currentSem] }; }
+    res.json(config); 
 });
-
-app.post('/api/wishes/random-fulfill', async (req, res) => {
-    const { teacherId } = req.body;
-    const pendingWishes = await WishModel.find({ 
-        teacherId, 
-        status: 'PENDING',
-        ...getQueryFilter(req)
-    });
-    
-    if (pendingWishes.length === 0) {
-        return res.status(404).json({ error: 'NO_WISHES', message: '暂无待实现的愿望' });
+app.get('/api/public/meta', async (req, res) => { res.json({ classes: await ClassModel.find({ schoolId: req.query.schoolId }), subjects: await SubjectModel.find({ schoolId: req.query.schoolId }) }); });
+app.post('/api/auth/login', async (req, res) => {
+  const { username, password } = req.body;
+  const user = await User.findOne({ username, password });
+  if (!user) return res.status(401).json({ message: 'Error' });
+  if (user.status !== 'active') return res.status(403).json({ error: 'PENDING_APPROVAL' });
+  res.json(user);
+});
+app.get('/api/schools', async (req, res) => { res.json(await School.find()); });
+app.post('/api/schools', async (req, res) => { res.json(await School.create(req.body)); });
+app.put('/api/schools/:id', async (req, res) => { await School.findByIdAndUpdate(req.params.id, req.body); res.json({}); });
+app.delete('/api/schools/:id', async (req, res) => {
+    const schoolId = req.params.id;
+    try { await School.findByIdAndDelete(schoolId); await User.deleteMany({ schoolId }); await Student.deleteMany({ schoolId }); await ClassModel.deleteMany({ schoolId }); await SubjectModel.deleteMany({ schoolId }); await Course.deleteMany({ schoolId }); await Score.deleteMany({ schoolId }); await ExamModel.deleteMany({ schoolId }); await ScheduleModel.deleteMany({ schoolId }); await NotificationModel.deleteMany({ schoolId }); await AttendanceModel.deleteMany({ schoolId }); await LeaveRequestModel.deleteMany({ schoolId }); await GameSessionModel.deleteMany({ schoolId }); await StudentRewardModel.deleteMany({ schoolId }); await LuckyDrawConfigModel.deleteMany({ schoolId }); await GameMonsterConfigModel.deleteMany({ schoolId }); await GameZenConfigModel.deleteMany({ schoolId }); await AchievementConfigModel.deleteMany({ schoolId }); await StudentAchievementModel.deleteMany({ schoolId }); await SchoolCalendarModel.deleteMany({ schoolId }); res.json({ success: true }); } catch (e) { res.status(500).json({ error: e.message }); }
+});
+app.delete('/api/users/:id', async (req, res) => { 
+    const requesterRole = req.headers['x-user-role'];
+    if (requesterRole === 'PRINCIPAL') {
+        const user = await User.findById(req.params.id);
+        if (!user || user.schoolId !== req.headers['x-school-id']) return res.status(403).json({error: 'Permission denied'});
+        if (user.role === 'ADMIN') return res.status(403).json({error: 'Cannot delete admin'});
     }
-    
-    const randomWish = pendingWishes[Math.floor(Math.random() * pendingWishes.length)];
-    await WishModel.findByIdAndUpdate(randomWish._id, { 
-        status: 'FULFILLED', 
-        fulfillTime: new Date() 
-    });
-    
-    res.json({ success: true, wish: randomWish });
+    await User.findByIdAndDelete(req.params.id); res.json({}); 
 });
-
-// --- FEEDBACK WALL ROUTES ---
-app.get('/api/feedback', async (req, res) => {
+app.get('/api/students', async (req, res) => { res.json(await Student.find(getQueryFilter(req))); });
+app.post('/api/students', async (req, res) => { 
+    const data = injectSchoolId(req, req.body);
+    if (data.studentNo === '') delete data.studentNo;
+    try {
+        const existing = await Student.findOne({ schoolId: data.schoolId, name: data.name, className: data.className });
+        if (existing) { Object.assign(existing, data); if (!existing.studentNo) { existing.studentNo = await generateStudentNo(); } await existing.save(); } else { if (!data.studentNo) { data.studentNo = await generateStudentNo(); } await Student.create(data); }
+        res.json({ success: true });
+    } catch (e) { if (e.code === 11000) return res.status(409).json({ error: 'DUPLICATE', message: '保存失败：存在重复的系统ID' }); res.status(500).json({ error: e.message }); }
+});
+app.put('/api/students/:id', async (req, res) => { await Student.findByIdAndUpdate(req.params.id, req.body); res.json({}); });
+app.delete('/api/students/:id', async (req, res) => { await Student.findByIdAndDelete(req.params.id); res.json({}); });
+app.get('/api/classes', async (req, res) => { 
     const filter = getQueryFilter(req);
-    const { senderId, targetId, role } = req.query; 
-    
-    if (senderId) {
-        filter.senderId = senderId;
-    } else if (targetId) {
-        filter.targetId = targetId;
-    } else if (role === 'ADMIN') {
-        filter.targetId = 'ADMIN';
+    const cls = await ClassModel.find(filter); 
+    const resData = await Promise.all(cls.map(async c => {
+        const count = await Student.countDocuments({ className: c.grade + c.className, status: 'Enrolled', ...filter });
+        return { ...c.toObject(), studentCount: count };
+    }));
+    res.json(resData); 
+});
+app.delete('/api/classes/:id', async (req, res) => { 
+    const cls = await ClassModel.findById(req.params.id);
+    if (cls && cls.homeroomTeacherIds) await User.updateMany({ _id: { $in: cls.homeroomTeacherIds }, schoolId: cls.schoolId }, { homeroomClass: '' });
+    await ClassModel.findByIdAndDelete(req.params.id); res.json({}); 
+});
+app.get('/api/subjects', async (req, res) => { res.json(await SubjectModel.find(getQueryFilter(req))); });
+app.post('/api/subjects', async (req, res) => { await SubjectModel.create(injectSchoolId(req, req.body)); res.json({}); });
+app.put('/api/subjects/:id', async (req, res) => { await SubjectModel.findByIdAndUpdate(req.params.id, req.body); res.json({}); });
+app.delete('/api/subjects/:id', async (req, res) => { await SubjectModel.findByIdAndDelete(req.params.id); res.json({}); });
+app.put('/api/courses/:id', async (req, res) => { await Course.findByIdAndUpdate(req.params.id, req.body); res.json({}); });
+app.delete('/api/courses/:id', async (req, res) => { await Course.findByIdAndDelete(req.params.id); res.json({}); });
+app.get('/api/scores', async (req, res) => { res.json(await Score.find(getQueryFilter(req))); });
+app.post('/api/scores', async (req, res) => { await Score.create(injectSchoolId(req, req.body)); res.json({}); });
+app.put('/api/scores/:id', async (req, res) => { await Score.findByIdAndUpdate(req.params.id, req.body); res.json({}); });
+app.delete('/api/scores/:id', async (req, res) => { await Score.findByIdAndDelete(req.params.id); res.json({}); });
+app.get('/api/exams', async (req, res) => { res.json(await ExamModel.find(getQueryFilter(req))); });
+app.post('/api/exams', async (req, res) => { await ExamModel.findOneAndUpdate({name:req.body.name}, injectSchoolId(req, req.body), {upsert:true}); res.json({}); });
+app.get('/api/schedules', async (req, res) => { 
+    const query = { ...getQueryFilter(req), ...req.query };
+    if (query.grade) { query.className = { $regex: '^' + query.grade }; delete query.grade; }
+    res.json(await ScheduleModel.find(query)); 
+});
+app.post('/api/schedules', async (req, res) => { 
+    const filter = { className:req.body.className, dayOfWeek:req.body.dayOfWeek, period:req.body.period };
+    const sId = req.headers['x-school-id'];
+    if(sId) filter.schoolId = sId;
+    await ScheduleModel.findOneAndUpdate(filter, injectSchoolId(req, req.body), {upsert:true}); res.json({}); 
+});
+app.delete('/api/schedules', async (req, res) => { await ScheduleModel.deleteOne({...getQueryFilter(req), ...req.query}); res.json({}); });
+app.get('/api/stats', async (req, res) => { 
+    const filter = getQueryFilter(req);
+    const studentCount = await Student.countDocuments(filter);
+    const courseCount = await Course.countDocuments(filter);
+    const scores = await Score.find({...filter, status: 'Normal'});
+    let avgScore = 0; let excellentRate = '0%';
+    if (scores.length > 0) {
+        const total = scores.reduce((sum, s) => sum + s.score, 0);
+        avgScore = parseFloat((total / scores.length).toFixed(1));
+        const excellent = scores.filter(s => s.score >= 90).length;
+        excellentRate = Math.round((excellent / scores.length) * 100) + '%';
     }
-
-    const feedbacks = await FeedbackModel.find(filter).sort({ createTime: -1 });
-    res.json(feedbacks);
+    res.json({ studentCount, courseCount, avgScore, excellentRate });
 });
-
-app.post('/api/feedback', async (req, res) => {
-    const data = injectSchoolId(req, req.body);
-    await FeedbackModel.create(data);
+app.get('/api/config', async (req, res) => { 
+    const currentSem = getAutoSemester();
+    let config = await ConfigModel.findOne({key:'main'});
+    if (config) { let semesters = config.semesters || []; if (!semesters.includes(currentSem)) { semesters.unshift(currentSem); config.semesters = semesters; config.semester = currentSem; await ConfigModel.updateOne({ key: 'main' }, { semesters, semester: currentSem }); } } else { config = { key: 'main', allowRegister: true, semester: currentSem, semesters: [currentSem] }; }
+    res.json(config); 
+});
+app.post('/api/config', async (req, res) => { await ConfigModel.findOneAndUpdate({key:'main'}, req.body, {upsert:true}); res.json({}); });
+app.put('/api/rewards/:id', async (req, res) => { await StudentRewardModel.findByIdAndUpdate(req.params.id, req.body); res.json({}); });
+app.delete('/api/rewards/:id', async (req, res) => {
+    const reward = await StudentRewardModel.findById(req.params.id);
+    if (!reward) return res.status(404).json({error: 'Not found'});
+    if (reward.rewardType === 'DRAW_COUNT') {
+        const student = await Student.findById(reward.studentId);
+        if (student && student.drawAttempts < reward.count) return res.status(400).json({ error: 'FAILED_REVOKE', message: '修改失败，次数已被使用' });
+        await Student.findByIdAndUpdate(reward.studentId, { $inc: { drawAttempts: -reward.count } });
+    }
+    await StudentRewardModel.findByIdAndDelete(req.params.id); res.json({});
+});
+app.post('/api/rewards/:id/redeem', async (req, res) => { await StudentRewardModel.findByIdAndUpdate(req.params.id, {status:'REDEEMED'}); res.json({}); });
+app.get('/api/attendance', async (req, res) => {
+    const { className, date, studentId } = req.query;
+    const filter = getQueryFilter(req);
+    if(className) filter.className = className;
+    if(date) filter.date = date;
+    if(studentId) filter.studentId = studentId;
+    res.json(await AttendanceModel.find(filter));
+});
+app.post('/api/attendance/check-in', async (req, res) => {
+    const { studentId, date, status } = req.body;
+    const exists = await AttendanceModel.findOne({ studentId, date });
+    if (exists) return res.status(400).json({ error: 'ALREADY_CHECKED_IN', message: '今日已打卡' });
+    const student = await Student.findById(studentId);
+    await AttendanceModel.create({ schoolId: req.headers['x-school-id'], studentId, studentName: student.name, className: student.className, date, status: status || 'Present', checkInTime: new Date() });
     res.json({ success: true });
 });
-
-app.put('/api/feedback/:id/status', async (req, res) => {
-    const { status } = req.body;
-    await FeedbackModel.findByIdAndUpdate(req.params.id, { status });
+app.post('/api/attendance/batch', async (req, res) => {
+    const { className, date, status } = req.body;
+    const students = await Student.find({ className, ...getQueryFilter(req) });
+    const ops = students.map(s => ({ updateOne: { filter: { studentId: s._id, date }, update: { $setOnInsert: { schoolId: req.headers['x-school-id'], studentId: s._id, studentName: s.name, className: s.className, date, status: status || 'Present', checkInTime: new Date() } }, upsert: true } }));
+    if (ops.length > 0) await AttendanceModel.bulkWrite(ops);
+    res.json({ success: true, count: ops.length });
+});
+app.put('/api/attendance/update', async (req, res) => {
+    const { studentId, date, status } = req.body;
+    const student = await Student.findById(studentId);
+    await AttendanceModel.findOneAndUpdate({ studentId, date }, { schoolId: req.headers['x-school-id'], studentId, studentName: student.name, className: student.className, date, status, checkInTime: new Date() }, { upsert: true });
     res.json({ success: true });
 });
-
-app.post('/api/feedback/batch-ignore', async (req, res) => {
-    const { targetId } = req.body; 
-    await FeedbackModel.updateMany(
-        { targetId, status: 'PENDING', ...getQueryFilter(req) },
-        { status: 'IGNORED' }
-    );
+app.post('/api/leave', async (req, res) => {
+    await LeaveRequestModel.create(injectSchoolId(req, req.body));
+    const { studentId, startDate } = req.body;
+    const student = await Student.findById(studentId);
+    if (student) await AttendanceModel.findOneAndUpdate({ studentId, date: startDate }, { schoolId: req.headers['x-school-id'], studentId, studentName: student.name, className: student.className, date: startDate, status: 'Leave', checkInTime: new Date() }, { upsert: true });
     res.json({ success: true });
 });
-
-// --- BATCH DELETE UTILITY ---
-app.post('/api/batch-delete', async (req, res) => {
-    const { type, ids } = req.body;
-    if (!ids || ids.length === 0) return res.json({ count: 0 });
-
-    let result;
-    if (type === 'student') result = await Student.deleteMany({ _id: { $in: ids } });
-    if (type === 'score') result = await Score.deleteMany({ _id: { $in: ids } });
-    if (type === 'user') result = await User.deleteMany({ _id: { $in: ids } });
-
-    res.json({ count: result.deletedCount });
+app.get('/api/attendance/calendar', async (req, res) => {
+    const { className } = req.query;
+    const filter = getQueryFilter(req);
+    const query = { $and: [ filter, { $or: [{ className: { $exists: false } }, { className: null }, { className }] } ] };
+    res.json(await SchoolCalendarModel.find(query));
 });
-
-// Serve Frontend
-app.use(express.static(path.join(__dirname, 'dist')));
-app.get('*', (req, res) => {
-    res.sendFile(path.join(__dirname, 'dist', 'index.html'));
+app.post('/api/attendance/calendar', async (req, res) => { await SchoolCalendarModel.create(injectSchoolId(req, req.body)); res.json({ success: true }); });
+app.delete('/api/attendance/calendar/:id', async (req, res) => { await SchoolCalendarModel.findByIdAndDelete(req.params.id); res.json({}); });
+app.post('/api/batch-delete', async (req, res) => { 
+    if(req.body.type==='student') await Student.deleteMany({_id:{$in:req.body.ids}});
+    if(req.body.type==='score') await Score.deleteMany({_id:{$in:req.body.ids}});
+    res.json({}); 
 });
 
-app.listen(PORT, () => console.log(`Server running on port ${PORT} (In-Memory DB Mode)`));
+app.get('*', (req, res) => { res.sendFile(path.join(__dirname, 'dist', 'index.html')); });
+app.listen(PORT, () => console.log(`🚀 Server running on port ${PORT}`));

services/api.ts

@@ -1,7 +1,6 @@
 
-import { User, ClassInfo, SystemConfig, Subject, School, Schedule, GameSession, StudentReward, LuckyDrawConfig, Attendance, LeaveRequest, AchievementConfig, SchoolCalendarEntry, TeacherExchangeConfig, Wish, Feedback } from '../types';
+import { User, ClassInfo, SystemConfig, Subject, School, Schedule, GameSession, StudentReward, LuckyDrawConfig, Attendance, LeaveRequest, AchievementConfig, SchoolCalendarEntry, TeacherExchangeConfig } from '../types';
 
-// ... (existing getBaseUrl and request functions) ...
 const getBaseUrl = () => {
   let isProd = false;
   try {
@@ -20,7 +19,6 @@ const getBaseUrl = () => {
 const API_BASE_URL = getBaseUrl();
 
 async function request(endpoint: string, options: RequestInit = {}) {
-  // ... (existing request logic) ...
   const headers: any = { 'Content-Type': 'application/json', ...options.headers };
   
   if (typeof window !== 'undefined') {
@@ -50,18 +48,15 @@ async function request(endpoint: string, options: RequestInit = {}) {
     if (errorData.error === 'BANNED') throw new Error('BANNED');
     if (errorData.error === 'CONFLICT') throw new Error(errorData.message); 
     if (errorData.error === 'INVALID_PASSWORD') throw new Error('INVALID_PASSWORD');
-    if (errorData.error === 'LIMIT_REACHED') throw new Error(errorData.message);
     throw new Error(errorMessage);
   }
   return res.json();
 }
 
 export const api = {
-  // ... (existing methods: init, auth, schools, users, etc.) ...
   init: () => console.log('🔗 API:', API_BASE_URL),
 
   auth: {
-    // ... existing auth methods
     login: async (username: string, password: string): Promise<User> => {
       const user = await request('/auth/login', { method: 'POST', body: JSON.stringify({ username, password }) });
       if (typeof window !== 'undefined') {
@@ -109,7 +104,7 @@ export const api = {
     getAll: () => request('/schools'),
     add: (data: School) => request('/schools', { method: 'POST', body: JSON.stringify(data) }),
     update: (id: string, data: Partial<School>) => request(`/schools/${id}`, { method: 'PUT', body: JSON.stringify(data) }),
-    delete: (id: string) => request(`/schools/${id}`, { method: 'DELETE' })
+    delete: (id: string) => request(`/schools/${id}`, { method: 'DELETE' }) // NEW
   },
 
   users: {
@@ -131,6 +126,7 @@ export const api = {
     add: (data: any) => request('/students', { method: 'POST', body: JSON.stringify(data) }),
     update: (id: string, data: any) => request(`/students/${id}`, { method: 'PUT', body: JSON.stringify(data) }),
     delete: (id: string | number) => request(`/students/${id}`, { method: 'DELETE' }),
+    // NEW: Promote and Transfer
     promote: (data: { teacherFollows: boolean }) => request('/students/promote', { method: 'POST', body: JSON.stringify(data) }),
     transfer: (data: { studentId: string, targetClass: string }) => request('/students/transfer', { method: 'POST', body: JSON.stringify(data) })
   },
@@ -229,6 +225,7 @@ export const api = {
       getStudentAchievements: (studentId: string, semester?: string) => request(`/achievements/student?studentId=${studentId}${semester ? `&semester=${semester}` : ''}`),
       grant: (data: { studentId: string, achievementId: string, semester: string }) => request('/achievements/grant', { method: 'POST', body: JSON.stringify(data) }),
       exchange: (data: { studentId: string, ruleId: string, teacherId?: string }) => request('/achievements/exchange', { method: 'POST', body: JSON.stringify(data) }),
+      // Teacher Exchange Rules
       getMyRules: () => request('/achievements/teacher-rules'),
       saveMyRules: (data: TeacherExchangeConfig) => request('/achievements/teacher-rules', { method: 'POST', body: JSON.stringify(data) }),
       getRulesByTeachers: (teacherIds: string[]) => request(`/achievements/teacher-rules?teacherIds=${teacherIds.join(',')}`),
@@ -247,23 +244,6 @@ export const api = {
     redeem: (id: string) => request(`/rewards/${id}/redeem`, { method: 'POST' }),
   },
 
-  wishes: {
-      getMyWishes: (studentId: string) => request(`/wishes?studentId=${studentId}`),
-      getTeacherWishes: (teacherId: string) => request(`/wishes?teacherId=${teacherId}`),
-      submit: (data: Partial<Wish>) => request('/wishes', { method: 'POST', body: JSON.stringify(data) }),
-      fulfill: (id: string) => request(`/wishes/${id}/fulfill`, { method: 'POST' }),
-      randomFulfill: (teacherId: string) => request('/wishes/random-fulfill', { method: 'POST', body: JSON.stringify({ teacherId }) }),
-  },
-
-  feedback: {
-      getSent: (senderId: string) => request(`/feedback?senderId=${senderId}`),
-      getReceived: (targetId: string) => request(`/feedback?targetId=${targetId}`),
-      getAdmin: () => request('/feedback?role=ADMIN'), // Special param to indicate admin request
-      submit: (data: Partial<Feedback>) => request('/feedback', { method: 'POST', body: JSON.stringify(data) }),
-      updateStatus: (id: string, status: string) => request(`/feedback/${id}/status`, { method: 'PUT', body: JSON.stringify({ status }) }),
-      batchIgnore: (targetId: string) => request('/feedback/batch-ignore', { method: 'POST', body: JSON.stringify({ targetId }) }),
-  },
-
   batchDelete: (type: 'student' | 'score' | 'user', ids: string[]) => {
     return request('/batch-delete', { method: 'POST', body: JSON.stringify({ type, ids }) });
   }

types.ts

@@ -1,7 +1,49 @@
 
+// ... existing imports
+
+// ... existing types (User, School, etc.)
+
+export interface AchievementItem {
+  id: string;
+  name: string;
+  icon: string; 
+  points: number; 
+  description?: string;
+  addedBy?: string; // Teacher ID
+  addedByName?: string; // Teacher Name
+}
+
+export interface ExchangeRule {
+  id: string;
+  cost: number; 
+  rewardType: 'ITEM' | 'DRAW_COUNT';
+  rewardName: string;
+  rewardValue: number; 
+}
+
+// Class-based Config (Shared Achievement Library)
+export interface AchievementConfig {
+  _id?: string;
+  schoolId: string;
+  className: string;
+  achievements: AchievementItem[];
+  // exchangeRules is deprecated here, moving to TeacherExchangeConfig
+  exchangeRules?: ExchangeRule[]; 
+}
+
+// New: Teacher-based Config (Global Rules for a teacher)
+export interface TeacherExchangeConfig {
+  _id?: string;
+  schoolId: string;
+  teacherId: string;
+  teacherName: string;
+  rules: ExchangeRule[];
+}
+
+// ... rest of the file
 export enum UserRole {
   ADMIN = 'ADMIN',
-  PRINCIPAL = 'PRINCIPAL',
+  PRINCIPAL = 'PRINCIPAL', // 新增校长角色
   TEACHER = 'TEACHER',
   STUDENT = 'STUDENT',
   USER = 'USER'
@@ -13,301 +55,308 @@ export enum UserStatus {
   BANNED = 'banned'
 }
 
+export interface School {
+  id?: number;
+  _id?: string;
+  name: string;
+  code: string; 
+}
+
 export interface User {
+  id?: number;
   _id?: string;
-  id?: string | number;
   username: string;
-  password?: string;
-  role: UserRole;
-  status: UserStatus;
-  schoolId?: string;
   trueName?: string;
   phone?: string;
   email?: string;
+  schoolId?: string;
+  role: UserRole;
+  status: UserStatus;
   avatar?: string;
-  teachingSubject?: string;
-  homeroomClass?: string;
+  createTime?: string;
+  teachingSubject?: string; 
+  homeroomClass?: string; // 废弃或仅作显示，主要逻辑移至 ClassInfo.homeroomTeacherIds
+  // Class Application
   classApplication?: {
     type: 'CLAIM' | 'RESIGN';
-    targetClass: string;
-    status: 'PENDING' | 'APPROVED' | 'REJECTED';
+    targetClass?: string;
+    status: 'PENDING' | 'REJECTED';
   };
+  // Student Registration Temp Fields
   studentNo?: string;
   parentName?: string;
   parentPhone?: string;
+  address?: string;
+  gender?: 'Male' | 'Female';
+  seatNo?: string; 
+  idCard?: string; // NEW
 }
 
-export interface School {
+export interface ClassInfo {
+  id?: number;
   _id?: string;
-  id?: string | number;
+  schoolId?: string;
+  grade: string;
+  className: string;
+  teacherName?: string; // Display string (e.g., "张三, 李四")
+  homeroomTeacherIds?: string[]; // Actual IDs for logic
+  studentCount?: number;
+}
+
+export interface Subject {
+  id?: number;
+  _id?: string;
+  schoolId?: string;
   name: string;
   code: string;
+  color: string;
+  excellenceThreshold?: number;
+  thresholds?: Record<string, number>; // Grade specific overrides e.g. {'一年级': 95}
+}
+
+export interface SystemConfig {
+  systemName: string;
+  semester: string;
+  semesters?: string[];
+  allowRegister: boolean;
+  allowAdminRegister: boolean;
+  allowPrincipalRegister?: boolean; // 新增：是否允许校长注册
+  allowStudentRegister?: boolean;
+  maintenanceMode: boolean;
+  emailNotify: boolean;
 }
 
 export interface Student {
+  id?: number;
   _id?: string;
-  id?: string | number;
-  studentNo: string;
+  schoolId?: string;
+  studentNo: string; // System ID (Login ID)
+  seatNo?: string;   // Class Seat Number (Optional, for sorting/display)
   name: string;
-  gender: 'Male' | 'Female';
+  gender: 'Male' | 'Female' | 'Other';
+  birthday: string;
+  idCard: string;
+  phone: string;
   className: string;
-  seatNo?: string;
-  phone?: string;
-  birthday?: string;
-  idCard?: string;
-  status: 'Enrolled' | 'Graduated' | 'Left';
+  status: 'Enrolled' | 'Graduated' | 'Suspended';
   parentName?: string;
   parentPhone?: string;
   address?: string;
-  drawAttempts?: number;
-  flowerBalance?: number;
+  // Game related
+  teamId?: string; 
+  drawAttempts?: number; 
+  dailyDrawLog?: { date: string; count: number }; 
+  // Achievement related
+  flowerBalance?: number; 
 }
 
 export interface Course {
+  id?: number;
   _id?: string;
-  id?: string | number;
-  courseCode?: string;
-  courseName: string;
-  teacherId?: string;
+  schoolId?: string;
+  courseCode: string;
+  courseName: string; // Subject Name
+  className: string; // Target Class (e.g. "一年级(1)班")
   teacherName: string;
-  className: string;
+  teacherId?: string; // Optional linkage
   credits: number;
   capacity: number;
-  enrolled?: number;
+  enrolled: number;
 }
 
 export type ExamStatus = 'Normal' | 'Absent' | 'Leave' | 'Cheat';
 
 export interface Score {
+  id?: number;
   _id?: string;
-  id?: string | number;
-  studentId?: string;
+  schoolId?: string;
   studentName: string;
   studentNo: string;
   courseName: string;
   score: number;
   semester: string;
-  type: string;
+  type: 'Midterm' | 'Final' | 'Quiz';
   examName?: string;
   status?: ExamStatus;
 }
 
-export interface ClassInfo {
-  _id?: string;
-  id?: string | number;
-  grade: string;
-  className: string;
-  homeroomTeacherIds?: string[];
-  teacherName?: string;
-  studentCount?: number;
-}
-
-export interface Subject {
+export interface Exam {
+  id?: number;
   _id?: string;
-  id?: string | number;
+  schoolId?: string;
   name: string;
-  code?: string;
-  color?: string;
-  excellenceThreshold?: number;
-  thresholds?: Record<string, number>;
+  date: string;
+  semester?: string;
+  type?: 'Midterm' | 'Final' | 'Quiz' | string;
 }
 
 export interface Schedule {
+  id?: number;
   _id?: string;
+  schoolId?: string;
   className: string;
+  teacherName: string;
+  subject: string;
   dayOfWeek: number;
   period: number;
-  subject: string;
-  teacherName: string;
 }
 
 export interface Notification {
+  id?: number;
   _id?: string;
+  schoolId?: string;
+  targetRole?: UserRole;
+  targetUserId?: string;
   title: string;
   content: string;
   type: 'info' | 'success' | 'warning' | 'error';
+  isRead?: boolean;
   createTime: string;
-  targetRole?: string;
-  targetUserId?: string;
 }
 
-export interface SystemConfig {
-  systemName?: string;
-  allowRegister?: boolean;
-  allowAdminRegister?: boolean;
-  allowStudentRegister?: boolean;
-  allowPrincipalRegister?: boolean;
-  maintenanceMode?: boolean;
-  emailNotify?: boolean;
-  semester?: string;
-  semesters?: string[];
+export interface ApiResponse<T> {
+  code: number;
+  message: string;
+  data: T;
+  timestamp: number;
 }
 
-export interface Exam {
-  _id?: string;
-  name?: string;
-  date?: string;
-  type?: string;
-}
-
-export interface GameRewardConfig {
-  scoreThreshold: number;
-  rewardType: 'DRAW_COUNT' | 'ITEM' | 'ACHIEVEMENT';
-  rewardName: string;
-  rewardValue: number;
-  achievementId?: string;
-}
+// --- Game Types ---
 
 export interface GameTeam {
   id: string;
   name: string;
-  color: string;
-  avatar: string;
   score: number;
-  members: string[];
+  avatar: string; // Emoji or URL
+  color: string;
+  members: string[]; // Student IDs
+}
+
+export interface GameRewardConfig {
+  scoreThreshold: number; 
+  rewardType: 'ITEM' | 'DRAW_COUNT' | 'ACHIEVEMENT'; 
+  rewardName: string; 
+  rewardValue: number; 
+  achievementId?: string; 
 }
 
 export interface GameSession {
   _id?: string;
   schoolId: string;
-  className: string;
-  subject: string;
+  className: string; 
+  subject: string; 
   isEnabled: boolean;
-  maxSteps: number;
   teams: GameTeam[];
   rewardsConfig: GameRewardConfig[];
+  maxSteps: number; 
 }
 
-export interface LuckyPrize {
-  id: string;
-  name: string;
-  probability: number;
-  count: number;
-}
-
-export interface LuckyDrawConfig {
-  _id?: string;
-  schoolId: string;
-  className: string;
-  ownerId?: string;
-  prizes: LuckyPrize[];
-  dailyLimit?: number;
-  cardCount?: number;
-  defaultPrize?: string;
-  consolationWeight?: number;
+export enum RewardType {
+  ITEM = 'ITEM',
+  DRAW_COUNT = 'DRAW_COUNT',
+  CONSOLATION = 'CONSOLATION',
+  ACHIEVEMENT = 'ACHIEVEMENT' 
 }
 
 export interface StudentReward {
   _id?: string;
-  schoolId: string;
-  studentId: string;
+  schoolId?: string;
+  studentId: string; 
   studentName: string;
-  rewardType: 'DRAW_COUNT' | 'ITEM' | 'CONSOLATION';
+  rewardType: RewardType | string; 
   name: string;
-  count?: number;
+  count?: number; 
   status: 'PENDING' | 'REDEEMED';
-  source?: string;
+  source: string; 
   createTime: string;
+  ownerId?: string;
 }
 
-export interface Attendance {
-  _id?: string;
-  studentId: string;
-  date: string;
-  status: 'Present' | 'Leave' | 'Absent';
-  checkInTime?: string;
-}
-
-export interface LeaveRequest {
-  _id?: string;
-  studentId: string;
-  studentName: string;
-  className: string;
-  reason: string;
-  startDate: string;
-  endDate: string;
-  status: 'PENDING' | 'APPROVED' | 'REJECTED';
-  createTime: string;
-}
-
-export interface SchoolCalendarEntry {
-  _id?: string;
-  schoolId: string;
-  className?: string;
-  name: string;
-  startDate: string;
-  endDate: string;
-  type: 'HOLIDAY' | 'EXAM' | 'EVENT' | 'OFF';
-}
-
-export interface AchievementItem {
+export interface LuckyPrize {
   id: string;
   name: string;
-  icon: string;
-  points: number;
-  description?: string;
-  addedBy?: string;
-  addedByName?: string;
+  probability: number; // Treated as Weight
+  count: number; // Inventory
+  icon?: string;
 }
 
-export interface ExchangeRule {
-  id: string;
-  cost: number;
-  rewardType: 'DRAW_COUNT' | 'ITEM';
-  rewardName: string;
-  rewardValue: number;
+export interface LuckyDrawConfig {
+  _id?: string;
+  schoolId: string;
+  className?: string; 
+  ownerId?: string; // Isolated by teacher
+  prizes: LuckyPrize[]; 
+  dailyLimit: number;
+  cardCount?: number; 
+  defaultPrize: string; // "再接再厉"
+  consolationWeight?: number; // Weight for NOT winning a main prize
 }
 
-export interface AchievementConfig {
+export interface GameMonsterConfig {
   _id?: string;
   schoolId: string;
   className: string;
-  achievements: AchievementItem[];
-  exchangeRules: ExchangeRule[];
+  ownerId?: string; // Isolated by teacher
+  duration: number;
+  sensitivity: number;
+  difficulty: number;
+  useKeyboardMode: boolean;
+  rewardConfig: {
+      enabled: boolean;
+      type: 'DRAW_COUNT' | 'ITEM' | 'ACHIEVEMENT';
+      val: string;
+      count: number;
+  };
 }
 
-export interface TeacherExchangeConfig {
-  _id?: string;
-  teacherId: string;
-  teacherName?: string;
-  rules: ExchangeRule[];
-}
+// --- Achievement System Types ---
+// (Already defined above with new fields, kept here for structure context if needed)
 
 export interface StudentAchievement {
   _id?: string;
+  schoolId: string;
   studentId: string;
-  achievementId: string;
-  achievementName: string;
+  studentName: string;
+  achievementId: string; 
+  achievementName: string; 
   achievementIcon: string;
-  points: number;
   semester: string;
   createTime: string;
-  grantBy?: string;
 }
 
-export interface Wish {
+// --- Attendance Types ---
+export type AttendanceStatus = 'Present' | 'Absent' | 'Leave';
+
+export interface Attendance {
   _id?: string;
   schoolId: string;
   studentId: string;
   studentName: string;
   className: string;
-  teacherId: string;
-  teacherName: string;
-  content: string;
-  status: 'PENDING' | 'FULFILLED';
-  createTime: string;
-  fulfillTime?: string;
+  date: string; // YYYY-MM-DD
+  status: AttendanceStatus;
+  checkInTime?: string;
 }
 
-export interface Feedback {
+export interface LeaveRequest {
   _id?: string;
   schoolId: string;
-  senderId: string;
-  senderName: string;
-  senderRole: string;
-  targetId: string;
-  targetName: string;
-  content: string;
-  status: 'PENDING' | 'ACCEPTED' | 'PROCESSED' | 'IGNORED';
+  studentId: string;
+  studentName: string;
+  className: string;
+  reason: string;
+  startDate: string;
+  endDate: string;
+  status: 'Pending' | 'Approved' | 'Rejected';
   createTime: string;
 }
+
+export interface SchoolCalendarEntry {
+  _id?: string;
+  schoolId: string;
+  className?: string; // Optional, if set applies to specific class only
+  type: 'HOLIDAY' | 'BREAK' | 'OFF';
+  startDate: string; // YYYY-MM-DD
+  endDate: string; // YYYY-MM-DD
+  name: string;
+}