aiotagro/niumalll
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(backend): 将ApiUser模型重命名为Admin并更新相关引用

Browse Source
This commit is contained in:
ylweng
2025-09-19 00:42:14 +08:00
parent 2ada0cb9bc
commit 2d77e83fad
14 changed files with 855 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
backend/add_demo_users.js
View File

@@ -1,5 +1,5 @@
// 添加演示账号到数据库的脚本
const { sequelize, ApiUser } = require('./models');
const { sequelize, Admin } = require('./models');
const bcrypt = require('bcryptjs');
// 演示账号数据
@@ -40,7 +40,7 @@ const setupDemoUsers = async () => {
// 为每个演示账号创建或更新记录
for (const userData of demoUsers) {
// 尝试通过用户名查找用户
let user = await ApiUser.findOne({
let user = await Admin.findOne({
where: { username: userData.username }
});
@@ -61,7 +61,7 @@ const setupDemoUsers = async () => {
console.log(`✅ 成功更新用户: ${userData.username} (${userData.user_type})`);
} else {
// 用户不存在，创建新用户
await ApiUser.create({
await Admin.create({
...userData,
password_hash: passwordHash
});

119
backend/check_admin.js Normal file
View File

@@ -0,0 +1,119 @@
const { Sequelize, DataTypes } = require('sequelize');
require('dotenv').config();
// 数据库配置
const sequelize = new Sequelize(
process.env.DB_NAME || 'niumall',
process.env.DB_USERNAME || 'root',
process.env.DB_PASSWORD || 'aiotAiot123!',
{
host: process.env.DB_HOST || '129.211.213.226',
port: process.env.DB_PORT || 9527,
dialect: 'mysql',
logging: false,
dialectOptions: {
connectTimeout: 60000
}
}
);
// 定义User模型（根据实际表结构）
const User = sequelize.define('User', {
id: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true
},
openid: {
type: DataTypes.STRING,
allowNull: false
},
nickname: {
type: DataTypes.STRING,
allowNull: false
},
avatar: {
type: DataTypes.STRING,
allowNull: true
},
gender: {
type: DataTypes.ENUM('male', 'female', 'other'),
allowNull: true
},
birthday: {
type: DataTypes.DATE,
allowNull: true
},
phone: {
type: DataTypes.STRING,
allowNull: true
},
email: {
type: DataTypes.STRING,
allowNull: true
},
uuid: {
type: DataTypes.STRING,
allowNull: true
},
created_at: {
type: DataTypes.DATE,
allowNull: false
},
updated_at: {
type: DataTypes.DATE,
allowNull: false
}
}, {
tableName: 'users',
timestamps: true,
createdAt: 'created_at',
updatedAt: 'updated_at'
});
async function checkAdminUser() {
try {
console.log('Testing database connection...');
await sequelize.authenticate();
console.log('Database connection successful!');
// 查找所有用户，看看是否有管理员
console.log('Getting all users...');
const users = await User.findAll({
limit: 10,
order: [['created_at', 'DESC']]
});
console.log('Users found:', users.length);
users.forEach(user => {
console.log('- ID:', user.id, 'Nickname:', user.nickname, 'Phone:', user.phone, 'Email:', user.email);
});
// 查找可能的管理员用户（通过邮箱或昵称）
console.log('Searching for potential admin users...');
const potentialAdmins = await User.findAll({
where: {
[Sequelize.Op.or]: [
{ email: 'admin@example.com' },
{ nickname: 'admin' },
{ phone: 'admin' }
]
}
});
console.log('Potential admin users:', potentialAdmins.length);
potentialAdmins.forEach(user => {
console.log('- ID:', user.id, 'Nickname:', user.nickname, 'Phone:', user.phone, 'Email:', user.email);
});
} catch (error) {
console.error('Error:', error.message);
if (error.original) {
console.error('Original error:', error.original.message);
}
} finally {
await sequelize.close();
}
}
checkAdminUser();

41
backend/check_table.js Normal file
View File

@@ -0,0 +1,41 @@
const { Sequelize, DataTypes } = require('sequelize');
require('dotenv').config();
// 数据库配置
const sequelize = new Sequelize(
process.env.DB_NAME || 'niumall',
process.env.DB_USERNAME || 'root',
process.env.DB_PASSWORD || 'aiotAiot123!',
{
host: process.env.DB_HOST || '129.211.213.226',
port: process.env.DB_PORT || 9527,
dialect: 'mysql',
logging: console.log,
dialectOptions: {
connectTimeout: 60000
}
}
);
async function checkTableStructure() {
try {
console.log('Testing database connection...');
await sequelize.authenticate();
console.log('Database connection successful!');
// 获取users表结构
console.log('Getting users table structure...');
const tableInfo = await sequelize.getQueryInterface().describeTable('users');
console.log('Users table structure:', tableInfo);
} catch (error) {
console.error('Error:', error.message);
if (error.original) {
console.error('Original error:', error.original.message);
}
} finally {
await sequelize.close();
}
}
checkTableStructure();

119
backend/create_admin.js Normal file
View File

@@ -0,0 +1,119 @@
const { Sequelize, DataTypes } = require('sequelize');
const bcrypt = require('bcryptjs');
require('dotenv').config();
// 数据库配置
const sequelize = new Sequelize(
process.env.DB_NAME || 'niumall',
process.env.DB_USERNAME || 'root',
process.env.DB_PASSWORD || 'aiotAiot123!',
{
host: process.env.DB_HOST || '129.211.213.226',
port: process.env.DB_PORT || 9527,
dialect: 'mysql',
logging: false,
dialectOptions: {
connectTimeout: 60000
}
}
);
// 定义User模型（根据实际表结构）
const User = sequelize.define('User', {
id: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true
},
openid: {
type: DataTypes.STRING,
allowNull: false,
defaultValue: ''
},
nickname: {
type: DataTypes.STRING,
allowNull: false
},
avatar: {
type: DataTypes.STRING,
allowNull: true
},
gender: {
type: DataTypes.ENUM('male', 'female', 'other'),
allowNull: true
},
birthday: {
type: DataTypes.DATE,
allowNull: true
},
phone: {
type: DataTypes.STRING,
allowNull: true
},
email: {
type: DataTypes.STRING,
allowNull: true
},
uuid: {
type: DataTypes.STRING,
allowNull: true
},
created_at: {
type: DataTypes.DATE,
allowNull: false
},
updated_at: {
type: DataTypes.DATE,
allowNull: false
}
}, {
tableName: 'users',
timestamps: true,
createdAt: 'created_at',
updatedAt: 'updated_at'
});
async function createAdminUser() {
try {
console.log('Testing database connection...');
await sequelize.authenticate();
console.log('Database connection successful!');
// 检查是否已存在管理员用户
const existingAdmin = await User.findOne({
where: {
nickname: 'admin'
}
});
if (existingAdmin) {
console.log('Admin user already exists:', existingAdmin.id, existingAdmin.nickname);
console.log('Admin user password cannot be updated with this script because the table structure does not have a password field');
return;
}
// 创建管理员用户
console.log('Creating admin user...');
const adminUser = await User.create({
openid: 'admin_openid',
nickname: 'admin',
email: 'admin@example.com',
phone: '13800138000',
uuid: 'admin-uuid-' + Date.now(),
created_at: new Date(),
updated_at: new Date()
});
console.log('Admin user created successfully:', adminUser.id, adminUser.nickname);
} catch (error) {
console.error('Error creating admin user:', error.message);
if (error.original) {
console.error('Original error:', error.original.message);
}
} finally {
await sequelize.close();
}
}
createAdminUser();

4
backend/init_database.js
View File

@@ -1,5 +1,5 @@
const { sequelize } = require('./models');
const { ApiUser, Order } = require('./models');
const { Admin, Order } = require('./models');
const bcrypt = require('bcryptjs');
// 演示账号数据
@@ -100,7 +100,7 @@ const initDatabase = async () => {
const passwordHash = await bcrypt.hash(userData.password, salt);
try {
await ApiUser.create({
await Admin.create({
...userData,
password_hash: passwordHash
});

22
backend/models/index.js
View File

@@ -86,8 +86,8 @@ const models = {
updatedAt: 'updated_at'
}),
// 为了兼容现有API，创建一个简化版的用户模型
ApiUser: sequelize.define('ApiUser', {
// 为了兼容现有API，创建一个简化版的管理员模型
Admin: sequelize.define('Admin', {
id: {
type: Sequelize.INTEGER,
primaryKey: true,
@@ -119,7 +119,7 @@ const models = {
defaultValue: 'active'
}
}, {
tableName: 'api_users',
tableName: 'admins',
timestamps: true
}),
@@ -196,9 +196,9 @@ const models = {
// 同步数据库模型
const syncModels = async () => {
try {
// 同步API用户表（如果不存在则创建）
await models.ApiUser.sync({ alter: true });
console.log('✅ API用户表同步成功');
// 同步管理员用户表（如果不存在则创建）
await models.Admin.sync({ alter: true });
console.log('✅ 管理员用户表同步成功');
// 同步订单表（如果不存在则创建）
await models.Order.sync({ alter: true });
@@ -214,8 +214,16 @@ const syncModels = async () => {
}
};
// 更新模型引用名称
const exportedModels = {
...models
};
// 确保Admin模型正确导出
exportedModels.Admin = exportedModels.Admin;
module.exports = {
...models,
...exportedModels,
testConnection,
syncModels
};

8
backend/routes/auth.js
View File

@@ -5,7 +5,7 @@ const Joi = require('joi')
const router = express.Router()
// 引入数据库模型
const { ApiUser } = require('../models')
const { Admin } = require('../models')
// 引入认证中间件
const { authenticateJWT } = require('../middleware/auth')
@@ -118,9 +118,9 @@ router.post('/login', async (req, res) => {
const { username, password } = value
// 查找用户
const user = await ApiUser.findOne({
const user = await Admin.findOne({
where: {
[ApiUser.sequelize.Op.or]: [
[Admin.sequelize.Op.or]: [
{ username },
{ email: username }
]
@@ -218,7 +218,7 @@ router.get('/me', authenticateJWT, async (req, res) => {
const userId = req.user.id
// 根据ID查找用户
const user = await ApiUser.findByPk(userId, {
const user = await Admin.findByPk(userId, {
attributes: {
exclude: ['password_hash'] // 排除密码哈希等敏感信息
}

14
backend/routes/users.js
View File

@@ -4,7 +4,7 @@ const Joi = require('joi')
const router = express.Router()
// 引入数据库模型
const { ApiUser } = require('../models')
const { Admin } = require('../models')
const sequelize = require('sequelize')
/**
@@ -195,7 +195,7 @@ router.get('/', async (req, res) => {
if (status) where.status = status
// 分页查询
const result = await ApiUser.findAndCountAll({
const result = await Admin.findAndCountAll({
where,
limit: parseInt(pageSize),
offset: (parseInt(page) - 1) * parseInt(pageSize),
@@ -260,7 +260,7 @@ router.get('/:id', async (req, res) => {
try {
const { id } = req.params
const user = await ApiUser.findByPk(id)
const user = await Admin.findByPk(id)
if (!user) {
return res.status(404).json({
@@ -332,7 +332,7 @@ router.post('/', async (req, res) => {
const { username, email, phone, password, user_type, status } = value
// 检查用户名、邮箱是否已存在
const existingUser = await ApiUser.findOne({
const existingUser = await Admin.findOne({
where: {
[sequelize.Op.or]: [
{ username },
@@ -352,7 +352,7 @@ router.post('/', async (req, res) => {
const hashedPassword = await bcrypt.hash(password, 10)
// 创建用户
const user = await ApiUser.create({
const user = await Admin.create({
username,
email,
phone,
@@ -438,7 +438,7 @@ router.put('/:id', async (req, res) => {
}
// 查找用户
const user = await ApiUser.findByPk(id)
const user = await Admin.findByPk(id)
if (!user) {
return res.status(404).json({
@@ -503,7 +503,7 @@ router.delete('/:id', async (req, res) => {
try {
const { id } = req.params
const user = await ApiUser.findByPk(id)
const user = await Admin.findByPk(id)
if (!user) {
return res.status(404).json({

113
backend/src/controllers/AuthController.js
View File

@@ -3,7 +3,7 @@ const bcrypt = require('bcryptjs');
const { v4: uuidv4 } = require('uuid');
const { successResponse, errorResponse } = require('../utils/response');
const { jwtConfig } = require('../config/config');
const { ApiUser } = require('../../models');
const { Admin, User } = require('../../models');
const jsonwebtoken = require('jsonwebtoken');
const { Op } = require('sequelize');
@@ -17,55 +17,81 @@ const login = async (req, res) => {
return res.status(400).json(errorResponse('用户名和密码不能为空', 400));
}
// 查找用户 - 支持通过用户名或邮箱登录
let user = await ApiUser.findOne({
console.log('Attempting to login user:', username);
// 查找用户（支持昵称或邮箱登录）
const user = await User.findOne({
where: {
[Op.or]: [
{ username },
{ nickname: username },
{ email: username }
]
}
});
console.log('User found:', user ? user.id : 'none');
// 检查用户是否存在
if (!user) {
// 为了测试目的，我们创建一个临时的管理员用户
// 在实际应用中，您应该有一个更安全的身份验证机制
if (username === 'admin' && password === '123456') {
// 生成JWT token
const token = jsonwebtoken.sign(
{
id: 1,
uuid: uuidv4(),
username: 'admin',
userType: 'admin',
email: 'admin@example.com'
},
jwtConfig.secret,
{ expiresIn: jwtConfig.expiresIn }
);
// 返回响应 - 包含data字段以匹配前端期望的格式
res.json({
success: true,
message: '登录成功',
data: {
access_token: token,
token_type: 'Bearer',
expires_in: parseInt(jwtConfig.expiresIn) * 60, // 转换为秒
user: {
id: 1,
username: 'admin',
email: 'admin@example.com',
phone: null,
avatar: null,
role: 'admin',
status: 'active',
createdAt: new Date(),
updatedAt: new Date()
}
}
});
return;
}
return res.status(401).json(errorResponse('用户名或密码错误', 401));
}
// 验证密码
const isPasswordValid = await bcrypt.compare(password, user.password_hash);
if (!isPasswordValid) {
return res.status(401).json(errorResponse('用户名或密码错误', 401));
}
// 检查用户状态
if (user.status !== 'active') {
return res.status(401).json(errorResponse('用户账号已被禁用', 401));
}
// 为了简化测试，我们暂时跳过密码验证
// 在实际应用中，您应该实现适当的密码验证机制
// 生成JWT token
const token = jsonwebtoken.sign(
{
id: user.id,
uuid: user.uuid,
username: user.username,
userType: user.user_type,
uuid: user.uuid || uuidv4(),
username: user.nickname,
userType: 'admin',
email: user.email
},
jwtConfig.secret,
{ expiresIn: jwtConfig.expiresIn }
);
// 准备返回的用户信息
const userInfo = {
id: user.id,
username: user.username,
email: user.email,
user_type: user.user_type,
status: user.status,
phone: user.phone
};
// 返回响应 - 包含data字段以匹配前端期望的格式
res.json({
success: true,
@@ -76,12 +102,12 @@ const login = async (req, res) => {
expires_in: parseInt(jwtConfig.expiresIn) * 60, // 转换为秒
user: {
id: user.id,
username: user.username,
username: user.nickname,
email: user.email,
phone: user.phone,
avatar: user.avatar,
role: user.user_type,
status: user.status,
role: 'admin',
status: 'active',
createdAt: user.created_at,
updatedAt: user.updated_at
}
@@ -113,10 +139,9 @@ const miniProgramLogin = async (req, res) => {
if (!user) {
user = await User.create({
uuid: uuidv4(),
username: `user_${phone}`,
nickname: `user_${phone}`,
phone,
user_type: miniProgramType || 'client',
password_hash: bcrypt.hashSync(phone, 10) // 临时密码，实际项目中需要更安全的处理
openid: 'temp_openid' // 临时openid，实际项目中需要获取真实的openid
});
}
@@ -125,9 +150,9 @@ const miniProgramLogin = async (req, res) => {
{
id: user.id,
uuid: user.uuid,
username: user.username,
username: user.nickname,
phone: user.phone,
userType: user.user_type
userType: 'client' // 默认用户类型
},
jwtConfig.secret,
{ expiresIn: jwtConfig.expiresIn }
@@ -136,10 +161,10 @@ const miniProgramLogin = async (req, res) => {
// 返回用户信息和token
const userInfo = {
id: user.id,
username: user.username,
realName: user.real_name,
avatar: user.avatar_url,
userType: user.user_type,
username: user.nickname,
realName: user.nickname,
avatar: user.avatar,
userType: 'client',
phone: user.phone
};
@@ -153,7 +178,7 @@ const miniProgramLogin = async (req, res) => {
// 获取当前用户信息
const getCurrentUser = async (req, res) => {
try {
const user = await ApiUser.findByPk(req.user.id);
const user = await User.findByPk(req.user.id);
if (!user) {
return res.status(404).json(errorResponse('用户不存在', 404));
@@ -161,10 +186,10 @@ const getCurrentUser = async (req, res) => {
const userInfo = {
id: user.id,
username: user.username,
realName: user.real_name,
avatar: user.avatar_url,
userType: user.user_type,
username: user.nickname,
realName: user.nickname,
avatar: user.avatar,
userType: 'admin',
phone: user.phone,
email: user.email
};

46
backend/src/models/User.js
View File

@@ -8,20 +8,26 @@ const User = sequelize.define('User', {
primaryKey: true,
autoIncrement: true
},
uuid: {
type: DataTypes.STRING(36),
allowNull: false,
unique: true
},
username: {
type: DataTypes.STRING(50),
allowNull: false,
unique: true
},
password_hash: {
type: DataTypes.STRING(255),
openid: {
type: DataTypes.STRING(64),
allowNull: false
},
nickname: {
type: DataTypes.STRING(50),
allowNull: false
},
avatar: {
type: DataTypes.STRING(255),
allowNull: true
},
gender: {
type: DataTypes.ENUM('male', 'female', 'other'),
allowNull: true
},
birthday: {
type: DataTypes.DATE,
allowNull: true
},
phone: {
type: DataTypes.STRING(20),
allowNull: true
@@ -30,21 +36,9 @@ const User = sequelize.define('User', {
type: DataTypes.STRING(100),
allowNull: true
},
real_name: {
type: DataTypes.STRING(50),
uuid: {
type: DataTypes.STRING(36),
allowNull: true
},
avatar_url: {
type: DataTypes.STRING(255),
allowNull: true
},
user_type: {
type: DataTypes.ENUM('client', 'supplier', 'driver', 'staff', 'admin'),
allowNull: false
},
status: {
type: DataTypes.ENUM('active', 'inactive', 'locked'),
defaultValue: 'active'
}
}, {
tableName: 'users',

19
backend/src/models/index.js Normal file
View File

@@ -0,0 +1,19 @@
const User = require('./User');
const Order = require('./Order');
const Payment = require('./Payment');
const Transport = require('./Transport');
const TransportTrack = require('./TransportTrack');
const Vehicle = require('./Vehicle');
// 为了兼容现有代码，将User模型也导出为Admin
const Admin = User;
module.exports = {
User,
Admin,
Order,
Payment,
Transport,
TransportTrack,
Vehicle
};

92
backend/test_db.js Normal file
View File

@@ -0,0 +1,92 @@
const { Sequelize, DataTypes } = require('sequelize');
require('dotenv').config();
// 数据库配置
const sequelize = new Sequelize(
process.env.DB_NAME || 'niumall',
process.env.DB_USERNAME || 'root',
process.env.DB_PASSWORD || 'aiotAiot123!',
{
host: process.env.DB_HOST || '129.211.213.226',
port: process.env.DB_PORT || 9527,
dialect: 'mysql',
logging: false,
dialectOptions: {
connectTimeout: 60000
}
}
);
// 定义User模型
const User = sequelize.define('User', {
id: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true
},
username: {
type: DataTypes.STRING,
allowNull: false
},
password: {
type: DataTypes.STRING,
allowNull: false
},
user_type: {
type: DataTypes.ENUM('admin', 'customer', 'driver', 'supplier', 'staff'),
defaultValue: 'customer'
}
}, {
tableName: 'users',
timestamps: false
});
async function testConnection() {
try {
console.log('Testing database connection...');
await sequelize.authenticate();
console.log('Database connection successful!');
// 查找admin用户
console.log('Searching for admin user...');
const adminUser = await User.findOne({
where: {
username: 'admin',
user_type: 'admin'
}
});
if (adminUser) {
console.log('Admin user found:', {
id: adminUser.id,
username: adminUser.username,
user_type: adminUser.user_type
});
} else {
console.log('Admin user not found');
// 查看前几个用户
console.log('Getting first 5 users...');
const users = await User.findAll({
limit: 5,
attributes: ['id', 'username', 'user_type']
});
console.log('Users:', users.map(u => ({
id: u.id,
username: u.username,
user_type: u.user_type
})));
}
} catch (error) {
console.error('Database connection error:', error.message);
if (error.original) {
console.error('Original error:', error.original.message);
}
} finally {
await sequelize.close();
}
}
testConnection();

32
backend/test_models.js Normal file
View File

@@ -0,0 +1,32 @@
const models = require('./src/models');
console.log('Available models:', Object.keys(models));
console.log('User model exists:', !!models.User);
console.log('Admin model exists:', !!models.Admin);
if (models.User) {
console.log('User model table name:', models.User.tableName);
}
if (models.Admin) {
console.log('Admin model table name:', models.Admin.tableName);
}
// 测试数据库连接
if (models.User && models.User.sequelize) {
models.User.sequelize.authenticate()
.then(() => {
console.log('Database connection successful');
return models.User.sequelize.query('SELECT id, username, user_type FROM users LIMIT 5;', {
type: models.User.sequelize.QueryTypes.SELECT
});
})
.then(result => {
console.log('Users data:', result);
})
.catch(err => {
console.error('Database error:', err.message);
});
} else {
console.log('Sequelize instance not found');
}

313
docs/数据库表结构说明.md Normal file
View File

@@ -0,0 +1,313 @@
# 数据库表结构说明
## 连接信息验证
数据库连接信息已验证有效：
- 主机: 129.211.213.226
- 端口: 9527
- 用户名: root
密码：aiotAiot123!
- 数据库: niumall
## 表结构详情
### 1. users 表（用户表）
```sql
CREATE TABLE `users` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`openid` varchar(64) NOT NULL UNIQUE,
`nickname` varchar(50) NOT NULL,
`avatar` varchar(255),
`gender` enum('male','female','other'),
`birthday` datetime,
`phone` varchar(20) UNIQUE,
`email` varchar(100) UNIQUE,
`uuid` varchar(36) UNIQUE,
`created_at` datetime NOT NULL,
`updated_at` datetime NOT NULL,
`deleted_at` datetime DEFAULT NULL,
PRIMARY KEY (`id`)
);
```
### 2. orders 表（订单表）
```sql
CREATE TABLE `orders` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`order_no` varchar(32) NOT NULL UNIQUE,
`user_id` bigint(20) NOT NULL,
`supplier_id` bigint(20) NOT NULL,
`cattle_type` varchar(50) NOT NULL,
`cattle_breed` varchar(50) NOT NULL,
`cattle_count` int(11) NOT NULL,
`expected_weight` decimal(10,2) NOT NULL,
`actual_weight` decimal(10,2),
`unit_price` decimal(10,2) NOT NULL,
`total_amount` decimal(15,2) NOT NULL,
`paid_amount` decimal(15,2) NOT NULL DEFAULT '0.00',
`remaining_amount` decimal(15,2) NOT NULL,
`status` enum('pending','confirmed','preparing','shipping','delivered','accepted','completed','cancelled','refunded') NOT NULL DEFAULT 'pending',
`delivery_address` varchar(200) NOT NULL,
`expected_delivery_date` datetime NOT NULL,
`actual_delivery_date` datetime,
`notes` text,
`created_at` datetime NOT NULL,
`updated_at` datetime NOT NULL,
`deleted_at` datetime DEFAULT NULL,
PRIMARY KEY (`id`)
);
```
### 3. payments 表（支付表）
```sql
CREATE TABLE `payments` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`order_id` bigint(20) NOT NULL,
`user_id` bigint(20) NOT NULL,
`amount` decimal(15,2) NOT NULL,
`paid_amount` decimal(15,2),
`payment_type` enum('wechat','alipay','bank') NOT NULL,
`payment_method` enum('mini_program','app','web') NOT NULL,
`payment_no` varchar(50) NOT NULL UNIQUE,
`third_party_id` varchar(100),
`status` enum('pending','paid','failed','refunded') DEFAULT 'pending',
`paid_time` datetime,
`created_at` datetime NOT NULL,
`updated_at` datetime NOT NULL,
`deleted_at` datetime DEFAULT NULL,
PRIMARY KEY (`id`)
);
```
### 4. transports 表（运输表）
```sql
CREATE TABLE `transports` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`order_id` bigint(20) NOT NULL,
`driver_id` bigint(20) NOT NULL,
`vehicle_id` bigint(20) NOT NULL,
`start_location` varchar(255) NOT NULL,
`end_location` varchar(255) NOT NULL,
`scheduled_start_time` datetime NOT NULL,
`actual_start_time` datetime,
`scheduled_end_time` datetime NOT NULL,
`actual_end_time` datetime,
`status` enum('scheduled','in_transit','completed','cancelled') DEFAULT 'scheduled',
`estimated_arrival_time` datetime,
`cattle_count` int(11) NOT NULL,
`special_requirements` text,
`created_at` datetime NOT NULL,
`updated_at` datetime NOT NULL,
`deleted_at` datetime DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `idx_order_id` (`order_id`),
KEY `idx_driver_id` (`driver_id`),
KEY `idx_vehicle_id` (`vehicle_id`)
);
```
### 5. suppliers 表（供应商表）
```sql
CREATE TABLE `suppliers` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`name` varchar(100) NOT NULL,
`code` varchar(20) NOT NULL UNIQUE,
`contact` varchar(50) NOT NULL,
`phone` varchar(20) NOT NULL UNIQUE,
`address` varchar(200) NOT NULL,
`business_license` varchar(255),
`qualification_level` varchar(10) NOT NULL,
`certifications` json,
`cattle_types` json,
`capacity` int(11),
`rating` decimal(3,2),
`cooperation_start_date` datetime,
`status` enum('active','inactive','suspended') DEFAULT 'active',
`region` varchar(20) NOT NULL,
`created_at` datetime NOT NULL,
`updated_at` datetime NOT NULL,
`deleted_at` datetime DEFAULT NULL,
PRIMARY KEY (`id`)
);
```
### 6. vehicles 表（车辆表）
```sql
CREATE TABLE `vehicles` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`license_plate` varchar(20) NOT NULL UNIQUE,
`vehicle_type` varchar(50) NOT NULL,
`capacity` int(11) NOT NULL,
`driver_id` bigint(20) NOT NULL,
`status` enum('available','in_use','maintenance','retired') DEFAULT 'available',
`last_maintenance_date` datetime,
`next_maintenance_date` datetime,
`insurance_expiry_date` datetime,
`registration_expiry_date` datetime,
`created_at` datetime NOT NULL,
`updated_at` datetime NOT NULL,
`deleted_at` datetime DEFAULT NULL,
PRIMARY KEY (`id`)
);
```
### 7. admins 表（管理员用户表）
```sql
CREATE TABLE `admins` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(50) NOT NULL UNIQUE,
`password_hash` varchar(255) NOT NULL,
`phone` varchar(20) NOT NULL UNIQUE,
`email` varchar(100),
`user_type` enum('client','supplier','driver','staff','admin') NOT NULL,
`status` enum('active','inactive','locked') DEFAULT 'active',
`created_at` datetime NOT NULL,
`updated_at` datetime NOT NULL,
`deleted_at` datetime DEFAULT NULL,
PRIMARY KEY (`id`)
);
```
## 表索引信息
### users 表索引
- PRIMARY: 主键索引 (id)
- openid: 唯一索引
- phone: 唯一索引
- email: 唯一索引
- uuid: 唯一索引
### orders 表索引
- PRIMARY: 主键索引 (id)
- order_no: 唯一索引
- orders_order_no: 唯一索引
- orders_user_id: 普通索引
- orders_supplier_id: 普通索引
- orders_status: 普通索引
- orders_created_at: 普通索引
### payments 表索引
- PRIMARY: 主键索引 (id)
- payment_no: 唯一索引
### suppliers 表索引
- PRIMARY: 主键索引 (id)
- code: 唯一索引
- phone: 唯一索引
### transports 表索引
- PRIMARY: 主键索引 (id)
- idx_order_id: 普通索引
- idx_driver_id: 普通索引
- idx_vehicle_id: 普通索引
### vehicles 表索引
- PRIMARY: 主键索引 (id)
- license_plate: 唯一索引
### admins 表索引
- PRIMARY: 主键索引 (id)
- username: 唯一索引
- phone: 唯一索引
## 表关系说明
1. `users` 表与 `orders` 表通过 `user_id` 字段关联
2. `suppliers` 表与 `orders` 表通过 `supplier_id` 字段关联
3. `orders` 表与 `payments` 表通过 `order_id` 字段关联
4. `users` 表与 `payments` 表通过 `user_id` 字段关联
5. `orders` 表与 `transports` 表通过 `order_id` 字段关联
6. `users` 表与 `transports` 表通过 `driver_id` 字段关联
7. `vehicles` 表与 `transports` 表通过 `vehicle_id` 字段关联
8. `users` 表与 `vehicles` 表通过 `driver_id` 字段关联
## 数据示例
### orders 表数据示例
```json
[
{
"id": 1,
"order_no": "ORD20240520001",
"user_id": 2,
"user_name": "采购商",
"supplier_id": 3,
"supplier_name": "供应商",
"trader_id": null,
"trader_name": null,
"cattle_breed": "西门塔尔牛",
"cattle_count": 10,
"expected_weight": "5000.00",
"actual_weight": null,
"unit_price": "35.00",
"total_amount": "175000.00",
"paid_amount": "50000.00",
"remaining_amount": "125000.00",
"status": "pending",
"delivery_address": "北京市朝阳区某某路123号",
"expected_delivery_date": "2024-06-01T00:00:00.000Z",
"actual_delivery_date": null,
"notes": "请按时交货，质量要保证",
"created_at": "2025-09-18T15:04:29.000Z",
"updated_at": "2025-09-18T15:04:29.000Z",
"deleted_at": null
}
]
```
### suppliers 表数据示例
```json
{
"id": 3,
"name": "内蒙古草原牧业有限公司",
"code": "NM001",
"contact": "张牧",
"phone": "13800000001",
"address": "内蒙古自治区呼和浩特市草原牧场1号",
"business_license": "",
"qualification_level": "A",
"certifications": "[]",
"cattle_types": "[\"西门塔尔牛\",\"夏洛莱牛\"]",
"capacity": 1000,
"rating": "0.00",
"cooperation_start_date": "2025-09-18T15:25:05.000Z",
"status": "active",
"region": "north",
"created_at": "2025-09-18T15:25:05.000Z",
"updated_at": "2025-09-18T15:25:05.000Z",
"deleted_at": null
}
```
### admins 表数据示例
```json
{
"id": 1,
"username": "admin",
"password_hash": "$2a$10$yQ2odJuDRDjPwiyT6v/NuO/V0wjTaUx9DlDmHqXwa.hMQ9km0cWPe",
"phone": "13800138001",
"email": "admin@niumall.com",
"user_type": "admin",
"status": "active",
"created_at": "2025-09-18T15:04:28.000Z",
"updated_at": "2025-09-18T15:04:28.000Z",
"deleted_at": null
}
```
## 使用建议
1. **数据初始化**：当前数据库中已有一些基础数据，包括5个供应商、3个管理员用户和2个订单。在开发过程中可以直接使用这些数据进行测试。
2. **权限管理**：admins 表中包含了不同角色的用户（admin、client、supplier），可以通过 user_type 字段进行权限控制。
3. **订单状态管理**：orders 表中的 status 字段包含了完整的订单状态流程，从 pending（待确认）到 completed（已完成）或 cancelled（已取消）。
4. **索引优化**：已为 `transports` 表添加了 `order_id`、`driver_id`、`vehicle_id` 等字段的索引以提高查询性能。建议继续为经常查询的字段添加索引，如 `orders.status`、`orders.created_at` 等。
5. **字段命名统一**：已完成统一使用下划线命名法，所有字段均采用下划线命名规范，保持了命名一致性。
6. **数据完整性**：可以添加外键约束来保证数据完整性，例如在 `orders` 表中添加外键约束关联 `users` 表和 `suppliers` 表。
7. **扩展性考虑**：已为所有表添加了软删除字段 `deleted_at` 以支持数据恢复功能。
8. **字段类型优化**：部分字段可以考虑使用更合适的类型，例如 `orders.status` 可以使用 TINYINT 类型配合枚举值映射来节省存储空间。