zhy.he/jw-beauty
1
0
派生 0
代码 工单 合并请求 工作流 软件包 项目 发布 百科 活动

refactor: restructure entire project for human maintainability

浏览代码 
Server:
- Add Express framework, replace custom router/request parser
- Create DAO layer (12 files) centralizing all 73 SQL queries
- Rewrite 7 route files as thin Express controllers calling DAOs
- Add SCF-to-Express adapter (lib/serverless.js)
- Add auth middleware (middleware/auth.js)
- Remove dead code from lib/auth.js

Admin console:
- Extract DataTable component (table + pagination)
- Extract ConfirmModal component (modal + form styles)
- Create listMixin for paginated list pages
- Move form styles to common.css for slot compatibility
- Refactor device + subscription pages as examples

Miniprogram:
- Split 734-line BLE monolith into 4 focused modules
  (protocol, connection, commands, barrel index)
- Create API module (utils/api.js) with named functions
- Create page utilities (utils/page.js)
- Refactor index + profile pages to use API module
这个提交包含在：
Guoguo
2026-04-29 05:58:20 -07:00
父节点 9f0e629c82
当前提交 bb4b80f867
共修改 46 个文件，包含 4306 行新增和 2020 行删除
下载 Patch 文件 下载 Diff 文件 展开所有文件 折叠所有文件
server/src/routes/admin.js
+207 -336
查看文件
@@ -1,364 +1,235 @@
const { one, query, limitClause } = require('../lib/db')
const router = require('express').Router()
const { ok, fail } = require('../lib/response')
const { hashPassword, hashPasswordLegacy, verifyPassword, signAdmin, requireAdmin } = require('../lib/auth')
const { writeLog } = require('../lib/log')
const { hashPassword, hashPasswordLegacy, verifyPassword, signAdmin } = require('../lib/auth')
const { requireAdmin } = require('../middleware/auth')
const adminDao = require('../dao/admin.dao')
const deviceDao = require('../dao/device.dao')
const bindingDao = require('../dao/binding.dao')
const commandDao = require('../dao/command.dao')
const userDao = require('../dao/user.dao')
const subscriptionDao = require('../dao/subscription.dao')
const treatmentDao = require('../dao/treatment.dao')
const logDao = require('../dao/log.dao')
const settingsDao = require('../dao/settings.dao')
function pageParams(ctx) {
const page = Math.max(1, parseInt(ctx.query.page, 10) || 1)
const pageSize = Math.min(Math.max(1, parseInt(ctx.query.page_size, 10) || 20), 100)
const wrap = fn => (req, res, next) => fn(req, res, next).catch(next)
function pageParams(query) {
const page = Math.max(1, parseInt(query.page, 10) || 1)
const pageSize = Math.min(Math.max(1, parseInt(query.page_size, 10) || 20), 100)
return { page, pageSize, offset: (page - 1) * pageSize }
}
function register(router) {
router.post('/api/v1/admin/login', async ctx => {
const username = ctx.body.username || ''
const password = ctx.body.password || ''
const admin = await one('SELECT * FROM admin_accounts WHERE username = :username AND status = 1', { username })
if (!admin) return fail(1001, '用户名或密码错误')
let matched = verifyPassword(password, admin.password_hash)
if (!matched) {
// Try legacy SHA-256 verification for migration
if (admin.password_salt && hashPasswordLegacy(password, admin.password_salt) === admin.password_hash) {
// Auto-migrate to bcrypt
const newHash = hashPassword(password)
await query('UPDATE admin_accounts SET password_hash = :password_hash, password_salt = :password_salt WHERE admin_id = :admin_id', { password_hash: newHash, password_salt: '', admin_id: admin.admin_id })
matched = true
}
}
if (!matched) return fail(1001, '用户名或密码错误')
const token = signAdmin(admin)
await writeLog({ admin_id: admin.admin_id, action: 'admin_login', detail: '管理员登录: ' + username, ip: ctx.ip })
return ok({ token, admin_id: String(admin.admin_id), username: admin.username, real_name: admin.real_name, role: admin.role })
})
// --- Auth ---
router.post('/api/v1/admin/password', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const oldPassword = ctx.body.old_password || ''
const newPassword = ctx.body.new_password || ''
if (newPassword.length < 6) return fail(2001, 'password too short')
const current = await one('SELECT * FROM admin_accounts WHERE admin_id = :admin_id AND status = 1', { admin_id: admin.admin_id })
if (!current) return fail(1002, '未授权，请重新登录')
let matched = verifyPassword(oldPassword, current.password_hash)
if (!matched && current.password_salt && hashPasswordLegacy(oldPassword, current.password_salt) === current.password_hash) {
router.post('/login', wrap(async (req, res) => {
const username = req.body.username || ''
const password = req.body.password || ''
const admin = await adminDao.findByUsername(username)
if (!admin) return res.json(fail(1001, '用户名或密码错误'))
let matched = verifyPassword(password, admin.password_hash)
if (!matched) {
if (admin.password_salt && hashPasswordLegacy(password, admin.password_salt) === admin.password_hash) {
const newHash = hashPassword(password)
await adminDao.updatePassword(admin.admin_id, newHash)
matched = true
}
if (!matched) return fail(1001, '原密码错误')
const newHash = hashPassword(newPassword)
await query('UPDATE admin_accounts SET password_hash = :password_hash, password_salt = :password_salt WHERE admin_id = :admin_id', { password_hash: newHash, password_salt: '', admin_id: admin.admin_id })
await writeLog({ admin_id: admin.admin_id, action: 'admin_change_password', detail: '管理员修改密码', ip: ctx.ip })
return ok({ message: 'success' })
})
}
if (!matched) return res.json(fail(1001, '用户名或密码错误'))
const token = signAdmin(admin)
await logDao.write({ admin_id: admin.admin_id, action: 'admin_login', detail: '管理员登录: ' + username, ip: req.ip })
res.json(ok({ token, admin_id: String(admin.admin_id), username: admin.username, real_name: admin.real_name, role: admin.role }))
}))
router.get('/api/v1/admin/dashboard', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const rows = await Promise.all([
query('SELECT COUNT(*) AS total FROM devices', {}),
query('SELECT COUNT(*) AS total FROM users', {}),
query('SELECT COUNT(*) AS total FROM treatment_records', {}),
query('SELECT COUNT(*) AS total FROM subscriptions WHERE status = 1 AND expire_time > NOW()', {})
])
const subStats = await query('SELECT ' +
'SUM(CASE WHEN plan = \'monthly\' AND status = 1 AND expire_time > NOW() THEN 1 ELSE 0 END) AS monthly_count, ' +
'SUM(CASE WHEN plan = \'yearly\' AND status = 1 AND expire_time > NOW() THEN 1 ELSE 0 END) AS yearly_count, ' +
'SUM(CASE WHEN plan = \'trial\' AND status = 1 AND expire_time > NOW() THEN 1 ELSE 0 END) AS trial_count, ' +
'COALESCE(SUM(CASE WHEN MONTH(start_time) = MONTH(NOW()) AND YEAR(start_time) = YEAR(NOW()) THEN amount ELSE 0 END), 0) AS monthly_revenue ' +
'FROM subscriptions', {})
return ok({
device_count: rows[0][0].total,
user_count: rows[1][0].total,
treatment_count: rows[2][0].total,
subscription_count: rows[3][0].total,
sub_stats: subStats[0] || {}
})
})
router.post('/password', requireAdmin, wrap(async (req, res) => {
const oldPassword = req.body.old_password || ''
const newPassword = req.body.new_password || ''
if (newPassword.length < 6) return res.json(fail(2001, 'password too short'))
const current = await adminDao.findById(req.admin.admin_id)
if (!current) return res.json(fail(1002, '未授权，请重新登录'))
let matched = verifyPassword(oldPassword, current.password_hash)
if (!matched && current.password_salt && hashPasswordLegacy(oldPassword, current.password_salt) === current.password_hash) {
matched = true
}
if (!matched) return res.json(fail(1001, '原密码错误'))
const newHash = hashPassword(newPassword)
await adminDao.updatePassword(req.admin.admin_id, newHash)
await logDao.write({ admin_id: req.admin.admin_id, action: 'admin_change_password', detail: '管理员修改密码', ip: req.ip })
res.json(ok({ message: 'success' }))
}))
router.get('/api/v1/admin/devices', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const p = pageParams(ctx)
const keyword = (ctx.query.keyword || '').trim()
let where = ''
const params = {}
if (keyword) {
where = ' WHERE d.device_id LIKE :kw OR d.device_name LIKE :kw'
params.kw = '%' + keyword + '%'
}
const total = await query('SELECT COUNT(*) AS total FROM devices d' + where, params)
const records = await query('SELECT d.*, b.user_id AS bound_user, b.bind_time AS activated_at FROM devices d LEFT JOIN bindings b ON b.device_id = d.device_id AND b.bind_status = 1' + where + ' ORDER BY d.created_at DESC' + limitClause(p.pageSize, p.offset), params)
return ok({ records, total: total[0].total })
})
// --- Dashboard ---
router.post('/api/v1/admin/devices', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const deviceId = String(ctx.body.device_id || '').trim()
if (!deviceId) return fail(2001, 'device_id required')
await query(
'INSERT INTO devices (device_id, product_id, device_secret, device_name, firmware_version, status) VALUES (:device_id, :product_id, :device_secret, :device_name, :firmware_version, 1) ON DUPLICATE KEY UPDATE product_id = VALUES(product_id), device_secret = VALUES(device_secret), device_name = VALUES(device_name), firmware_version = VALUES(firmware_version), status = 1',
{
device_id: deviceId,
product_id: ctx.body.product_id || 'HOX_LIGHT_MASK',
device_secret: ctx.body.device_secret || '',
device_name: ctx.body.device_name || '光子美容仪',
firmware_version: ctx.body.firmware_version || '1.0.0'
}
)
await writeLog({ admin_id: admin.admin_id, action: 'admin_device_create', detail: '预生成产品码: ' + deviceId, ip: ctx.ip })
return ok({ device_id: deviceId })
})
router.get('/dashboard', requireAdmin, wrap(async (req, res) => {
const counts = await adminDao.getDashboardCounts()
const subStats = await adminDao.getSubscriptionStats()
res.json(ok({
device_count: counts.device_count,
user_count: counts.user_count,
treatment_count: counts.treatment_count,
subscription_count: counts.subscription_count,
sub_stats: subStats
}))
}))
router.post('/api/v1/admin/devices/batch', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const deviceIds = ctx.body.device_ids
if (!Array.isArray(deviceIds) || deviceIds.length === 0 || deviceIds.length > 500) return fail(2001, 'device_ids must be an array with 1-500 items')
let successCount = 0
const failedIds = []
for (const id of deviceIds) {
const deviceId = String(id || '').trim()
if (!deviceId) { failedIds.push(id); continue }
try {
await query(
'INSERT INTO devices (device_id, product_id, device_secret, device_name, firmware_version, status) VALUES (:device_id, :product_id, :device_secret, :device_name, :firmware_version, 1) ON DUPLICATE KEY UPDATE product_id = VALUES(product_id), device_secret = VALUES(device_secret), device_name = VALUES(device_name), firmware_version = VALUES(firmware_version), status = 1',
{
device_id: deviceId,
product_id: 'HOX_LIGHT_MASK',
device_secret: '',
device_name: '光子美容仪',
firmware_version: '1.0.0'
}
)
successCount++
} catch (err) {
failedIds.push(deviceId)
}
}
await writeLog({ admin_id: admin.admin_id, action: 'admin_device_batch_create', detail: '批量预生成产品码: ' + successCount + '/' + deviceIds.length, ip: ctx.ip })
return ok({ created: successCount, failed: failedIds })
})
// --- Devices ---
router.get('/api/v1/admin/devices/:device_id', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const device = await one('SELECT d.*, b.user_id AS bound_user, b.bind_time AS activated_at FROM devices d LEFT JOIN bindings b ON b.device_id = d.device_id AND b.bind_status = 1 WHERE d.device_id = :device_id', { device_id: ctx.params.device_id })
if (!device) return fail(1005, 'DEVICE_NOT_FOUND')
const bindingHistory = await query('SELECT b.*, u.nickname FROM bindings b LEFT JOIN users u ON u.user_id = b.user_id WHERE b.device_id = :device_id ORDER BY b.bind_time DESC', { device_id: ctx.params.device_id })
const recentTreatments = await query('SELECT r.*, u.nickname FROM treatment_records r LEFT JOIN users u ON u.user_id = r.user_id WHERE r.device_id = :device_id ORDER BY r.created_at DESC LIMIT 5', { device_id: ctx.params.device_id })
return ok(Object.assign({}, device, { binding_history: bindingHistory, recent_treatments: recentTreatments }))
router.get('/devices', requireAdmin, wrap(async (req, res) => {
const { page, pageSize, offset } = pageParams(req.query)
const { records, total } = await deviceDao.list({
keyword: req.query.keyword,
pageSize,
offset
})
res.json(ok({ records, total }))
}))
router.post('/api/v1/admin/devices/:device_id/unbind', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
await query('UPDATE bindings SET bind_status = 2, unbind_time = NOW() WHERE device_id = :device_id AND bind_status = 1', { device_id: ctx.params.device_id })
await writeLog({ admin_id: admin.admin_id, action: 'admin_device_unbind', detail: '后台解绑设备: ' + ctx.params.device_id, ip: ctx.ip })
return ok({ message: 'success' })
router.post('/devices', requireAdmin, wrap(async (req, res) => {
const deviceId = String(req.body.device_id || '').trim()
if (!deviceId) return res.json(fail(2001, 'device_id required'))
await deviceDao.create({
device_id: deviceId,
product_id: req.body.product_id || 'HOX_LIGHT_MASK',
device_secret: req.body.device_secret || '',
device_name: req.body.device_name || '光子美容仪',
firmware_version: req.body.firmware_version || '1.0.0'
})
await logDao.write({ admin_id: req.admin.admin_id, action: 'admin_device_create', detail: '预生成产品码: ' + deviceId, ip: req.ip })
res.json(ok({ device_id: deviceId }))
}))
router.post('/api/v1/admin/devices/:device_id/command', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const opcode = parseInt(ctx.body.opcode, 10)
if (!opcode) return fail(2001, 'opcode required')
await query(
'INSERT INTO device_commands (device_id, admin_id, opcode, payload_json, status) VALUES (:device_id, :admin_id, :opcode, :payload_json, 1)',
{ device_id: ctx.params.device_id, admin_id: admin.admin_id, opcode, payload_json: JSON.stringify(ctx.body) }
)
await writeLog({ admin_id: admin.admin_id, action: 'admin_device_command', detail: '记录远程指令: ' + ctx.params.device_id, ip: ctx.ip })
return ok({ message: 'queued', command: ctx.body })
router.post('/devices/batch', requireAdmin, wrap(async (req, res) => {
const deviceIds = req.body.device_ids
if (!Array.isArray(deviceIds) || deviceIds.length === 0 || deviceIds.length > 500) {
return res.json(fail(2001, 'device_ids must be an array with 1-500 items'))
}
const { created, failed } = await deviceDao.createBatch(deviceIds)
await logDao.write({ admin_id: req.admin.admin_id, action: 'admin_device_batch_create', detail: '批量预生成产品码: ' + created + '/' + deviceIds.length, ip: req.ip })
res.json(ok({ created, failed }))
}))
router.get('/devices/:device_id', requireAdmin, wrap(async (req, res) => {
const result = await deviceDao.findByIdWithHistory(req.params.device_id)
if (!result) return res.json(fail(1005, 'DEVICE_NOT_FOUND'))
res.json(ok(result))
}))
router.post('/devices/:device_id/unbind', requireAdmin, wrap(async (req, res) => {
await deviceDao.unbind(req.params.device_id)
await logDao.write({ admin_id: req.admin.admin_id, action: 'admin_device_unbind', detail: '后台解绑设备: ' + req.params.device_id, ip: req.ip })
res.json(ok({ message: 'success' }))
}))
router.post('/devices/:device_id/command', requireAdmin, wrap(async (req, res) => {
const opcode = parseInt(req.body.opcode, 10)
if (!opcode) return res.json(fail(2001, 'opcode required'))
await commandDao.create(req.params.device_id, req.admin.admin_id, opcode, req.body)
await logDao.write({ admin_id: req.admin.admin_id, action: 'admin_device_command', detail: '记录远程指令: ' + req.params.device_id, ip: req.ip })
res.json(ok({ message: 'queued', command: req.body }))
}))
router.get('/devices/:device_id/commands', requireAdmin, wrap(async (req, res) => {
const { page, pageSize, offset } = pageParams(req.query)
const { records, total } = await commandDao.listByDevice(req.params.device_id, { pageSize, offset })
res.json(ok({ records, total }))
}))
// --- Users ---
router.get('/users', requireAdmin, wrap(async (req, res) => {
const { page, pageSize, offset } = pageParams(req.query)
const { records, total } = await userDao.listAdmin({
keyword: req.query.keyword,
pageSize,
offset
})
res.json(ok({ records, total }))
}))
router.get('/api/v1/admin/devices/:device_id/commands', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const p = pageParams(ctx)
const total = await query('SELECT COUNT(*) AS total FROM device_commands WHERE device_id = :device_id', { device_id: ctx.params.device_id })
const records = await query(
'SELECT command_id, device_id, admin_id, opcode, payload_json, status, created_at, pulled_at, finished_at, result_json FROM device_commands WHERE device_id = :device_id ORDER BY created_at DESC' + limitClause(p.pageSize, p.offset),
{ device_id: ctx.params.device_id }
)
return ok({ records, total: total[0].total })
router.get('/users/:user_id', requireAdmin, wrap(async (req, res) => {
const result = await userDao.findByIdAdmin(req.params.user_id)
if (!result) return res.json(fail(1004, 'USER_NOT_FOUND'))
res.json(ok(result))
}))
// --- Subscriptions ---
router.get('/subscriptions', requireAdmin, wrap(async (req, res) => {
const { page, pageSize, offset } = pageParams(req.query)
const { records, total } = await subscriptionDao.list({
tab: req.query.tab,
pageSize,
offset
})
const stats = await subscriptionDao.getStats()
res.json(ok({ records, total, stats }))
}))
router.get('/api/v1/admin/users', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const p = pageParams(ctx)
const keyword = (ctx.query.keyword || '').trim()
let where = ''
const params = {}
if (keyword) {
where = ' WHERE u.nickname LIKE :kw OR u.phone LIKE :kw OR u.user_id = :keyword'
params.kw = '%' + keyword + '%'
params.keyword = keyword
}
const total = await query('SELECT COUNT(*) AS total FROM users u' + where, params)
const records = await query(
'SELECT u.*,' +
' (SELECT COUNT(*) FROM bindings WHERE user_id = u.user_id AND bind_status = 1) AS device_count,' +
' (SELECT COUNT(*) FROM treatment_records WHERE user_id = u.user_id) AS treatment_count,' +
' COALESCE((SELECT status FROM subscriptions WHERE user_id = u.user_id AND status = 1 AND expire_time > NOW() ORDER BY expire_time DESC LIMIT 1), 0) AS subscription_status' +
' FROM users u' + where + ' ORDER BY u.created_at DESC' + limitClause(p.pageSize, p.offset),
params
)
return ok({ records, total: total[0].total })
router.post('/subscriptions', requireAdmin, wrap(async (req, res) => {
const userId = req.body.user_id
if (!userId) return res.json(fail(2001, 'user_id required'))
const targetUser = await userDao.findById(userId)
if (!targetUser) return res.json(fail(1004, 'user_not_found'))
await subscriptionDao.adminCreate(
userId,
req.body.plan || 'monthly',
req.body.amount || 0,
req.body.order_id || 'ADMIN' + Date.now(),
req.body.days || 30
)
res.json(ok({ message: 'success' }))
}))
router.post('/subscriptions/cancel', requireAdmin, wrap(async (req, res) => {
const subscriptionId = req.body.subscription_id
if (!subscriptionId) return res.json(fail(2001, 'subscription_id required'))
const result = await subscriptionDao.cancel(subscriptionId)
if (result.affectedRows === 0) return res.json(fail(2001, '未找到有效订阅'))
await logDao.write({ admin_id: req.admin.admin_id, action: 'subscription_cancel', detail: '取消订阅 #' + subscriptionId, ip: req.ip })
res.json(ok({ message: 'success' }))
}))
// --- Treatment Records ---
router.get('/records', requireAdmin, wrap(async (req, res) => {
const { page, pageSize, offset } = pageParams(req.query)
const { records, total } = await treatmentDao.listAdmin({
keyword: req.query.keyword,
dateFrom: req.query.date_from,
dateTo: req.query.date_to,
pageSize,
offset
})
res.json(ok({ records, total }))
}))
router.get('/api/v1/admin/users/:user_id', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const user = await one('SELECT * FROM users WHERE user_id = :user_id', { user_id: ctx.params.user_id })
if (!user) return fail(1004, 'USER_NOT_FOUND')
const devices = await query('SELECT d.device_id, d.device_name FROM bindings b JOIN devices d ON d.device_id = b.device_id WHERE b.user_id = :user_id AND b.bind_status = 1', { user_id: user.user_id })
const treatments = await query('SELECT * FROM treatment_records WHERE user_id = :user_id ORDER BY created_at DESC LIMIT 5', { user_id: user.user_id })
const subscription = await one('SELECT plan, status, start_time, expire_time FROM subscriptions WHERE user_id = :user_id AND status = 1 AND expire_time > NOW() ORDER BY expire_time DESC LIMIT 1', { user_id: user.user_id })
const stats = await one('SELECT COUNT(*) AS treatment_count, COALESCE(SUM(total_duration_ms), 0) AS total_duration FROM treatment_records WHERE user_id = :user_id', { user_id: user.user_id })
return ok(Object.assign({}, user, {
devices,
recent_treatments: treatments,
subscription_status: subscription ? subscription.status : 0,
subscription_type: subscription ? subscription.plan : null,
subscription_expire: subscription ? subscription.expire_time : null,
treatment_count: stats ? stats.treatment_count : 0,
total_duration: stats ? stats.total_duration : 0
}))
// --- Logs ---
router.get('/logs', requireAdmin, wrap(async (req, res) => {
const { page, pageSize, offset } = pageParams(req.query)
const { records, total } = await logDao.list({
type: req.query.type,
deviceId: req.query.device_id,
pageSize,
offset
})
res.json(ok({ records, total }))
}))
router.get('/api/v1/admin/subscriptions', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const p = pageParams(ctx)
const tab = (ctx.query.tab || '').trim()
let where = ''
const params = {}
if (tab && tab !== 'all') {
if (tab === 'expired') {
where = ' WHERE s.status = 2'
} else {
where = ' WHERE s.plan = :plan'
params.plan = tab
}
}
const total = await query('SELECT COUNT(*) AS total FROM subscriptions s' + where, params)
const records = await query(
'SELECT s.*, u.nickname FROM subscriptions s LEFT JOIN users u ON u.user_id = s.user_id' + where + ' ORDER BY s.created_at DESC' + limitClause(p.pageSize, p.offset),
params
)
const statsRow = await query('SELECT ' +
'SUM(CASE WHEN plan = \'monthly\' AND status = 1 AND expire_time > NOW() THEN 1 ELSE 0 END) AS monthly_count, ' +
'SUM(CASE WHEN plan = \'yearly\' AND status = 1 AND expire_time > NOW() THEN 1 ELSE 0 END) AS yearly_count, ' +
'SUM(CASE WHEN plan = \'trial\' AND status = 1 AND expire_time > NOW() THEN 1 ELSE 0 END) AS trial_count, ' +
'COALESCE(SUM(CASE WHEN MONTH(start_time) = MONTH(NOW()) AND YEAR(start_time) = YEAR(NOW()) THEN amount ELSE 0 END), 0) AS monthly_revenue ' +
'FROM subscriptions', {})
return ok({ records, total: total[0].total, stats: statsRow[0] || {} })
})
// --- Settings ---
router.post('/api/v1/admin/subscriptions', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const targetUser = await one('SELECT user_id FROM users WHERE user_id = :user_id', { user_id: ctx.body.user_id })
if (!targetUser) return fail(1004, 'user_not_found')
await query('UPDATE subscriptions SET status = 2 WHERE user_id = :user_id AND status = 1', { user_id: ctx.body.user_id })
await query('INSERT INTO subscriptions (user_id, plan, status, amount, order_id, start_time, expire_time) VALUES (:user_id, :plan, 1, :amount, :order_id, NOW(), DATE_ADD(NOW(), INTERVAL :days DAY))', {
user_id: ctx.body.user_id,
plan: ctx.body.plan || 'monthly',
amount: ctx.body.amount || 0,
order_id: ctx.body.order_id || 'ADMIN' + Date.now(),
days: ctx.body.days || 30
})
return ok({ message: 'success' })
})
router.get('/settings', requireAdmin, wrap(async (req, res) => {
const settings = await settingsDao.getAll()
res.json(ok(settings))
}))
router.post('/api/v1/admin/subscriptions/cancel', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const subscriptionId = ctx.body.subscription_id
if (!subscriptionId) return fail(2001, 'subscription_id required')
const result = await query('UPDATE subscriptions SET status = 3 WHERE subscription_id = :subscription_id AND status = 1', { subscription_id: subscriptionId })
if (result.affectedRows === 0) return fail(2001, '未找到有效订阅')
await writeLog({ admin_id: admin.admin_id, action: 'subscription_cancel', detail: '取消订阅 #' + subscriptionId, ip: ctx.ip })
return ok({ message: 'success' })
})
router.post('/settings', requireAdmin, wrap(async (req, res) => {
const ALLOWED_KEYS = ['system_name', 'admin_email', 'timezone', 'monthly_price', 'yearly_price', 'trial_days', 'enable_register', 'enable_binding', 'enable_free_mode', 'enable_smart_mode', 'maintenance_mode']
for (const key of Object.keys(req.body || {})) {
if (!ALLOWED_KEYS.includes(key)) continue
await settingsDao.update(key, req.body[key])
}
res.json(ok({ message: 'success' }))
}))
router.get('/api/v1/admin/records', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const p = pageParams(ctx)
const keyword = (ctx.query.keyword || '').trim()
const dateFrom = (ctx.query.date_from || '').trim()
const dateTo = (ctx.query.date_to || '').trim()
const conditions = []
const params = {}
if (keyword) {
conditions.push('u.nickname LIKE :kw')
params.kw = '%' + keyword + '%'
}
if (dateFrom) {
conditions.push('r.created_at >= :date_from')
params.date_from = dateFrom
}
if (dateTo) {
conditions.push('r.created_at <= :date_to')
params.date_to = dateTo
}
const where = conditions.length ? ' WHERE ' + conditions.join(' AND ') : ''
const total = await query('SELECT COUNT(*) AS total FROM treatment_records r LEFT JOIN users u ON u.user_id = r.user_id' + where, params)
const records = await query(
'SELECT r.*, u.nickname FROM treatment_records r LEFT JOIN users u ON u.user_id = r.user_id' + where + ' ORDER BY r.created_at DESC' + limitClause(p.pageSize, p.offset),
params
)
return ok({ records, total: total[0].total })
})
router.get('/api/v1/admin/logs', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const p = pageParams(ctx)
const type = (ctx.query.type || '').trim()
const deviceId = (ctx.query.device_id || '').trim()
const conditions = []
const params = {}
if (type) {
conditions.push('action LIKE :type')
params.type = '%' + type + '%'
}
if (deviceId) {
conditions.push('detail LIKE :device_id')
params.device_id = '%' + deviceId + '%'
}
const where = conditions.length ? ' WHERE ' + conditions.join(' AND ') : ''
const total = await query('SELECT COUNT(*) AS total FROM operation_logs' + where, params)
const records = await query('SELECT * FROM operation_logs' + where + ' ORDER BY created_at DESC' + limitClause(p.pageSize, p.offset), params)
return ok({ records, total: total[0].total })
})
router.get('/api/v1/admin/settings', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const rows = await query('SELECT setting_key, setting_value FROM system_settings', {})
const settings = {}
rows.forEach(row => {
if (typeof row.setting_value === 'string') {
try { settings[row.setting_key] = JSON.parse(row.setting_value) } catch (_) { settings[row.setting_key] = row.setting_value }
} else {
settings[row.setting_key] = row.setting_value
}
})
return ok(settings)
})
router.post('/api/v1/admin/settings', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const ALLOWED_KEYS = ['system_name', 'admin_email', 'timezone', 'monthly_price', 'yearly_price', 'trial_days', 'enable_register', 'enable_binding', 'enable_free_mode', 'enable_smart_mode', 'maintenance_mode']
for (const key of Object.keys(ctx.body || {})) {
if (!ALLOWED_KEYS.includes(key)) continue
await query('REPLACE INTO system_settings (setting_key, setting_value) VALUES (:setting_key, :setting_value)', { setting_key: key, setting_value: JSON.stringify(ctx.body[key]) })
}
return ok({ message: 'success' })
})
}
module.exports = register
module.exports = router
server/src/routes/auth.js
+59 -62
查看文件
@@ -1,78 +1,75 @@
const jwt = require('jsonwebtoken')
const { one, query } = require('../lib/db')
const router = require('express').Router()
const { ok, fail } = require('../lib/response')
const { signUser, readBearer } = require('../lib/auth')
const { code2Session } = require('../lib/wechat')
const { writeLog } = require('../lib/log')
const config = require('../config')
const userDao = require('../dao/user.dao')
const logDao = require('../dao/log.dao')
function register(router) {
router.post('/api/v1/auth/login', async ctx => {
const session = await code2Session(ctx.body.code || '')
let user = await one('SELECT * FROM users WHERE openid = :openid', { openid: session.openid })
if (!user) {
const result = await query(
'INSERT INTO users (openid, nickname, avatar, status) VALUES (:openid, :nickname, :avatar, 1)',
{ openid: session.openid, nickname: '', avatar: '' }
)
user = await one('SELECT * FROM users WHERE user_id = :user_id', { user_id: result.insertId })
await writeLog({ user_id: user.user_id, action: 'user_register', detail: '新用户注册', ip: ctx.ip })
}
const token = signUser(user)
await writeLog({ user_id: user.user_id, action: 'user_login', detail: '用户登录', ip: ctx.ip })
return ok({
token,
const wrap = fn => (req, res, next) => fn(req, res, next).catch(next)
router.post('/auth/login', wrap(async (req, res) => {
const session = await code2Session(req.body.code || '')
let user = await userDao.findByOpenid(session.openid)
if (!user) {
const result = await userDao.create(session.openid)
user = await userDao.findById(result.insertId)
await logDao.write({ user_id: user.user_id, action: 'user_register', detail: '新用户注册', ip: req.ip })
}
const token = signUser(user)
await logDao.write({ user_id: user.user_id, action: 'user_login', detail: '用户登录', ip: req.ip })
res.json(ok({
token,
user_id: String(user.user_id),
user_info: {
user_id: String(user.user_id),
user_info: {
user_id: String(user.user_id),
nickname: user.nickname || '用户' + String(user.user_id),
avatar: user.avatar || '',
phone: user.phone || '',
gender: user.gender || 0
},
expires_in: 604800
})
})
nickname: user.nickname || '用户' + String(user.user_id),
avatar: user.avatar || '',
phone: user.phone || '',
gender: user.gender || 0
},
expires_in: 604800
}))
}))
router.post('/api/v1/auth/refresh', async ctx => {
const token = readBearer(ctx.headers)
if (!token) return fail(1001, 'token_expired')
router.post('/auth/refresh', wrap(async (req, res) => {
const token = readBearer(req.headers)
if (!token) return res.json(fail(1001, 'token_expired'))
let payload
try {
payload = jwt.verify(token, config.jwt.secret)
} catch (err) {
if (err.name === 'TokenExpiredError') {
try {
payload = jwt.verify(token, config.jwt.secret, { ignoreExpiration: true })
} catch (_) {
return fail(1001, 'token_expired')
}
const now = Math.floor(Date.now() / 1000)
const gracePeriod = 3 * 24 * 60 * 60
if (now - payload.exp > gracePeriod) {
return fail(1001, 'token_expired')
}
} else {
return fail(1001, 'token_expired')
let payload
try {
payload = jwt.verify(token, config.jwt.secret)
} catch (err) {
if (err.name === 'TokenExpiredError') {
try {
payload = jwt.verify(token, config.jwt.secret, { ignoreExpiration: true })
} catch (_) {
return res.json(fail(1001, 'token_expired'))
}
const now = Math.floor(Date.now() / 1000)
const gracePeriod = 3 * 24 * 60 * 60
if (now - payload.exp > gracePeriod) {
return res.json(fail(1001, 'token_expired'))
}
} else {
return res.json(fail(1001, 'token_expired'))
}
}
if (payload.type !== 'user') return fail(1001, 'token_expired')
if (payload.type !== 'user') return res.json(fail(1001, 'token_expired'))
// Check if token is within 7 days of expiry (for non-expired tokens)
const now = Math.floor(Date.now() / 1000)
const sevenDays = 7 * 24 * 60 * 60
if (payload.exp && payload.exp > now && (payload.exp - now) > sevenDays) {
return ok({ token, expires_in: payload.exp - now })
}
const now = Math.floor(Date.now() / 1000)
const sevenDays = 7 * 24 * 60 * 60
if (payload.exp && payload.exp > now && (payload.exp - now) > sevenDays) {
return res.json(ok({ token, expires_in: payload.exp - now }))
}
const user = await one('SELECT * FROM users WHERE user_id = :user_id AND status = 1', { user_id: payload.user_id })
if (!user) return fail(1001, 'token_expired')
const user = await userDao.findById(payload.user_id)
if (!user) return res.json(fail(1001, 'token_expired'))
const newToken = signUser(user)
return ok({ token: newToken, expires_in: 604800 })
})
}
const newToken = signUser(user)
res.json(ok({ token: newToken, expires_in: 604800 }))
}))
module.exports = register
module.exports = router
server/src/routes/device.js
+124 -165
查看文件
@@ -1,176 +1,135 @@
const { one, query, transaction } = require('../lib/db')
const router = require('express').Router()
const { ok, fail } = require('../lib/response')
const { requireUser, randomHex } = require('../lib/auth')
const { writeLog } = require('../lib/log')
const { requireUser } = require('../middleware/auth')
const { randomHex } = require('../lib/auth')
const bindingDao = require('../dao/binding.dao')
const deviceDao = require('../dao/device.dao')
const commandDao = require('../dao/command.dao')
const subscriptionDao = require('../dao/subscription.dao')
const deviceEventDao = require('../dao/device-event.dao')
const logDao = require('../dao/log.dao')
const wrap = fn => (req, res, next) => fn(req, res, next).catch(next)
async function ensureTrial(conn, userId) {
const [subs] = await conn.execute('SELECT subscription_id FROM subscriptions WHERE user_id = ? AND status = 1 AND expire_time > NOW() LIMIT 1', [userId])
if (subs.length > 0) return
await conn.execute('INSERT INTO subscriptions (user_id, plan, status, amount, start_time, expire_time) VALUES (?, ?, 1, 0, NOW(), DATE_ADD(NOW(), INTERVAL 7 DAY))', [userId, 'trial'])
}
router.post('/device/bind', requireUser, wrap(async (req, res) => {
const deviceId = String(req.body.device_id || '').trim()
if (!deviceId) return res.json(fail(2001, 'device_id required'))
function register(router) {
router.post('/api/v1/device/bind', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const deviceId = String(ctx.body.device_id || '').trim()
if (!deviceId) return fail(2001, 'device_id required')
const active = await bindingDao.findActiveByUser(req.user.user_id)
if (active) return res.json(fail(2001, '已绑定设备', { device_id: active.device_id }))
const result = await transaction(async conn => {
const [active] = await conn.execute('SELECT device_id FROM bindings WHERE user_id = ? AND bind_status = 1 LIMIT 1', [user.user_id])
if (active.length > 0) return { duplicated: true, device_id: active[0].device_id }
const device = await bindingDao.findDeviceExists(deviceId)
if (!device) return res.json(fail(1005, 'DEVICE_NOT_FOUND'))
const [devices] = await conn.execute('SELECT * FROM devices WHERE device_id = ? AND status <> 4 LIMIT 1', [deviceId])
if (devices.length === 0) return { invalid: true }
const bindToken = randomHex(8)
await bindingDao.createPending(req.user.user_id, deviceId, bindToken)
await logDao.write({ user_id: req.user.user_id, action: 'device_bind_request', detail: '申请绑定设备: ' + deviceId, ip: req.ip })
const bindToken = randomHex(8)
await conn.execute(
'INSERT INTO bindings (user_id, device_id, bind_token, bind_expires, bind_status, bind_time) VALUES (?, ?, ?, DATE_ADD(NOW(), INTERVAL 10 MINUTE), 3, NOW())',
[user.user_id, deviceId, bindToken]
)
return { device_id: deviceId, bind_token: bindToken }
})
const sub = await subscriptionDao.findActive(req.user.user_id)
res.json(ok({
device_id: deviceId,
bind_token: bindToken,
subscription: sub ? { plan: sub.plan, remaining_days: sub.remaining_days } : { plan: 'none', remaining_days: 0 }
}))
}))
if (result.invalid) return fail(1005, 'DEVICE_NOT_FOUND')
if (result.duplicated) return fail(2001, '已绑定设备', { device_id: result.device_id })
await writeLog({ user_id: user.user_id, action: 'device_bind_request', detail: '申请绑定设备: ' + deviceId, ip: ctx.ip })
const sub = await one('SELECT plan, GREATEST(DATEDIFF(expire_time, NOW()), 0) AS remaining_days FROM subscriptions WHERE user_id = :user_id AND status = 1 AND expire_time > NOW() ORDER BY expire_time DESC LIMIT 1', { user_id: user.user_id })
return ok(Object.assign(result, { subscription: sub ? { plan: sub.plan, remaining_days: sub.remaining_days } : { plan: 'none', remaining_days: 0 } }))
router.post('/device/bind/confirm', requireUser, wrap(async (req, res) => {
const deviceId = String(req.body.device_id || '').trim()
const bindToken = String(req.body.bind_token || '').trim()
if (!deviceId || !bindToken) return res.json(fail(2001, 'device_id and bind_token required'))
const confirmed = await bindingDao.confirmBind(req.user.user_id, deviceId, bindToken)
if (!confirmed) return res.json(fail(2001, 'bind_token invalid or expired'))
await logDao.write({ user_id: req.user.user_id, action: 'device_bind_confirm', detail: '确认绑定设备: ' + deviceId, ip: req.ip })
const sub = await subscriptionDao.findActive(req.user.user_id)
res.json(ok({
message: 'success',
subscription: sub ? { plan: sub.plan, remaining_days: sub.remaining_days } : { plan: 'none', remaining_days: 0 }
}))
}))
router.post('/device/mock-bind', requireUser, wrap(async (req, res) => {
const config = require('../config')
if (config.nodeEnv === 'production') return res.json(fail(2001, 'not available in production'))
const deviceId = String(req.body.device_id || '').trim()
if (!deviceId) return res.json(fail(2001, 'device_id required'))
const active = await bindingDao.findActiveByUser(req.user.user_id)
if (active) return res.json(fail(2001, '已绑定设备', { device_id: active.device_id }))
const device = await bindingDao.findDeviceExists(deviceId)
if (!device) return res.json(fail(1005, 'DEVICE_NOT_FOUND'))
await bindingDao.mockBind(req.user.user_id, deviceId)
await logDao.write({ user_id: req.user.user_id, action: 'device_bind_confirm', detail: '模拟绑定设备: ' + deviceId, ip: req.ip })
res.json(ok({ message: 'success', device_id: deviceId }))
}))
router.post('/device/unbind', requireUser, wrap(async (req, res) => {
const deviceId = req.body.device_id || null
await bindingDao.unbindByUser(req.user.user_id, deviceId)
await logDao.write({ user_id: req.user.user_id, action: 'device_unbind', detail: '解绑设备: ' + (deviceId || 'current'), ip: req.ip })
res.json(ok({ message: 'success' }))
}))
router.get('/device/list', requireUser, wrap(async (req, res) => {
const devices = await deviceDao.listByUser(req.user.user_id)
res.json(ok({ devices, total: devices.length }))
}))
router.get('/device/command/pending', requireUser, wrap(async (req, res) => {
const deviceId = String(req.query.device_id || '').trim()
if (!deviceId) return res.json(fail(2001, 'device_id required'))
const active = await bindingDao.findActiveByUser(req.user.user_id)
if (!active || active.device_id !== deviceId) return res.json(fail(1006, 'DEVICE_NOT_BOUND'))
const commands = await commandDao.getPending(deviceId)
if (commands.length > 0) {
await commandDao.markPulled(commands.map(c => c.command_id))
}
res.json(ok({
commands: commands.map(c => ({
seq: c.command_id,
opcode: c.opcode,
payload: typeof c.payload_json === 'string' ? JSON.parse(c.payload_json) : c.payload_json || {}
}))
}))
}))
router.post('/device/command/result', requireUser, wrap(async (req, res) => {
const commandId = parseInt(req.body.command_id || req.body.seq, 10)
const success = req.body.success !== false
if (!commandId) return res.json(fail(2001, 'command_id required'))
// commandDao.finish verifies device ownership via user binding
await commandDao.finish(commandId, success, JSON.stringify(req.body), req.user.user_id)
res.json(ok({ message: 'success' }))
}))
router.post('/device/event', requireUser, wrap(async (req, res) => {
const deviceId = String(req.body.device_id || '').trim()
if (!deviceId) return res.json(fail(2001, 'device_id required'))
const active = await bindingDao.findActiveByUser(req.user.user_id)
if (!active || active.device_id !== deviceId) return res.json(fail(1006, 'device_not_bound'))
await deviceEventDao.create({
device_id: deviceId,
user_id: req.user.user_id,
event_type: req.body.event_type || 'device_error',
error_code: req.body.error_code || null,
temperature: req.body.temperature || null,
payload: req.body
})
await logDao.write({ user_id: req.user.user_id, action: 'device_event', detail: '设备事件: ' + deviceId, ip: req.ip })
res.json(ok({ message: 'ok' }))
}))
router.post('/api/v1/device/bind/confirm', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const deviceId = String(ctx.body.device_id || '').trim()
const bindToken = String(ctx.body.bind_token || '').trim()
if (!deviceId || !bindToken) return fail(2001, 'device_id and bind_token required')
router.get('/device/:device_id', requireUser, wrap(async (req, res) => {
const device = await deviceDao.findBoundDevice(req.user.user_id, req.params.device_id)
if (!device) return res.json(fail(1006, 'DEVICE_NOT_BOUND'))
res.json(ok(device))
}))
const updated = await transaction(async conn => {
const [rows] = await conn.execute(
'SELECT binding_id FROM bindings WHERE user_id = ? AND device_id = ? AND bind_token = ? AND bind_status = 3 AND bind_expires > NOW() LIMIT 1',
[user.user_id, deviceId, bindToken]
)
if (rows.length === 0) return false
await conn.execute('UPDATE bindings SET bind_status = 1, bind_time = NOW() WHERE binding_id = ?', [rows[0].binding_id])
await ensureTrial(conn, user.user_id)
return true
})
if (!updated) return fail(2001, 'bind_token invalid or expired')
await writeLog({ user_id: user.user_id, action: 'device_bind_confirm', detail: '确认绑定设备: ' + deviceId, ip: ctx.ip })
const sub = await one('SELECT plan, GREATEST(DATEDIFF(expire_time, NOW()), 0) AS remaining_days FROM subscriptions WHERE user_id = :user_id AND status = 1 AND expire_time > NOW() ORDER BY expire_time DESC LIMIT 1', { user_id: user.user_id })
return ok({ message: 'success', subscription: sub ? { plan: sub.plan, remaining_days: sub.remaining_days } : { plan: 'none', remaining_days: 0 } })
})
router.post('/api/v1/device/mock-bind', async ctx => {
const config = require('../config')
if (config.nodeEnv === 'production') return fail(2001, 'not available in production')
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const deviceId = String(ctx.body.device_id || '').trim()
if (!deviceId) return fail(2001, 'device_id required')
const result = await transaction(async conn => {
const [active] = await conn.execute('SELECT device_id FROM bindings WHERE user_id = ? AND bind_status = 1 LIMIT 1', [user.user_id])
if (active.length > 0) return { duplicated: true, device_id: active[0].device_id }
const [devices] = await conn.execute('SELECT * FROM devices WHERE device_id = ? AND status <> 4 LIMIT 1', [deviceId])
if (devices.length === 0) return { invalid: true }
await conn.execute('UPDATE bindings SET bind_status = 2 WHERE user_id = ? AND bind_status = 3', [user.user_id])
await conn.execute('INSERT INTO bindings (user_id, device_id, bind_token, bind_expires, bind_status, bind_time) VALUES (?, ?, ?, NOW(), 1, NOW())', [user.user_id, deviceId, 'mock'])
await ensureTrial(conn, user.user_id)
return { success: true }
})
if (result.invalid) return fail(1005, 'DEVICE_NOT_FOUND')
if (result.duplicated) return fail(2001, '已绑定设备', { device_id: result.device_id })
await writeLog({ user_id: user.user_id, action: 'device_bind_confirm', detail: '模拟绑定设备: ' + deviceId, ip: ctx.ip })
return ok({ message: 'success', device_id: deviceId })
})
router.post('/api/v1/device/unbind', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const deviceId = ctx.body.device_id || null
await query(
'UPDATE bindings SET bind_status = 2, unbind_time = NOW() WHERE user_id = :user_id AND bind_status = 1 AND (:device_id IS NULL OR device_id = :device_id)',
{ user_id: user.user_id, device_id: deviceId }
)
await writeLog({ user_id: user.user_id, action: 'device_unbind', detail: '解绑设备: ' + (deviceId || 'current'), ip: ctx.ip })
return ok({ message: 'success' })
})
router.get('/api/v1/device/list', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const devices = await query(
'SELECT d.device_id, d.device_name, d.status, d.battery, d.firmware_version, d.last_online_at, b.bind_time FROM bindings b JOIN devices d ON d.device_id = b.device_id WHERE b.user_id = :user_id AND b.bind_status = 1 ORDER BY b.bind_time DESC',
{ user_id: user.user_id }
)
return ok({ devices, total: devices.length })
})
router.get('/api/v1/device/command/pending', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const deviceId = String(ctx.query.device_id || '').trim()
if (!deviceId) return fail(2001, 'device_id required')
const bound = await one('SELECT binding_id FROM bindings WHERE user_id = :user_id AND device_id = :device_id AND bind_status = 1', { user_id: user.user_id, device_id: deviceId })
if (!bound) return fail(1006, 'DEVICE_NOT_BOUND')
const commands = await query('SELECT command_id, opcode, payload_json FROM device_commands WHERE device_id = :device_id AND status = 1 ORDER BY created_at ASC LIMIT 10', { device_id: deviceId })
if (commands.length > 0) {
await query('UPDATE device_commands SET status = 2, pulled_at = NOW() WHERE command_id IN (' + commands.map(c => Number(c.command_id)).join(',') + ')', {})
}
return ok({ commands: commands.map(c => ({ seq: c.command_id, opcode: c.opcode, payload: typeof c.payload_json === 'string' ? JSON.parse(c.payload_json) : c.payload_json || {} })) })
})
router.post('/api/v1/device/command/result', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const commandId = parseInt(ctx.body.command_id || ctx.body.seq, 10)
const success = ctx.body.success !== false
if (!commandId) return fail(2001, 'command_id required')
const cmd = await one('SELECT dc.command_id FROM device_commands dc JOIN bindings b ON b.device_id = dc.device_id AND b.user_id = :user_id AND b.bind_status = 1 WHERE dc.command_id = :command_id', { user_id: user.user_id, command_id: commandId })
if (!cmd) return fail(1006, 'device_not_bound')
await query('UPDATE device_commands SET status = :status, finished_at = NOW(), result_json = :result_json WHERE command_id = :command_id', {
command_id: commandId,
status: success ? 3 : 4,
result_json: JSON.stringify(ctx.body)
})
return ok({ message: 'success' })
})
router.get('/api/v1/device/:device_id', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const device = await one(
'SELECT d.device_id, d.device_name, d.status, d.battery, d.temperature, d.firmware_version, d.last_online_at, b.bind_time FROM bindings b JOIN devices d ON d.device_id = b.device_id WHERE b.user_id = :user_id AND b.bind_status = 1 AND b.device_id = :device_id',
{ user_id: user.user_id, device_id: ctx.params.device_id }
)
if (!device) return fail(1006, 'DEVICE_NOT_BOUND')
return ok(device)
})
router.post('/api/v1/device/event', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const deviceId = String(ctx.body.device_id || '').trim()
if (!deviceId) return fail(2001, 'device_id required')
const binding = await one('SELECT binding_id FROM bindings WHERE user_id = :user_id AND device_id = :device_id AND bind_status = 1', { user_id: user.user_id, device_id: deviceId })
if (!binding) return fail(1006, 'device_not_bound')
await query(
'INSERT INTO device_events (device_id, user_id, event_type, error_code, temperature, payload_json) VALUES (:device_id, :user_id, :event_type, :error_code, :temperature, :payload_json)',
{
device_id: deviceId,
user_id: user.user_id,
event_type: ctx.body.event_type || 'device_error',
error_code: ctx.body.error_code || null,
temperature: ctx.body.temperature || null,
payload_json: JSON.stringify(ctx.body)
}
)
await writeLog({ user_id: user.user_id, action: 'device_event', detail: '设备事件: ' + deviceId, ip: ctx.ip })
return ok({ message: 'ok' })
})
}
module.exports = register
module.exports = router
server/src/routes/firmware.js
+48 -57
查看文件
@@ -1,64 +1,55 @@
const { one, query } = require('../lib/db')
const router = require('express').Router()
const { ok, fail } = require('../lib/response')
const { requireUser, requireAdmin } = require('../lib/auth')
const { requireUser } = require('../middleware/auth')
const { requireAdmin } = require('../middleware/auth')
const { getObjectUrl } = require('../lib/cos')
const { writeLog } = require('../lib/log')
const firmwareDao = require('../dao/firmware.dao')
const logDao = require('../dao/log.dao')
function register(router) {
router.get('/api/v1/admin/firmware', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const rows = await query('SELECT firmware_id, version, device_type, cos_key, size_bytes, sha256, status, created_at FROM firmware_files ORDER BY created_at DESC', {})
return ok({ records: rows, total: rows.length })
const wrap = fn => (req, res, next) => fn(req, res, next).catch(next)
router.get('/admin/firmware', requireAdmin, wrap(async (req, res) => {
const rows = await firmwareDao.list()
res.json(ok({ records: rows, total: rows.length }))
}))
router.post('/admin/firmware', requireAdmin, wrap(async (req, res) => {
const version = String(req.body.version || '').trim()
const cosKey = String(req.body.cos_key || '').trim()
if (!version || !cosKey) return res.json(fail(2001, 'version and cos_key required'))
const insertId = await firmwareDao.create({
version,
device_type: req.body.device_type || '',
cos_key: cosKey,
size_bytes: Number(req.body.size_bytes || 0),
sha256: req.body.sha256 || '',
status: req.body.status === 0 ? 0 : 1
})
await logDao.write({ admin_id: req.admin.admin_id, action: 'admin_firmware_create', detail: '登记固件: ' + version, ip: req.ip })
res.json(ok({ firmware_id: insertId }))
}))
router.post('/api/v1/admin/firmware', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const version = String(ctx.body.version || '').trim()
const cosKey = String(ctx.body.cos_key || '').trim()
if (!version || !cosKey) return fail(2001, 'version and cos_key required')
const result = await query(
'INSERT INTO firmware_files (version, device_type, cos_key, size_bytes, sha256, status) VALUES (:version, :device_type, :cos_key, :size_bytes, :sha256, :status)',
{
version,
device_type: ctx.body.device_type || '',
cos_key: cosKey,
size_bytes: Number(ctx.body.size_bytes || 0),
sha256: ctx.body.sha256 || '',
status: ctx.body.status === 0 ? 0 : 1
}
)
await writeLog({ admin_id: admin.admin_id, action: 'admin_firmware_create', detail: '登记固件: ' + version, ip: ctx.ip })
return ok({ firmware_id: result.insertId })
})
router.post('/admin/firmware/:firmware_id/status', requireAdmin, wrap(async (req, res) => {
const firmwareId = parseInt(req.params.firmware_id, 10)
const status = Number(req.body.status) === 1 ? 1 : 0
if (!firmwareId) return res.json(fail(2001, 'firmware_id required'))
await firmwareDao.updateStatus(firmwareId, status)
await logDao.write({ admin_id: req.admin.admin_id, action: 'admin_firmware_status', detail: '更新固件状态: ' + firmwareId + ' -> ' + status, ip: req.ip })
res.json(ok({ message: 'success' }))
}))
router.post('/api/v1/admin/firmware/:firmware_id/status', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const firmwareId = parseInt(ctx.params.firmware_id, 10)
const status = Number(ctx.body.status) === 1 ? 1 : 0
if (!firmwareId) return fail(2001, 'firmware_id required')
await query('UPDATE firmware_files SET status = :status WHERE firmware_id = :firmware_id', { status, firmware_id: firmwareId })
await writeLog({ admin_id: admin.admin_id, action: 'admin_firmware_status', detail: '更新固件状态: ' + firmwareId + ' -> ' + status, ip: ctx.ip })
return ok({ message: 'success' })
})
router.get('/firmware/latest', requireUser, wrap(async (req, res) => {
const firmware = await firmwareDao.findLatest()
if (!firmware) return res.json(ok({ has_update: false }))
const currentVersion = req.query.current_version || ''
if (currentVersion && currentVersion === firmware.version) return res.json(ok({ has_update: false }))
res.json(ok({
has_update: true,
version: firmware.version,
size_bytes: firmware.size_bytes,
sha256: firmware.sha256,
download_url: await getObjectUrl(firmware.cos_key, 600)
}))
}))
router.get('/api/v1/firmware/latest', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const firmware = await one('SELECT * FROM firmware_files WHERE status = 1 ORDER BY created_at DESC LIMIT 1', {})
if (!firmware) return ok({ has_update: false })
const currentVersion = ctx.query.current_version || ''
if (currentVersion && currentVersion === firmware.version) return ok({ has_update: false })
return ok({
has_update: true,
version: firmware.version,
size_bytes: firmware.size_bytes,
sha256: firmware.sha256,
download_url: await getObjectUrl(firmware.cos_key, 600)
})
})
}
module.exports = register
module.exports = router
server/src/routes/subscription.js
+44 -50
查看文件
@@ -1,7 +1,11 @@
const { one, query, transaction } = require('../lib/db')
const router = require('express').Router()
const { ok, fail } = require('../lib/response')
const { requireUser, requireAdmin } = require('../lib/auth')
const { writeLog } = require('../lib/log')
const { requireUser } = require('../middleware/auth')
const { requireAdmin } = require('../middleware/auth')
const subscriptionDao = require('../dao/subscription.dao')
const logDao = require('../dao/log.dao')
const wrap = fn => (req, res, next) => fn(req, res, next).catch(next)
const PLANS = {
trial: { amount: 0, days: 7 },
@@ -9,54 +13,44 @@ const PLANS = {
yearly: { amount: 899, days: 365 }
}
function register(router) {
router.get('/api/v1/subscription', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const sub = await one('SELECT *, GREATEST(DATEDIFF(expire_time, NOW()), 0) AS remaining_days FROM subscriptions WHERE user_id = :user_id AND status = 1 ORDER BY expire_time DESC LIMIT 1', { user_id: user.user_id })
if (!sub) return ok({ status: 'inactive', plan: 'none', remaining_days: 0 })
return ok({ status: sub.remaining_days > 0 ? 'active' : 'expired', plan: sub.plan, start_time: sub.start_time, expire_time: sub.expire_time, remaining_days: sub.remaining_days })
})
router.get('/subscription', requireUser, wrap(async (req, res) => {
const sub = await subscriptionDao.findActive(req.user.user_id)
if (!sub) return res.json(ok({ status: 'inactive', plan: 'none', remaining_days: 0 }))
res.json(ok({
status: sub.remaining_days > 0 ? 'active' : 'expired',
plan: sub.plan,
start_time: sub.start_time,
expire_time: sub.expire_time,
remaining_days: sub.remaining_days
}))
}))
router.post('/api/v1/subscription/purchase', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const plan = ctx.body.plan || ctx.body.plan_type
if (!PLANS[plan]) return fail(2001, 'invalid plan')
const orderId = 'ORD' + Date.now()
return ok({ order_id: orderId, payment_params: {}, plan, amount: PLANS[plan].amount })
})
router.post('/subscription/purchase', requireUser, wrap(async (req, res) => {
const plan = req.body.plan || req.body.plan_type
if (!PLANS[plan]) return res.json(fail(2001, 'invalid plan'))
const orderId = 'ORD' + Date.now()
res.json(ok({ order_id: orderId, payment_params: {}, plan, amount: PLANS[plan].amount }))
}))
router.post('/api/v1/subscription/trial', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const usedTrial = await one('SELECT subscription_id FROM subscriptions WHERE user_id = :user_id AND plan = \'trial\' LIMIT 1', { user_id: user.user_id })
if (usedTrial) return fail(2001, '已使用过试用')
const activeSub = await one('SELECT subscription_id FROM subscriptions WHERE user_id = :user_id AND status = 1 LIMIT 1', { user_id: user.user_id })
if (activeSub) return fail(2001, '已有有效订阅')
const orderId = 'TRIAL' + Date.now()
await query('INSERT INTO subscriptions (user_id, plan, status, amount, order_id, start_time, expire_time) VALUES (:user_id, \'trial\', 1, 0, :order_id, NOW(), DATE_ADD(NOW(), INTERVAL 7 DAY))', { user_id: user.user_id, order_id: orderId })
return ok({ status: 'active', plan: 'trial', remaining_days: 7 })
})
router.post('/subscription/trial', requireUser, wrap(async (req, res) => {
const usedTrial = await subscriptionDao.findTrial(req.user.user_id)
if (usedTrial) return res.json(fail(2001, '已使用过试用'))
const activeSub = await subscriptionDao.findActive(req.user.user_id)
if (activeSub) return res.json(fail(2001, '已有有效订阅'))
await subscriptionDao.createTrial(req.user.user_id)
res.json(ok({ status: 'active', plan: 'trial', remaining_days: 7 }))
}))
// Temporary: admin-only until payment integration
router.post('/api/v1/subscription/verify', async ctx => {
const admin = await requireAdmin(ctx)
if (!admin) return fail(1002, '未授权，请重新登录')
const userId = ctx.body.user_id
if (!userId) return fail(2001, 'user_id required')
const plan = ctx.body.plan || ctx.body.plan_type || 'monthly'
if (!PLANS[plan]) return fail(2001, 'invalid plan')
const p = PLANS[plan]
await transaction(async conn => {
await conn.execute('UPDATE subscriptions SET status = 2 WHERE user_id = ? AND status = 1', [userId])
await conn.execute('INSERT INTO subscriptions (user_id, plan, status, amount, order_id, start_time, expire_time) VALUES (?, ?, 1, ?, ?, NOW(), DATE_ADD(NOW(), INTERVAL ? DAY))', [
userId, plan, p.amount, ctx.body.order_id || 'ORD' + Date.now(), p.days
])
})
await writeLog({ admin_id: admin.admin_id, action: 'subscription_verify', detail: '订阅生效: ' + plan + ' user:' + userId, ip: ctx.ip })
return ok({ status: 'active', plan, remaining_days: p.days })
})
}
// Temporary: admin-only until payment integration
router.post('/subscription/verify', requireAdmin, wrap(async (req, res) => {
const userId = req.body.user_id
if (!userId) return res.json(fail(2001, 'user_id required'))
const plan = req.body.plan || req.body.plan_type || 'monthly'
if (!PLANS[plan]) return res.json(fail(2001, 'invalid plan'))
const p = PLANS[plan]
await subscriptionDao.purchase(userId, plan, p.amount, req.body.order_id || 'ORD' + Date.now(), p.days)
await logDao.write({ admin_id: req.admin.admin_id, action: 'subscription_verify', detail: '订阅生效: ' + plan + ' user:' + userId, ip: req.ip })
res.json(ok({ status: 'active', plan, remaining_days: p.days }))
}))
module.exports = register
module.exports = router
server/src/routes/treatment.js
+51 -61
查看文件
@@ -1,68 +1,58 @@
const { one, query, limitClause } = require('../lib/db')
const router = require('express').Router()
const { ok, fail } = require('../lib/response')
const { requireUser } = require('../lib/auth')
const { writeLog } = require('../lib/log')
const { requireUser } = require('../middleware/auth')
const { toMysqlDate } = require('../lib/utils')
const treatmentDao = require('../dao/treatment.dao')
const bindingDao = require('../dao/binding.dao')
const logDao = require('../dao/log.dao')
function register(router) {
const wrap = fn => (req, res, next) => fn(req, res, next).catch(next)
router.get('/api/v1/treatment/history', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const page = Math.max(1, parseInt(ctx.query.page, 10) || 1)
const pageSize = Math.min(Math.max(1, parseInt(ctx.query.page_size, 10) || 20), 100)
const offset = (page - 1) * pageSize
const total = await query('SELECT COUNT(*) AS total FROM treatment_records WHERE user_id = :user_id', { user_id: user.user_id })
const records = await query('SELECT * FROM treatment_records WHERE user_id = :user_id ORDER BY created_at DESC' + limitClause(pageSize, offset), { user_id: user.user_id })
return ok({ total: total[0].total, page, page_size: pageSize, records })
router.get('/treatment/history', requireUser, wrap(async (req, res) => {
const page = Math.max(1, parseInt(req.query.page, 10) || 1)
const pageSize = Math.min(Math.max(1, parseInt(req.query.page_size, 10) || 20), 100)
const offset = (page - 1) * pageSize
const { records, total } = await treatmentDao.listByUser(req.user.user_id, { pageSize, offset })
res.json(ok({ total, page, page_size: pageSize, records }))
}))
router.post('/treatment/sync', requireUser, wrap(async (req, res) => {
const d = req.body || {}
if (!d.device_id) return res.json(fail(2001, 'device_id required'))
const active = await bindingDao.findActiveByUser(req.user.user_id)
if (!active || active.device_id !== d.device_id) return res.json(fail(1006, 'device_not_bound'))
const sessionId = d.session_id || 'SESS' + Date.now()
await treatmentDao.create({
session_id: sessionId,
device_id: d.device_id,
user_id: req.user.user_id,
start_time: toMysqlDate(d.start_time),
end_time: toMysqlDate(d.end_time),
regions: Array.isArray(d.regions) ? d.regions.join(',') : String(d.regions || ''),
total_duration_ms: parseInt(d.total_duration_ms, 10) || 0,
mode: parseInt(d.mode, 10) || 0,
avg_pd: Number(d.avg_pd) || 0,
battery: d.battery == null ? null : parseInt(d.battery, 10),
temperature: d.temperature == null ? null : parseInt(d.temperature, 10),
wavelength: d.wavelength == null ? null : parseInt(d.wavelength, 10),
brightness: d.brightness == null ? null : parseInt(d.brightness, 10),
pd_json: JSON.stringify(d.pd_values || {})
})
await treatmentDao.updateDevice(
d.device_id,
d.battery == null ? null : parseInt(d.battery, 10),
d.temperature == null ? null : parseInt(d.temperature, 10)
)
await logDao.write({ user_id: req.user.user_id, action: 'treatment_sync', detail: '同步护理记录: ' + sessionId, ip: req.ip })
res.json(ok({ record_id: sessionId }))
}))
router.post('/api/v1/treatment/sync', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const d = ctx.body || {}
if (!d.device_id) return fail(2001, 'device_id required')
const binding = await one('SELECT binding_id FROM bindings WHERE user_id = :user_id AND device_id = :device_id AND bind_status = 1', { user_id: user.user_id, device_id: d.device_id })
if (!binding) return fail(1006, 'device_not_bound')
const sessionId = d.session_id || 'SESS' + Date.now()
await query(
`INSERT INTO treatment_records
(session_id, device_id, user_id, start_time, end_time, regions, total_duration_ms, mode, avg_pd, battery, temperature, wavelength, brightness, pd_json)
VALUES (:session_id, :device_id, :user_id, :start_time, :end_time, :regions, :total_duration_ms, :mode, :avg_pd, :battery, :temperature, :wavelength, :brightness, :pd_json)
ON DUPLICATE KEY UPDATE end_time = VALUES(end_time), total_duration_ms = VALUES(total_duration_ms), avg_pd = VALUES(avg_pd), battery = VALUES(battery), temperature = VALUES(temperature), pd_json = VALUES(pd_json)`,
{
session_id: sessionId,
device_id: d.device_id,
user_id: user.user_id,
start_time: toMysqlDate(d.start_time),
end_time: toMysqlDate(d.end_time),
regions: Array.isArray(d.regions) ? d.regions.join(',') : String(d.regions || ''),
total_duration_ms: parseInt(d.total_duration_ms, 10) || 0,
mode: parseInt(d.mode, 10) || 0,
avg_pd: Number(d.avg_pd) || 0,
battery: d.battery == null ? null : parseInt(d.battery, 10),
temperature: d.temperature == null ? null : parseInt(d.temperature, 10),
wavelength: d.wavelength == null ? null : parseInt(d.wavelength, 10),
brightness: d.brightness == null ? null : parseInt(d.brightness, 10),
pd_json: JSON.stringify(d.pd_values || {})
}
)
await query('UPDATE devices SET battery = COALESCE(:battery, battery), temperature = COALESCE(:temperature, temperature), last_online_at = NOW() WHERE device_id = :device_id', {
device_id: d.device_id,
battery: d.battery == null ? null : parseInt(d.battery, 10),
temperature: d.temperature == null ? null : parseInt(d.temperature, 10)
})
await writeLog({ user_id: user.user_id, action: 'treatment_sync', detail: '同步护理记录: ' + sessionId, ip: ctx.ip })
return ok({ record_id: sessionId })
})
router.get('/treatment/:record_id', requireUser, wrap(async (req, res) => {
const record = await treatmentDao.findBySession(req.params.record_id, req.user.user_id)
if (!record) return res.json(fail(1005, 'record_not_found'))
res.json(ok(record))
}))
router.get('/api/v1/treatment/:record_id', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const record = await one('SELECT * FROM treatment_records WHERE session_id = :session_id AND user_id = :user_id', { session_id: ctx.params.record_id, user_id: user.user_id })
if (!record) return fail(1005, 'record_not_found')
return ok(record)
})
}
module.exports = register
module.exports = router
server/src/routes/user.js
+39 -46
查看文件
@@ -1,52 +1,45 @@
const { query } = require('../lib/db')
const router = require('express').Router()
const { ok, fail } = require('../lib/response')
const { requireUser } = require('../lib/auth')
const { writeLog } = require('../lib/log')
const { requireUser } = require('../middleware/auth')
const { getPhoneNumber } = require('../lib/wechat')
const userDao = require('../dao/user.dao')
const deviceDao = require('../dao/device.dao')
const logDao = require('../dao/log.dao')
function register(router) {
router.get('/api/v1/user/profile', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const binds = await query('SELECT COUNT(*) AS total FROM bindings WHERE user_id = :user_id AND bind_status = 1', { user_id: user.user_id })
return ok({
user_id: String(user.user_id),
nickname: user.nickname || '用户' + String(user.user_id),
avatar: user.avatar || '',
phone: user.phone || '',
gender: user.gender || 0,
bind_time: null,
device_count: binds[0].total
})
const wrap = fn => (req, res, next) => fn(req, res, next).catch(next)
router.get('/user/profile', requireUser, wrap(async (req, res) => {
const user = req.user
const devices = await deviceDao.listByUser(user.user_id)
res.json(ok({
user_id: String(user.user_id),
nickname: user.nickname || '用户' + String(user.user_id),
avatar: user.avatar || '',
phone: user.phone || '',
gender: user.gender || 0,
bind_time: null,
device_count: devices.length
}))
}))
router.put('/user/profile', requireUser, wrap(async (req, res) => {
await userDao.updateProfile(req.user.user_id, {
nickname: req.body.nickname || null,
avatar: req.body.avatar || req.body.avatar_url || null,
gender: req.body.gender === undefined ? null : req.body.gender
})
await logDao.write({ user_id: req.user.user_id, action: 'user_update', detail: '更新用户资料', ip: req.ip })
res.json(ok({ message: 'success' }))
}))
router.put('/api/v1/user/profile', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
await query('UPDATE users SET nickname = COALESCE(:nickname, nickname), avatar = COALESCE(:avatar, avatar), gender = COALESCE(:gender, gender) WHERE user_id = :user_id', {
user_id: user.user_id,
nickname: ctx.body.nickname || null,
avatar: ctx.body.avatar || ctx.body.avatar_url || null,
gender: ctx.body.gender === undefined ? null : ctx.body.gender
})
await writeLog({ user_id: user.user_id, action: 'user_update', detail: '更新用户资料', ip: ctx.ip })
return ok({ message: 'success' })
})
router.post('/user/phone', requireUser, wrap(async (req, res) => {
const code = String(req.body.code || '').trim()
if (!code) return res.json(fail(2001, 'phone code required'))
const phoneInfo = await getPhoneNumber(code)
if (!phoneInfo || !phoneInfo.phoneNumber) return res.json(fail(2001, 'phone authorization failed'))
await userDao.updatePhone(req.user.user_id, phoneInfo.phoneNumber)
await logDao.write({ user_id: req.user.user_id, action: 'user_phone_bind', detail: '授权手机号', ip: req.ip })
res.json(ok({ phone: phoneInfo.phoneNumber, pure_phone_number: phoneInfo.purePhoneNumber || '', country_code: phoneInfo.countryCode || '' }))
}))
router.post('/api/v1/user/phone', async ctx => {
const user = await requireUser(ctx)
if (!user) return fail(1001, 'invalid_token')
const code = String(ctx.body.code || '').trim()
if (!code) return fail(2001, 'phone code required')
const phoneInfo = await getPhoneNumber(code)
if (!phoneInfo || !phoneInfo.phoneNumber) return fail(2001, 'phone authorization failed')
await query('UPDATE users SET phone = :phone WHERE user_id = :user_id', {
user_id: user.user_id,
phone: phoneInfo.phoneNumber
})
await writeLog({ user_id: user.user_id, action: 'user_phone_bind', detail: '授权手机号', ip: ctx.ip })
return ok({ phone: phoneInfo.phoneNumber, pure_phone_number: phoneInfo.purePhoneNumber || '', country_code: phoneInfo.countryCode || '' })
})
}
module.exports = register
module.exports = router