<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>管理员页面</title>
    <link href="./css/admin.css" rel="stylesheet" type="text/css">
</head>
<style>
    table {
        width: 100%;
        border-collapse: collapse;
    }

    th,
    td {
        border: 1px solid #ddd;
        padding: 8px;
    }

    th {
        background-color: #f2f2f2;
        text-align: left;
    }
</style>

<body>
    <div class="topbar">
        <div>管理员：张三</div>
        <button onclick="logout()">退出</button>
    </div>
    <div class="sidebar">
        <h1>管理员菜单</h1>
        <button onclick="showForm('add')">增加图书</button>
        <button onclick="showForm('delete')">删除图书</button>
        <button onclick="showForm('edit')">修改图书</button>
        <button onclick="showForm('search')">查询图书</button>
        <button onclick="showForm('userManagement')">用户管理</button>
        <button onclick="showForm('dataManagement')">图书管理</button>
        <button onclick="showForm('borrowRecords')">借阅记录</button>
    </div>
    <div class="main-content">
        <div class="form-container centered-content" id="formContainer" style="display:none;">
            <!-- 这里将根据需要动态显示表单 -->
        </div>
    </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 = `
                        <input type="text" placeholder="书名">
                        <input type="text" placeholder="作者">
                        <input type="number" placeholder="出版年份">
                        <button onclick="addBook()">添加</button>
                    `;
                    break;
                case 'delete':
                    formContainer.innerHTML = `
                        <input type="text" placeholder="图书ID">
                        <button onclick="deleteBook()">删除</button>
                    `;
                    break;
                case 'borrowRecords':
                    formContainer.innerHTML = `<h2>借阅记录</h2><div id="borrowRecordsList"></div>`;
                    loadBorrowRecords();
                    break;
                case 'edit':
                    formContainer.innerHTML = `
                        <input type="text" placeholder="图书ID">
                        <input type="text" placeholder="新书名">
                        <input type="text" placeholder="新作者">
                         <input type="number" placeholder="新出版年份">
                        <button onclick="editBook()">修改</button> <!-- 添加这一行 -->
                    `;
                    break;
                case 'search':
                    formContainer.innerHTML = `
                        <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.forEach(user => {
    formContainer.innerHTML += `
        <li style="margin: 10px 0;">
            ${user.username}
            <button onclick="editUserForm('${user.id}')">编辑</button>
            <button onclick="deleteUser('${user.id}')">删除</button>
        </li>
    `;
});
                        formContainer.innerHTML += `
                    </ul>
                </div>
            `;
                    });
                    break;
                case 'dataManagement':
                    formContainer.innerHTML = `
                        <h2>数据管理</h2>
                        <!-- 这里可以添加数据管理的相关表单或内容 -->
                    `;
                    loadBooks();  // 正确的位置
                    break;
                case 'borrowRecords':
                    formContainer.innerHTML = `
                        <h2>借阅记录</h2>
                        <!-- 这里可以添加借阅记录的相关表单或内容 -->
                    `;
                    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 = `
                <input type="hidden" value="${id}" name="id">
                <input type="text" placeholder="用户名" value="${user.username}" name="username">
                <input type="password" placeholder="密码" name="password">
                <select name="role">
                    <option value="user" ${user.role === 'user' ? 'selected' : ''}>用户</option>
                    <option value="admin" ${user.role === 'admin' ? 'selected' : ''}>管理员</option>
                </select>
                <button onclick="editUser(${id})">保存</button>
            `;
                        })
                        .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 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/add-book', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'user-type': 'admin' // 假设已经在某处设置了用户类型
                },
                body: JSON.stringify({ title, author, year_published }) // 使用正确的变量名
            })
                .then(response => {
                    if (!response.ok) {
                        throw new Error('Network response was not ok');
                    }
                    return response.text();
                })
                .then(data => {
                    console.log('Book added:', data);
                    alert('图书添加成功：' + data); // 显示成功消息
                    // 可选：清空表单
                    formContainer.innerHTML = '';
                    formContainer.style.display = 'none';
                    // 可选：更新图书列表（如果有的话）
                })
                .catch(error => {
                    console.error('Error adding book:', error);
                    alert('添加图书时出错：' + error.message);
                });
        }

        function deleteBook() {
            // 获取图书ID
            const formContainer = document.getElementById('formContainer');
            const bookId = formContainer.querySelector('input[placeholder="图书ID"]').value;

            // 发送删除图书的请求
            fetch('http://localhost:3000/admin/delete-book', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'user-type': 'admin'
                },
                body: JSON.stringify({ id: bookId })
            })
                .then(response => {
                    if (!response.ok) {
                        throw new Error('Network response was not ok');
                    }
                    return response.text();
                })
                .then(data => {
                    console.log('Book deleted:', data);
                    alert('图书删除成功');
                    formContainer.innerHTML = '';
                    formContainer.style.display = 'none';
                })
                .catch(error => {
                    console.error('Error deleting book:', error);
                    alert('删除图书时出错：' + error.message);
                });
        }


        function editBook() {
            const formContainer = document.getElementById('formContainer');
            const bookId = formContainer.querySelector('input[placeholder="图书ID"]').value;
            const newTitle = formContainer.querySelector('input[placeholder="新书名"]').value;
            const newAuthor = formContainer.querySelector('input[placeholder="新作者"]').value;
            const newYearPublished = formContainer.querySelector('input[placeholder="新出版年份"]').value;

            fetch('http://localhost:3000/admin/edit-book', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'user-type': 'admin'
                },
                body: JSON.stringify({ id: bookId, title: newTitle, author: newAuthor, year_published: newYearPublished })
            })
                .then(response => {
                    if (!response.ok) {
                        throw new Error('Network response was not ok');
                    }
                    return response.text();
                })
                .then(data => {
                    console.log('Book edited:', data);
                    alert('图书修改成功');
                    formContainer.innerHTML = '';
                    formContainer.style.display = 'none';
                })
                .catch(error => {
                    console.error('Error editing 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">
            <ul>
    `;
    books.forEach(book => {
        formContainer.innerHTML += `
            <li>
                ${book.title} by ${book.author} (${book.year_published})
                <button onclick="editBookForm(${book.id})">编辑</button>
                <button onclick="deleteBookConfirm(${book.id})">删除</button>
            </li>
        `;
    });
    formContainer.innerHTML += `
            </ul>
        </div>
    `;
    return Promise.resolve();  // 如果在这个函数内有异步操作需求，确保正确返回Promise
}

        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')
                .then(response => {
                    if (!response.ok) {
                        throw new Error('Network response was not ok');
                    }
                    return response.json();
                })
                .then(records => {
                    displayBorrowRecords(records);
                })
                .catch(error => {
                    console.error('Error loading borrow records:', error);
                    alert('加载借阅记录时出错：' + error.message);
                });
        }

        function displayBorrowRecords(records) {
    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 => {
            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="password">
                    <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>
                </form>
            `;
                })
                .catch(error => {
                    console.error('编辑用户信息获取出错：', error);
                    alert('获取用户信息失败，请稍后重试：' + error.message);
                });
        }

        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.password || !data.role) {
                alert('请填写所有必填字段');
                return;
            }

            fetch(`http://localhost:3000/admin/edit-user`, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(data)
            })
                .then(response => response.text())
                .then(data => {
                    alert(data);
                    loadUsers(); // 刷新用户列表
                })
                .catch(error => {
                    console.error('Error editing user:', error);
                    alert('编辑用户信息时出现错误，请稍后重试：' + error.message);
                });
        }

        function editBookForm(bookId) {
    if (!bookId) {
        alert('无效的图书ID');
        return;
    }
    // 先调用获取所有图书的后端路由
    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 => {
            // 在获取到的所有图书数据中查找对应id的图书
            const targetBook = allBooks.find(book => book.id === Number(bookId));
            if (!targetBook) {
                alert('未找到对应图书信息，请确认图书ID是否正确');
                return;
            }
            const formContainer = document.getElementById('formContainer');
            formContainer.innerHTML = `
                <input type="hidden" value="${bookId}" name="id">
                <input type="text" placeholder="书名" value="${targetBook.title}" name="title">
                <input type="text" placeholder="作者" value="${targetBook.author}" name="author">
                <input type="number" placeholder="出版年份" value="${targetBook.year_published}" name="year_published">
                <button onclick="editBook(${bookId})">保存</button>
            `;
        })
     .catch(error => {
            console.error('Error fetching book data:', error);
            alert('获取图书信息失败，请稍后重试：' + error.message);
        });
}

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 })
    })
      .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(bookId) {
    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;

    // 简单验证输入框是否为空
    if (!bookId ||!title ||!author ||!year_published) {
        alert('请填写完整图书编辑信息');
        return;
    }

    fetch('http://localhost:3000/admin/edit-book', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'user-type': 'admin'
        },
        body: JSON.stringify({ id: bookId, title, author, year_published })
    })
  .then(response => {
        console.log('Received response from edit-book:', response);
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        return response.text();
    })
  .then(data => {
        console.log('Book edited:', data);
        alert('图书修改成功');
        // 模拟点击图书管理按钮，重新加载图书列表显示
        showForm('dataManagement');
    })
  .catch(error => {
        console.error('Error editing book:', error);
        console.error('Error details:', error.message);
        alert('修改图书时出错：' + error.message);
    });
}
function deleteBorrowRecordConfirm(recordId) {
    if (!recordId) {
        alert('无效的借阅记录ID');
        return;
    }
    if (confirm(`确定要删除借阅记录ID为${recordId}的记录吗？此操作不可撤销！`)) {
        deleteBorrowRecord(recordId);
    }
}
function deleteBorrowRecord(recordId) {
    if (!recordId) {
        alert('请输入借阅记录ID');
        return;
    }
    fetch('http://localhost:3000/admin/delete-borrow-record', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({ id: recordId })
    })
   .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函数实现此功能）
        loadBorrowRecords();
    })        
   .catch(error => {
        console.error('Error deleting borrow record:', error);
        alert('删除借阅记录时出错：' + error.message);
    });
}
    </script>
</body>

</html>                    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.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 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);
            res.status(500).json({ error: 'Failed to add book' });
        } else {
            res.status(200).send('Book added successfully');
        }
    });
});
// 删除图书
app.post('/admin/delete-book', (req, res) => {
    const { id } = req.body;
    // 验证id是否为有效的数字且大于0（通常图书id为正整数）
    if (!Number.isInteger(Number(id)) || Number(id) <= 0) {
        res.status(400).json({ error: 'Invalid book ID format or value' });
        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 {
            res.send('Book deleted');
        }
    });
});

// 用户操作路由
// 搜索书籍
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 { id, title, author, year_published } = req.body;
    // 验证id是否为有效的数字且大于0
    if (!Number.isInteger(Number(id)) || Number(id) <= 0) {
        res.status(400).json({ error: 'Invalid book ID format or value' });
        return;
    }
    // 简单验证标题、作者等非空及长度（可根据实际需求完善）
    if (!title || title.length > 100) {
        res.status(400).json({ error: 'Invalid title format' });
        return;
    }
    if (!author || author.length > 100) {
        res.status(400).json({ error: 'Invalid author format' });
        return;
    }
    const query = 'UPDATE books SET title =?, author =?, year_published =? WHERE id =?';
    db.query(query, [title, author, year_published, id], (err, results) => {
        if (err) {
            console.error('Error editing book:', err);
            res.status(500).json({ error: 'Failed to edit book. Error details: ' + err.message });
        } else {
            res.status(200).send('Book edited successfully');
        } 
    });
});

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 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 {
            res.json(results);
        }
    });
});

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

// 删除用户
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;
    const query = 'DELETE FROM borrow_records WHERE id = ?';
    db.query(query, [id], (err, results) => {
        if (err) {
            res.status(500).send('Server error');
        } else {
            res.send('Borrow record deleted');
        }
    });
});
// 获取单个借阅记录详情的路由
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}`);
});                        修改代码，修改所有的id，查询当前最大的id，初始化为1（如果表为空），后续自增，再根据代码与前端进行修改，让他能够运行，分段输出