修改代码，左上角管理员的名字时应该时账号登录的用户名 const express = require('express');
const mysql = require('mysql');
const bodyParser = require('body-parser');
const cors = require('cors');

const app = express();
app.use(cors());
app.use(bodyParser.json());

// MySQL数据库连接配置
const db = mysql.createConnection({
host: 'localhost',
user: 'root',
password: '123456', // 替换为你的MySQL密码
database: 'librarysystem'
});

db.connect(err => {
if (err) {
throw err;
}
console.log('MySQL connected...');
});

// 登录路由
app.post('/login', (req, res) => {
const { username, password } = req.body;
const query = 'SELECT * FROM users WHERE username = ? AND password = ?';
db.query(query, [username, password], (err, results) => {
if (err) {
res.status(500).json({ error: 'Server error' });
} else if (results.length > 0) {
console.log("Login successful, sending response:", results[0]);
res.json(results[0]);
} else {
res.status(400).json({ error: 'Invalid login' });
}
});
});

// 获取当前管理员信息
app.get('/admin/current', (req, res) => {
// 假设管理员信息保存在 session 中
// 或者从数据库中查询并返回
const adminInfo = { username: '张三' }; // 这里可以找到适合获取当前管理员信息的方式
res.json(adminInfo);
});
// 注册路由
app.post('/register', (req, res) => {
const { username, password } = req.body;
// 检查用户名是否已存在
const checkUserQuery = 'SELECT * FROM users WHERE username = ?';
db.query(checkUserQuery, [username], (err, results) => {
if (err) {
res.status(500).json({ error: 'Server error' });
} else if (results.length > 0) {
// 用户名已存在
res.status(400).json({ error: 'Username already exists' });
} else {
// 用户名不存在，可以注册
const insertUserQuery = 'INSERT INTO users (username, password, role) VALUES (?, ?, ?)';
db.query(insertUserQuery, [username, password, 'user'], (err, results) => {
if (err) {
res.status(500).json({ error: 'Failed to register user' });
} else {
res.status(201).send('User registered successfully');
}
});
}
});
});
// 管理员操作路由
// 添加图书
app.post('/admin/add-book', (req, res) => {
const { title, author, year_published } = req.body;


// 在添加之前，先检查书名是否已存在
const checkBookQuery = 'SELECT * FROM books WHERE title = ?';
db.query(checkBookQuery, [title], (err, results) => {
    if (err) {
        console.error('Error checking existing book:', err);
        return res.status(500).json({ error: 'Failed to check existing book' });
    }

    if (results.length > 0) {
        return res.status(400).json({ error: 'Book title already exists' }); // 如果书名已存在，则返回错误
    }

    // 如果书名不存在，则继续插入新书
    const query = 'INSERT INTO books (title, author, year_published) VALUES (?, ?, ?)';
    db.query(query, [title, author, year_published], (err, results) => {
        if (err) {
            console.error('Error adding book:', err);
            return res.status(500).json({ error: 'Failed to add book' });
        }
        res.status(200).send('Book added successfully');
    });
});
});
// 删除图书按ID
app.post('/admin/delete-book', (req, res) => {
const { id } = req.body;


// 确保 ID 是有效的数字
if (!id || isNaN(id)) {
    res.status(400).json({ error: 'Invalid book ID format' });
    return;
}

const query = 'DELETE FROM books WHERE id = ?';
db.query(query, [id], (err, results) => {
    if (err) {
        console.error('Error deleting book:', err);
        res.status(500).json({ error: 'Failed to delete book. Error details: ' + err.message });
    } else {
        // 检查是否有行被删除
        if (results.affectedRows > 0) {
            res.send('Book deleted');
        } else {
            res.status(404).send('No book found with this ID');
        }
    }
});
});

// 用户操作路由
// 搜索书籍
app.post('/user/search-books', (req, res) => {
const { keyword } = req.body;
const query = SELECT * FROM books WHERE id = ? OR title LIKE ? OR author LIKE ? ;
db.query(query, [keyword, %${keyword}%, %${keyword}%], (err, results) => {
if (err) {
res.status(500).send('Server error');
} else {
res.json(results);
}
});
});
// 添加收藏
// 获取用户的收藏书籍
app.get('/user/favorites/:userId', (req, res) => {
const { userId } = req.params;
const query = SELECT b.id, b.title, b.author FROM favorites f JOIN books b ON f.book_id = b.id WHERE f.user_id = ? ;
db.query(query, [userId], (err, results) => {
if (err) {
res.status(500).send('Server error');
} else {
res.json(results);
}
});
});
// 编辑图书
app.post('/admin/edit-book', (req, res) => {
const { oldTitle, newTitle, newAuthor, newYearPublished } = req.body;


// 验证每个字段
if (!oldTitle || !newTitle || !newAuthor || !newYearPublished) {
    return res.status(400).json({ error: '所有字段都需要填写' });
}

const query = 'UPDATE books SET title=?, author=?, year_published=? WHERE title=?';
db.query(query, [newTitle, newAuthor, newYearPublished, oldTitle], (err, results) => {
    if (err) {
        console.error('Error editing book:', err);
        return res.status(500).json({ error: 'Failed to edit book. Error details: ' + err.message });
    }
    // 检查是否有行被更新
    if (results.affectedRows > 0) {
        res.status(200).send('Book edited successfully');
    } else {
        res.status(404).send('No book found with that title for editing');
    }
});
});
app.post('/admin/edit-book', (req, res) => {
const { oldTitle, newTitle, newAuthor, newYearPublished } = req.body;


// 验证每个字段
if (!oldTitle || !newTitle || !newAuthor || !newYearPublished) {
    return res.status(400).json({ error: '所有字段都需要填写' });
}

const query = 'UPDATE books SET title=?, author=?, year_published=? WHERE title=?';
db.query(query, [newTitle, newAuthor, newYearPublished, oldTitle], (err, results) => {
    if (err) {
        console.error('Error editing book:', err);
        return res.status(500).json({ error: 'Failed to edit book. Error details: ' + err.message });
    }
    // 检查是否有行被更新
    if (results.affectedRows > 0) {
        res.status(200).send('Book edited successfully');
    } else {
        res.status(404).send('No book found with that title for editing');
    }
});
});

app.get('/admin/get-books', (req, res) => {
const query = 'SELECT * FROM books';
db.query(query, (err, results) => {
if (err) {
console.error('Error getting books:', err);
res.status(500).json({ error: 'Failed to get books' });
} else {
res.json(results);
}
});
});

// 获取所有用户
app.get('/admin/get-users', (req, res) => {
const query = 'SELECT * FROM users';
db.query(query, (err, results) => {
if (err) {
console.error('Error getting users:', err);
res.status(500).json({ error: 'Failed to get users' });
} else {
res.json(results);
}
});
});
// 借阅书籍
app.post('/user/borrow-book', (req, res) => {
const { userId, bookId } = req.body;
const query = 'INSERT INTO borrow_records (user_id, book_id, borrow_date) VALUES (?, ?, NOW())';
db.query(query, [userId, bookId], (err, results) => {
if (err) {
console.error('Error borrowing book:', err);
res.status(500).json({ error: 'Failed to borrow book' });
} else {
res.status(200).send('Book borrowed successfully');
}
});
});

// 获取借阅历史
app.get('/user/borrow-history/:userId', (req, res) => {
const { userId } = req.params;
const query = SELECT b.title, b.author, br.borrow_date FROM borrow_records br JOIN books b ON br.book_id = b.id WHERE br.user_id = ? ORDER BY br.borrow_date DESC ;
db.query(query, [userId], (err, results) => {
if (err) {
res.status(500).send('Server error');
} else {
res.json(results);
}
});
});

// 获取所有借阅记录（管理员用）
// 获取所有借阅记录（管理员用）
app.get('/admin/borrow-records', (req, res) => {
const query = SELECT br.id, u.username, b.title, b.author, br.borrow_date FROM borrow_records br JOIN users u ON br.user_id = u.id JOIN books b ON br.book_id = b.id ORDER BY br.borrow_date DESC ;
db.query(query, (err, results) => {
if (err) {
res.status(500).send('Server error');
} else {
// Ensure that the ID is included in results
res.json(results);
}
});
});

// 编辑用户
app.post('/admin/edit-user', (req, res) => {
const { id, username, oldPassword, newPassword, role } = req.body;


// 验证旧密码
const query = 'SELECT * FROM users WHERE id = ?';
db.query(query, [id], (err, user) => {
    if (err) {
        console.error('Error fetching user data for password verification:', err);
        return res.status(500).json({ error: 'Failed to verify password' });
    }
    if (!user || user.length === 0 || user[0].password !== oldPassword) {
        // 旧密码不正确
        return res.status(400).json({ error: 'Invalid old password' });
    }

    // 更新用户信息
    const updateQuery = 'UPDATE users SET username = ?, password = ?, role = ? WHERE id = ?';
    db.query(updateQuery, [username, newPassword, role, id], (err, results) => {
        if (err) {
            console.error('编辑用户信息出错，编辑的用户ID：', id);
            console.error('错误信息：', err.message);
            console.error('错误堆栈：', err.stack);
            return res.status(500).json({ error: 'Failed to edit user' });
        }
        console.log('用户信息编辑成功，编辑的用户ID：', id);
        res.status(200).send('User edited successfully');
    });
});
});

// 删除图书
app.post('/admin/delete-book-by-title', (req, res) => {
const { title } = req.body; // 获取书名


// 确保书名是有效的字符串
if (!title || typeof title !== 'string') {
    return res.status(400).json({ error: 'Invalid book title format' });
}

// SQL 查询使用书名删除图书
const query = 'DELETE FROM books WHERE title = ?';
db.query(query, [title], (err, results) => {
    if (err) {
        console.error('Error deleting book:', err);
        return res.status(500).json({ error: 'Failed to delete book. Error details: ' + err.message });
    } else {
        if (results.affectedRows > 0) {
            res.send('Book deleted');
        } else {
            res.status(404).send('No book found with that title');
        }
    }
});
});
// 删除用户
app.post('/admin/delete-user', (req, res) => {
const { id } = req.body;
db.beginTransaction((err => {
if (err) {
console.error('Error starting transaction:', err);
res.status(500).send('Server error starting transaction');
return;
}
// 先删除 borrow_records 表中与该用户相关的记录
const deleteBorrowRecordsQuery = 'DELETE FROM borrow_records WHERE user_id =?';
db.query(deleteBorrowRecordsQuery, [id], (err => {
if (err) {
db.rollback(() => {
console.error('Error deleting related borrow records, rolling back transaction:', err);
res.status(500).send('Server error when deleting related borrow records, transaction rolled back');
});
return;
}
// 再删除 favorites 表中与该用户相关的记录
const deleteFavoritesQuery = 'DELETE FROM favorites WHERE user_id =?';
db.query(deleteFavoritesQuery, [id], (err => {
if (err) {
db.rollback(() => {
console.error('Error deleting related favorites, rolling back transaction:', err);
res.status(500).send('Server error when deleting related favorites, transaction rolled back');
});
return;
}
// 最后执行删除用户操作
const query = 'DELETE FROM users WHERE id =?';
db.query(query, [id], (err, results) => {
if (err) {
db.rollback(() => {
console.error('删除用户出错，要删除的用户ID：', id);
console.error('错误信息：', err.message);
console.error('错误堆栈：', err.stack);
res.status(500).send('Server error, transaction rolled back');
});
} else {
db.commit((err => {
if (err) {
console.error('Error committing transaction:', err);
res.status(500).send('Server error committing transaction');
return;
}
console.log('用户删除成功，删除的用户ID：', id);
res.send('User deleted');
}));
}
});
}));
}));
}));
});
//获取单个用户
app.get('/admin/get-user/:id', (req, res) => {
const { id } = req.params;
const query = 'SELECT * FROM users WHERE id = ?';
db.query(query, [id], (err, results) => {
if (err) {
console.error('Error getting user:', err);
res.status(500).json({ error: 'Failed to get user' });
} else if (results.length === 0) {
res.status(404).json({ error: 'User not found' });
} else {
res.json(results[0]);
}
});
});
// 编辑借阅记录（注意：通常借阅记录不需要编辑，但这里为了完整性提供示例）
app.post('/admin/edit-borrow-record', (req, res) => {
const { id, user_id, book_id, borrow_date } = req.body;
const query = 'UPDATE borrow_records SET user_id = ?, book_id = ?, borrow_date = ? WHERE id = ?';
db.query(query, [user_id, book_id, borrow_date, id], (err, results) => {
if (err) {
console.error('Error editing borrow record:', err);
res.status(500).json({ error: 'Failed to edit borrow record' });
} else {
res.status(200).send('Borrow record edited successfully');
}
});
});

// 删除借阅记录
app.post('/admin/delete-borrow-record', (req, res) => {
const { id } = req.body;


if (!id || isNaN(id)) {
    return res.status(400).send('无效的借阅记录ID格式');
}

const query = 'DELETE FROM borrow_records WHERE id = ?';
db.query(query, [id], (err, results) => {
    if (err) {
        console.error('Error deleting borrow record:', err);
        return res.status(500).send('服务器错误');
    }
    if (results.affectedRows > 0) {
        res.send('借阅记录删除成功');
    } else {
        res.status(404).send('没有找到该借阅记录');
    }
});
});
// 获取单个借阅记录详情的路由
app.get('/admin/get-borrow-record/:id', (req, res) => {
const { id } = req.params;
// 验证id是否为有效的数字且大于0
if (!Number.isInteger(Number(id)) || Number(id) <= 0) {
res.status(400).json({ error: 'Invalid borrow record ID format or value' });
return;
}
const query = SELECT * FROM borrow_records WHERE id =? ;
db.query(query, [id], (err, results) => {
if (err) {
console.error('Error getting borrow record:', err);
res.status(500).json({ error: 'Failed to get borrow record. Error details: ' + err.message });
} else if (results.length === 0) {
res.status(404).json({ error: 'Borrow record not found' });
} else {
res.json(results[0]);
}
});
});
// 添加收藏路由
app.post('/user/add-favorite', (req, res) => {
const { userId, bookId } = req.body;
// 先检查该用户是否已经收藏了这本书
const checkFavoriteQuery = 'SELECT * FROM favorites WHERE user_id =? AND book_id =?';
db.query(checkFavoriteQuery, [userId, bookId], (err, results) => {
if (err) {
res.status(500).json({ error: 'Server error' });
} else if (results.length > 0) {
// 已收藏，提示用户
res.status(400).json({ error: 'This book has already been added to favorites' });
} else {
// 可以添加收藏，插入记录到 favorites 表
const insertFavoriteQuery = 'INSERT INTO favorites (user_id, book_id) VALUES (?,?)';
db.query(insertFavoriteQuery, [userId, bookId], (err, results) => {
if (err) {
res.status(500).json({ error: 'Failed to add to favorites' });
} else {
// 返回成功的 JSON 响应
res.status(200).json({ message: 'Book added to favorites successfully' });
}
});
}
});
});

// 删除收藏书籍路由
app.post('/user/delete-favorite', (req, res) => {
const { userId, bookId } = req.body;
const deleteQuery = 'DELETE FROM favorites WHERE user_id =? AND book_id =?';
db.query(deleteQuery, [userId, bookId], (err, results) => {
if (err) {
res.status(500).json({ error: 'Server error when deleting favorite' });
} else if (results.affectedRows === 0) {
// 如果受影响的行数为0，表示没有找到对应的收藏记录，即可能已经不存在该收藏了
res.status(400).json({ error: 'This book is not in your favorites' });
} else {
res.status(200).json({ message: 'Book removed from favorites successfully' });
}
});
});

// 从收藏中借阅书籍
app.post('/user/borrow-from-favorite', (req, res) => {
const { userId, bookId } = req.body;
// 先从收藏中删除这本书
const deleteFavoriteQuery = 'DELETE FROM favorites WHERE user_id = ? AND book_id = ?';
db.query(deleteFavoriteQuery, [userId, bookId], (err, deleteResults) => {
if (err) {
console.error('Error deleting favorite before borrowing:', err);
res.status(500).json({ error: 'Failed to borrow book from favorites' });
return;
}
if (deleteResults.affectedRows === 0) {
res.status(400).json({ error: 'This book is not in your favorites' });
return;
}


    // 然后借阅这本书
    const borrowQuery = 'INSERT INTO borrow_records (user_id, book_id, borrow_date) VALUES (?, ?, NOW())';
    db.query(borrowQuery, [userId, bookId], (err, borrowResults) => {
        if (err) {
            console.error('Error borrowing book:', err);
            res.status(500).json({ error: 'Failed to borrow book' });
        } else {
            // 返回成功的 JSON 响应
            res.status(200).json({ message: 'Book borrowed from favorites successfully' });
        }
    });
});
});

// 监听端口
const PORT = 3000;
app.listen(PORT, () => {
console.log(Server running on port ${PORT});
});

管理员：
退出
管理员菜单
增加图书 删除图书 修改图书 查询图书 用户管理 图书管理 借阅记录

</div>
<script>
    function logout() {
        alert('已退出登录');
        window.location.href = 'login.html'; // 重定向到登录页面
    }
    function showForm(type, id = null) {
        const formContainer = document.getElementById('formContainer');
        formContainer.innerHTML = ''; // 清空之前的内容
        formContainer.style.display = 'block';

        // 根据type动态创建表单
        switch (type) {
            case 'add':
                formContainer.innerHTML = `
                        <h2 style="text-align: center";>增加图书</h2>
                    <input type="text" placeholder="书名">
                    <input type="text" placeholder="作者">
                    <input type="number" placeholder="出版年份">
                    <button onclick="addBook()">添加</button>
                `;
                break;
            case 'delete':
                formContainer.innerHTML = `
    <h2 style="text-align: center";>删除图书</h2>
    <input type="text" id="bookTitle" placeholder="输入书名" style="width: 200px;" />
    <button onclick="deleteBookByTitle()">删除</button>
`;
                break;
            case 'borrowRecords':
                formContainer.innerHTML = `
                <h2 style="text-align: center";>借阅记录</h2>
                <div id="borrowRecordsList"></div>`;
                loadBorrowRecords();
                break;
            case 'edit':
                formContainer.innerHTML = `
                <h2 style="text-align: center";>修改图书</h2>
    <input type="text" placeholder="旧书名" id="oldTitle">
    <input type="text" placeholder="新书名" id="newTitle">
    <input type="text" placeholder="新作者" id="newAuthor">
    <input type="number" placeholder="新出版年份" id="newYearPublished">
    <button onclick="editBook()">修改</button>
`;
                break;
            case 'search':
                formContainer.innerHTML = `
                <h2 style="text-align: center";>查询图书</h2>
                    <input type="text" placeholder="搜索关键词" id="searchKeyword">
                    <button onclick="searchBooks()">查询</button>
                `;
                break;
            case 'userManagement':
                loadUsers().then(users => {
                    const formContainer = document.getElementById('formContainer');
                    formContainer.innerHTML = `
            <h2 style="text-align: center;">用户管理</h2>
            <div class="user-list-container" style="display: flex; flex-direction: column; align-items: center;">
<ul style="list-style-type: none; padding: 0;">
    ${users.map(user => `
        <li style="display: flex; justify-content: space-between; align-items: center; width: 100%;">
            <span style="flex-grow: 1; margin-right: 10px;">${user.username}</span>
            <div class="book-actions">
                <button onclick="editUserForm('${user.id}')">编辑</button>
                <button onclick="deleteUser('${user.id}')">删除</button>
            </div>
        </li>`).join("")}
</ul>
`; }); break; case 'dataManagement': formContainer.innerHTML = `
数据管理
`; loadBooks(); // 正确的位置 break; case 'borrowRecords': formContainer.innerHTML = `
借阅记录
`; break; case 'editUser': fetch(`http://localhost:3000/admin/get-user/${id}`) .then(response => { if (!response.ok) { throw new Error('Failed to fetch user data'); } return response.json(); }) .then(user => { const formContainer = document.getElementById('formContainer'); formContainer.innerHTML = ` 
${user.username}
 
密码
 
用户
 保存 `; }) .catch(error => { console.error('Error fetching user data:', error); alert('Failed to fetch user data: ' + error.message); }); break; case 'deleteUser': if (confirm(`确定要删除用户ID为${id}的用户吗？此操作不可撤销！`)) { deleteUser(id); } break; default: formContainer.style.display = 'none'; } }

    function deleteBookByTitle() {
        const bookTitle = document.getElementById('bookTitle').value; // 获取书名

        if (!bookTitle) {
            alert('请输入书名以进行删除');
            return;
        }

        fetch('http://localhost:3000/admin/delete-book-by-title', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'user-type': 'admin'
            },
            body: JSON.stringify({ title: bookTitle }) // 传递书名
        })
            .then(response => {
                if (!response.ok) {
                    throw new Error('Network response was not ok');
                }
                return response.text();
            })
            .then(data => {
                console.log('Book deleted:', data);
                alert('图书删除成功');
                loadBooks();  // 重新加载图书列表
            })
            .catch(error => {
                console.error('Error deleting book:', error);
                alert('删除图书时出错：' + error.message);
            });
    }
    function addBook() {
        const formContainer = document.getElementById('formContainer');
        const title = formContainer.querySelector('input[placeholder="书名"]').value;
        const author = formContainer.querySelector('input[placeholder="作者"]').value;
        const year_published = formContainer.querySelector('input[placeholder="出版年份"]').value;

        // 先检查图书名是否已经存在
        fetch('http://localhost:3000/admin/get-books') // 获取所有书籍的数组
            .then(response => {
                if (!response.ok) {
                    throw new Error('无法加载书籍');
                }
                return response.json();
            })
            .then(books => {
                // 检查书名是否已存在
                const bookExists = books.some(book => book.title === title);
                if (bookExists) {
                    alert('书名已经存在，无法添加。');
                    return; // 结束添加逻辑
                }

                // 发送增加图书的请求
                return fetch('http://localhost:3000/admin/add-book', {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json',
                        'user-type': 'admin'
                    },
                    body: JSON.stringify({ title, author, year_published })
                });
            })
            .then(response => {
                // 前端处理整个响应
                if (!response.ok) {
                    return response.json().then(err => {
                        alert(err.error || '添加图书时出错'); // 不再抛出异常
                    });
                }

                return response.text();
            })
            .then(data => {
                alert('图书添加成功：' + data); // 显示成功消息
                formContainer.innerHTML = '';
                formContainer.style.display = 'none';
                showForm('dataManagement'); // 刷新图书列表
            })
            .catch(error => {
                console.error('Error adding book:', error);
                // 在这里可以选择不再显示错误，除非非常重要
                // alert('添加图书时出错：' + error.message); 
            });
    }

    function searchBooks() {
        const searchKeyword = document.getElementById('searchKeyword').value;

        fetch('http://localhost:3000/user/search-books', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({ keyword: searchKeyword })
        })
            .then(response => {
                if (!response.ok) {
                    throw new Error('Network response was not ok');
                }
                return response.json();
            })
            .then(data => {
                displaySearchResults(data);
            })
            .catch(error => {
                console.error('Error searching books:', error);
                alert('搜索图书时出错：' + error.message);
            });
    }

    function displaySearchResults(books) {
        const formContainer = document.getElementById('formContainer');
        formContainer.innerHTML = `
    <div>
        <button onclick="showForm('search')">返回继续搜索</button>
    </div>
    <h2>搜索结果</h2>
`;

        if (books.length === 0) {
            formContainer.innerHTML += '<p>未找到图书。</p>';
        } else {
            const resultsList = document.createElement('ul');
            books.forEach(book => {
                const listItem = document.createElement('li');
                listItem.textContent = `${book.title} by ${book.author} (${book.year_published})`;
                resultsList.appendChild(listItem);
            });
            formContainer.appendChild(resultsList);
        }
    }

    function loadBooks() {
        console.log('Starting to load books...');
        return fetch('http://localhost:3000/admin/get-books')
            .then(response => {
                console.log('Received response from get-books:', response);
                if (!response.ok) {
                    throw new Error('Network response was not ok');
                }
                return response.json();
            })
            .then(books => {
                console.log('Loaded books data:', books);
                displayBooks(books);
                return Promise.resolve();  // 显式返回一个已解决的Promise，确保外层能正确链式调用
            })
            .catch(error => {
                console.error('Error loading books:', error);
                alert('加载图书时出错：' + error.message);
                return Promise.reject(error);  // 出现错误时返回一个被拒绝的Promise，传播错误
            });
    }

    function displayBooks(books) {
        const formContainer = document.getElementById('formContainer');
        formContainer.innerHTML = `
    <h2 style="text-align: center;">图书管理</h2>
    <div class="book-list-container">
        <div class="book-list-header">
            <input type="checkbox" id="selectAllBooks"> 全选
            <button onclick="deleteSelectedBooks()">删除选中</button>
        </div>
        <ul id="bookList">
`;
        books.forEach(book => {
            formContainer.innerHTML += `
        <li style="display: flex; align-items: center;">
            <div class="book-item" style="flex-grow: 1; display: flex; align-items: center;">
                <input type="checkbox" class="bookCheckbox" value="${book.id}">
                <strong>书名:</strong> ${book.title} &nbsp;&nbsp;
                <strong>作者:</strong> ${book.author} &nbsp;&nbsp;
                <strong>出版年份:</strong> ${book.year_published}
            </div>
            <div class="book-actions">
                <button onclick="editBookForm('${book.id}')">编辑</button>
                <button onclick="deleteBookConfirm('${book.id}')">删除</button>
            </div>
        </li>
    `;
        });
        formContainer.innerHTML += `
        </ul>
    </div>
`;

        // 绑定全选事件
        const selectAllCheckbox = document.getElementById('selectAllBooks');
        selectAllCheckbox.addEventListener('change', function () {
            const checkboxes = document.querySelectorAll('.bookCheckbox');
            checkboxes.forEach(checkbox => {
                checkbox.checked = this.checked; // 设置每个复选框的选中状态
            });
        });

        // 绑定小复选框的change事件，以便跟踪选中状态
        const bookCheckboxes = document.querySelectorAll('.bookCheckbox');
        bookCheckboxes.forEach(checkbox => {
            checkbox.addEventListener('change', function () {
                // 检查所有小复选框是否都被选中
                const allChecked = Array.from(bookCheckboxes).every(cb => cb.checked);
                selectAllCheckbox.checked = allChecked; // 更新大全选框的状态
            });
        });
    }

    // 删除选中书籍的函数
    function deleteSelectedBooks() {
        const checkboxes = document.querySelectorAll('.bookCheckbox:checked');
        const bookIds = Array.from(checkboxes).map(checkbox => checkbox.value);

        if (bookIds.length === 0) {
            alert('没有选中任何书籍。');
            return;
        }

        if (confirm('确定要删除选中的书籍吗？此操作不可撤销！')) {
            bookIds.forEach(id => {
                deleteBook(id);
            });
        }
    }


    function loadUsers() {
        return fetch('http://localhost:3000/admin/get-users')
            .then(response => {
                if (!response.ok) {
                    throw new Error('Network response was not ok');
                }
                return response.json();
            })
            .then(users => {
                displayUsers(users);
                return users; // 将处理后的用户数据返回，使得外层能接收到这个 Promise 结果
            })
            .catch(error => {
                console.error('Error loading users:', error);
                alert('加载用户时出错：' + error.message);
                throw error; // 可以选择重新抛出错误，让调用处能进一步处理
            });
    }

    function displayUsers(users) {
        const formContainer = document.getElementById('formContainer');
        formContainer.innerHTML = `
    <h2 style="text-align: center;">用户管理</h2>
    <div class="user-list-container" style="display: flex; flex-direction: column; align-items: center;">
        <ul style="list-style-type: none; padding: 0;">
    `;
        users.forEach(user => {
            formContainer.innerHTML += `
        <li style="margin: 10px 0;">
            ${user.username}
            <button onclick="editUserForm('${user.id}')">编辑</button>
            <button onclick="deleteUserConfirm('${user.id}')">删除</button>
        </li>
    `;
        });
        formContainer.innerHTML += `
        </ul>
    </div>
`;
    }

    function loadBorrowRecords() {
        fetch('http://localhost:3000/admin/borrow-records') // 确保此 API 地址是正确的
            .then(response => {
                if (!response.ok) {
                    throw new Error('Network response was not ok');
                }
                return response.json();
            })
            .then(records => {
                console.log('Loaded borrow records:', records); // 检查返回的 records
                displayBorrowRecords(records);
            })
            .catch(error => {
                console.error('Error loading borrow records:', error);
                alert('加载借阅记录时出错：' + error.message);
            });
    }

    function displayBorrowRecords(records) {
        console.log('Borrow records:', records); // Debug log - 确保调用时返回记录的结构

        const borrowRecordsList = document.getElementById('borrowRecordsList');
        borrowRecordsList.innerHTML = ''; // 清空之前的内容

        if (records.length === 0) {
            borrowRecordsList.innerHTML = '<p>无借阅记录。</p>';
        } else {
            const table = document.createElement('table');
            table.innerHTML = `
        <tr>
            <th>用户名</th>
            <th>书名</th>
            <th>作者</th>
            <th>借阅日期</th>
            <th>操作</th>
        </tr>
    `;
            records.forEach(record => {
                console.log('Record:', record); // 输出每一条记录
                const row = document.createElement('tr');
                row.innerHTML = `
            <td>${record.username}</td>
            <td>${record.title}</td>
            <td>${record.author}</td>
            <td>${record.borrow_date}</td>
            <td>
                <button onclick="deleteBorrowRecordConfirm(${record.id})">删除</button>
            </td>
        `;
                table.appendChild(row);
            });
            borrowRecordsList.appendChild(table);
        }
    }


    function deleteUser(id) {
        fetch(`http://localhost:3000/admin/delete-user`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ id })
        })
            .then(response => {
                if (!response.ok) {
                    throw new Error('Network response was not ok: ' + response.statusText);
                }
                return response.text();
            })
            .then(data => {
                alert(data);
                loadUsers(); // 刷新用户列表
            })
            .catch(error => {
                console.error('Error deleting user:', error);
                alert('删除用户时出现错误：' + error.message);
            });
    }
    function editUserForm(id) {
        fetch(`http://localhost:3000/admin/get-user/${id}`)
            .then(response => {
                if (!response.ok) {
                    throw new Error('获取用户信息失败，状态码：' + response.status);
                }
                return response.json();
            })
            .then(user => {
                const formContainer = document.getElementById('formContainer');
                formContainer.innerHTML = `
            <form id="editUserForm">
                <input type="hidden" value="${id}" name="id">
                <input type="text" placeholder="用户名" value="${user.username}" name="username">
                <input type="password" placeholder="旧密码" name="oldPassword" required>
                <input type="password" placeholder="新密码" name="newPassword">
                <select name="role">
                    <option value="user" ${user.role === 'user' ? 'selected' : ''}>用户</option>
                    <option value="admin" ${user.role === 'admin' ? 'selected' : ''}>管理员</option>
                </select>
                <button type="button" onclick="editUser(${id})">保存</button>
                <button type="button" onclick="cancelEditUser()">取消</button>
            </form>
        `;
            })
            .catch(error => {
                console.error('编辑用户信息获取出错：', error);
                alert('获取用户信息失败，请稍后重试：' + error.message);
            });
    }

    function cancelEditUser() {
        showForm('userManagement'); // 返回用户管理列表
    }

    function editUser(id) {
        const form = document.querySelector(`#editUserForm`);
        if (!form || !(form instanceof HTMLFormElement)) {
            console.error('Invalid form element');
            return;
        }
        const formData = new FormData(form);
        const data = Object.fromEntries(formData.entries());

        // Simple validation for required fields
        if (!data.username || !data.oldPassword || !data.newPassword || !data.role) {
            alert('请填写所有必填字段');
            return;
        }

        fetch(`http://localhost:3000/admin/edit-user`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(data)
        })
            .then(response => {
                if (!response.ok) {
                    throw new Error('Failed to edit user');
                }
                return response.text();
            })
            .then(data => {
                alert(data); // 显示成功消息
                loadUsers(); // 刷新用户列表
            })
            .catch(error => {
                console.error('Error editing user:', error);
                if (error.response && error.response.status === 400) {
                    error.response.json().then(data => {
                        alert('编辑用户信息时出错：' + data.error);
                    });
                } else {
                    alert('编辑用户信息时出错，请稍后重试：' + error.message);
                }
                // 保持表单内容不变，以便用户可以继续编辑
            });
    }

    function editBookForm(bookId) {
        fetch(`http://localhost:3000/admin/get-books`)
            .then(response => {
                if (!response.ok) {
                    throw new Error('Failed to fetch all books data');
                }
                return response.json();
            })
            .then(allBooks => {
                const targetBook = allBooks.find(book => book.id === Number(bookId));
                if (!targetBook) {
                    alert('未找到对应图书信息，请确认图书ID是否正确');
                    return;
                }

                const formContainer = document.getElementById('formContainer');
                formContainer.innerHTML = `
                    <h2>修改图书</h2>
                    <input type="hidden" value="${bookId}" id="bookId">
                    <input type="text" placeholder="旧书名" id="oldTitle" value="${targetBook.title}" disabled>
                    <input type="text" placeholder="新书名" id="newTitle" value="${targetBook.title}">
                    <input type="text" placeholder="新作者" id="newAuthor" value="${targetBook.author}">
                    <input type="number" placeholder="新出版年份" id="newYearPublished" value="${targetBook.year_published}">
                    <button onclick="editBook()">保存</button>
                    <button onclick="cancelEditBook()">取消</button>
                `;
            })
            .catch(error => {
                console.error('Error fetching book data:', error);
                alert('获取图书信息失败，请稍后重试：' + error.message);
            });
    }

    function cancelEditBook() {
        const bookId = document.getElementById('bookId').value;
        if (bookId) {
            showForm('dataManagement'); // 返回图书管理列表
        }
    }

    function deleteBookConfirm(bookId) {
        if (!bookId) {
            alert('无效的图书ID');
            return;
        }
        if (confirm(`确定要删除图书ID为${bookId}的图书吗？此操作不可撤销！`)) {
            deleteBook(bookId);
        }
    }

    function deleteBook(bookId) {
        if (!bookId) {
            alert('无效的图书ID');
            return;
        }

        fetch('http://localhost:3000/admin/delete-book', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'user-type': 'admin'
            },
            body: JSON.stringify({ id: bookId })  // 使用书籍 ID
        })
            .then(response => {
                if (!response.ok) {
                    throw new Error('Network response was not ok');
                }
                return response.text();
            })
            .then(data => {
                console.log('Book deleted:', data);
                alert('图书删除成功');
                loadBooks();  // 重新加载图书列表
            })
            .catch(error => {
                console.error('Error deleting book:', error);
                alert('删除图书时出错：' + error.message);
            });
    }

    function editBook() {
        const newTitle = document.getElementById('newTitle').value.trim();
        const newAuthor = document.getElementById('newAuthor').value.trim();
        const newYearPublished = document.getElementById('newYearPublished').value.trim();

        // 简单验证输入框是否为空
        if (!newTitle || !newAuthor || !newYearPublished) {
            alert('请填写所有修改信息');
            return;
        }

        const oldTitle = document.getElementById('oldTitle').value; // 注意，没有trim()，因为oldTitle是禁用输入，不应更改

        fetch('http://localhost:3000/admin/edit-book', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'user-type': 'admin'
            },
            body: JSON.stringify({ oldTitle, newTitle, newAuthor, newYearPublished })
        })
            .then(response => {
                if (!response.ok) {
                    throw new Error('Network response was not ok: ' + response.statusText);
                }
                return response.text();
            })
            .then(data => {
                console.log('Book edited:', data);
                alert('图书修改成功');
                showForm('dataManagement'); // 返回数据管理界面
            })
            .catch(error => {
                console.error('Error editing book:', error);
                alert('修改图书时出错：' + error.message);
            });
    }
    function deleteBorrowRecordConfirm(recordId) {
        console.log('Attempting to delete record with ID:', recordId);
        if (!recordId) {
            alert('无效的借阅记录ID');
            return;
        }
        if (confirm(`确定要删除借阅记录ID为${recordId}的记录吗？此操作不可撤销！`)) {
            deleteBorrowRecord(recordId);
        }
    }
    function deleteBorrowRecord(recordId) {
        fetch('http://localhost:3000/admin/delete-borrow-record', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({ id: recordId }) // 发送要删除记录的 ID
        })
            .then(response => {
                if (!response.ok) {
                    throw new Error('Network response was not ok');
                }
                return response.text();
            })
            .then(data => {
                console.log('Borrow record deleted:', data);
                alert('借阅记录删除成功');
                loadBorrowRecords(); // 重新加载借阅记录列表
            })
            .catch(error => {
                console.error('Error deleting borrow record:', error);
                alert('删除借阅记录时出错：' + error.message);
            });
    }
document.addEventListener('DOMContentLoaded', () => {
fetchCurrentAdmin();
});

// 获取当前管理员信息
function fetchCurrentAdmin() {
fetch('http://localhost:3000/admin/current')
.then(response => {
if (!response.ok) {
throw new Error('Network response was not ok');
}
return response.json();
})
.then(data => {
console.log(data);


        document.getElementById('adminName').textContent = `管理员：${data.username}`;
    })
    .catch(error => {
        console.error('Error fetching admin name:', error);
        document.getElementById('adminName').textContent = '管理员：未知'; // 出错时处理
    });
}

尽量不要下载npm包