476 lines
14 KiB
TypeScript
476 lines
14 KiB
TypeScript
/**
|
|
* 书籍内容数据库API
|
|
* 支持完整的CRUD操作 - 读取/写入/修改/删除章节
|
|
* 同时支持文件系统和数据库双写
|
|
*/
|
|
|
|
import { NextRequest, NextResponse } from 'next/server'
|
|
import { query } from '@/lib/db'
|
|
import fs from 'fs'
|
|
import path from 'path'
|
|
import { bookData } from '@/lib/book-data'
|
|
|
|
// 获取章节内容（从数据库或文件系统）
|
|
async function getSectionContent(id: string): Promise<{content: string, source: 'db' | 'file'} | null> {
|
|
try {
|
|
// 先从数据库查询
|
|
const results = await query(
|
|
'SELECT content, section_title FROM chapters WHERE id = ?',
|
|
[id]
|
|
) as any[]
|
|
|
|
if (results.length > 0 && results[0].content) {
|
|
return { content: results[0].content, source: 'db' }
|
|
}
|
|
} catch (e) {
|
|
console.log('[Book API] 数据库查询失败，尝试从文件读取:', e)
|
|
}
|
|
|
|
// 从文件系统读取
|
|
const filePath = findSectionFilePath(id)
|
|
if (filePath && fs.existsSync(filePath)) {
|
|
try {
|
|
const content = fs.readFileSync(filePath, 'utf-8')
|
|
return { content, source: 'file' }
|
|
} catch (e) {
|
|
console.error('[Book API] 读取文件失败:', e)
|
|
}
|
|
}
|
|
|
|
return null
|
|
}
|
|
|
|
// 根据section ID查找对应的文件路径
|
|
function findSectionFilePath(id: string): string | null {
|
|
for (const part of bookData) {
|
|
for (const chapter of part.chapters) {
|
|
const section = chapter.sections.find(s => s.id === id)
|
|
if (section?.filePath) {
|
|
return path.join(process.cwd(), section.filePath)
|
|
}
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
|
|
// 获取section的完整信息
|
|
function getSectionInfo(id: string) {
|
|
for (const part of bookData) {
|
|
for (const chapter of part.chapters) {
|
|
const section = chapter.sections.find(s => s.id === id)
|
|
if (section) {
|
|
return {
|
|
section,
|
|
chapter,
|
|
part,
|
|
partId: part.id,
|
|
chapterId: chapter.id,
|
|
partTitle: part.title,
|
|
chapterTitle: chapter.title
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
|
|
/**
|
|
* GET - 读取章节内容
|
|
* 支持参数:
|
|
* - id: 章节ID
|
|
* - action: 'read' | 'export' | 'list'
|
|
*/
|
|
export async function GET(request: NextRequest) {
|
|
const { searchParams } = new URL(request.url)
|
|
const action = searchParams.get('action') || 'read'
|
|
const id = searchParams.get('id')
|
|
|
|
try {
|
|
// 读取单个章节
|
|
if (action === 'read' && id) {
|
|
const result = await getSectionContent(id)
|
|
const sectionInfo = getSectionInfo(id)
|
|
|
|
if (result) {
|
|
return NextResponse.json({
|
|
success: true,
|
|
section: {
|
|
id,
|
|
content: result.content,
|
|
source: result.source,
|
|
title: sectionInfo?.section.title || '',
|
|
price: sectionInfo?.section.price || 1,
|
|
partTitle: sectionInfo?.partTitle,
|
|
chapterTitle: sectionInfo?.chapterTitle
|
|
}
|
|
})
|
|
} else {
|
|
return NextResponse.json({
|
|
success: false,
|
|
error: '章节不存在或无法读取'
|
|
}, { status: 404 })
|
|
}
|
|
}
|
|
|
|
// 导出所有章节
|
|
if (action === 'export') {
|
|
const sections: any[] = []
|
|
|
|
for (const part of bookData) {
|
|
for (const chapter of part.chapters) {
|
|
for (const section of chapter.sections) {
|
|
const content = await getSectionContent(section.id)
|
|
sections.push({
|
|
id: section.id,
|
|
title: section.title,
|
|
price: section.price,
|
|
isFree: section.isFree,
|
|
partId: part.id,
|
|
partTitle: part.title,
|
|
chapterId: chapter.id,
|
|
chapterTitle: chapter.title,
|
|
content: content?.content || '',
|
|
source: content?.source || 'none'
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
const blob = JSON.stringify(sections, null, 2)
|
|
return new NextResponse(blob, {
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Content-Disposition': `attachment; filename="book_sections_${new Date().toISOString().split('T')[0]}.json"`
|
|
}
|
|
})
|
|
}
|
|
|
|
// 列出所有章节（不含内容）
|
|
// 优先从数据库读取，确保新建章节能立即显示
|
|
if (action === 'list') {
|
|
const sectionsFromDb = new Map<string, any>()
|
|
try {
|
|
const rows = await query(`
|
|
SELECT id, part_id, part_title, chapter_id, chapter_title, section_title,
|
|
price, is_free, content
|
|
FROM chapters ORDER BY part_id, chapter_id, id
|
|
`) as any[]
|
|
if (rows && rows.length > 0) {
|
|
for (const r of rows) {
|
|
sectionsFromDb.set(r.id, {
|
|
id: r.id,
|
|
title: r.section_title || '',
|
|
price: r.price ?? 1,
|
|
isFree: !!r.is_free,
|
|
partId: r.part_id || 'part-1',
|
|
partTitle: r.part_title || '',
|
|
chapterId: r.chapter_id || 'chapter-1',
|
|
chapterTitle: r.chapter_title || '',
|
|
filePath: ''
|
|
})
|
|
}
|
|
}
|
|
} catch (e) {
|
|
console.log('[Book API] list 从数据库读取失败，回退到 bookData:', (e as Error).message)
|
|
}
|
|
// 合并：以数据库为准，数据库没有的用 bookData 补
|
|
const sections: any[] = []
|
|
for (const part of bookData) {
|
|
for (const chapter of part.chapters) {
|
|
for (const section of chapter.sections) {
|
|
const dbRow = sectionsFromDb.get(section.id)
|
|
sections.push(dbRow || {
|
|
id: section.id,
|
|
title: section.title,
|
|
price: section.price,
|
|
isFree: section.isFree,
|
|
partId: part.id,
|
|
partTitle: part.title,
|
|
chapterId: chapter.id,
|
|
chapterTitle: chapter.title,
|
|
filePath: section.filePath
|
|
})
|
|
sectionsFromDb.delete(section.id)
|
|
}
|
|
}
|
|
}
|
|
// 数据库有但 bookData 没有的（新建章节）
|
|
for (const [, v] of sectionsFromDb) {
|
|
sections.push(v)
|
|
}
|
|
// 按 id 去重，避免数据库重复或合并逻辑导致同一文章出现多次
|
|
const seen = new Set<string>()
|
|
const deduped = sections.filter((s) => {
|
|
if (seen.has(s.id)) return false
|
|
seen.add(s.id)
|
|
return true
|
|
})
|
|
return NextResponse.json({
|
|
success: true,
|
|
sections: deduped,
|
|
total: deduped.length
|
|
})
|
|
}
|
|
|
|
return NextResponse.json({
|
|
success: false,
|
|
error: '无效的操作或缺少参数'
|
|
}, { status: 400 })
|
|
|
|
} catch (error) {
|
|
console.error('[Book API] GET错误:', error)
|
|
return NextResponse.json({
|
|
success: false,
|
|
error: '获取章节失败: ' + (error as Error).message
|
|
}, { status: 500 })
|
|
}
|
|
}
|
|
|
|
/**
|
|
* POST - 同步/导入章节
|
|
* 支持action:
|
|
* - sync: 同步文件系统到数据库
|
|
* - import: 批量导入章节数据
|
|
*/
|
|
export async function POST(request: NextRequest) {
|
|
try {
|
|
const body = await request.json()
|
|
const { action, data } = body
|
|
|
|
// 同步到数据库
|
|
if (action === 'sync') {
|
|
let synced = 0
|
|
let failed = 0
|
|
|
|
for (const part of bookData) {
|
|
for (const chapter of part.chapters) {
|
|
for (const section of chapter.sections) {
|
|
try {
|
|
const filePath = path.join(process.cwd(), section.filePath)
|
|
let content = ''
|
|
|
|
if (fs.existsSync(filePath)) {
|
|
content = fs.readFileSync(filePath, 'utf-8')
|
|
}
|
|
|
|
// 插入或更新到数据库
|
|
await query(`
|
|
INSERT INTO chapters (id, part_id, part_title, chapter_id, chapter_title, section_title, content, word_count, is_free, price, sort_order, status)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'published')
|
|
ON DUPLICATE KEY UPDATE
|
|
part_title = VALUES(part_title),
|
|
chapter_title = VALUES(chapter_title),
|
|
section_title = VALUES(section_title),
|
|
content = VALUES(content),
|
|
word_count = VALUES(word_count),
|
|
is_free = VALUES(is_free),
|
|
price = VALUES(price),
|
|
updated_at = CURRENT_TIMESTAMP
|
|
`, [
|
|
section.id,
|
|
part.id,
|
|
part.title,
|
|
chapter.id,
|
|
chapter.title,
|
|
section.title,
|
|
content,
|
|
content.length,
|
|
section.isFree,
|
|
section.price,
|
|
synced
|
|
])
|
|
|
|
synced++
|
|
} catch (e) {
|
|
console.error(`[Book API] 同步章节${section.id}失败:`, e)
|
|
failed++
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return NextResponse.json({
|
|
success: true,
|
|
message: `同步完成：成功 ${synced} 个章节，失败 ${failed} 个`,
|
|
synced,
|
|
failed
|
|
})
|
|
}
|
|
|
|
// 导入数据
|
|
if (action === 'import' && data) {
|
|
let imported = 0
|
|
let failed = 0
|
|
|
|
for (const item of data) {
|
|
try {
|
|
await query(`
|
|
INSERT INTO chapters (id, part_id, part_title, chapter_id, chapter_title, section_title, content, word_count, is_free, price, status)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'published')
|
|
ON DUPLICATE KEY UPDATE
|
|
section_title = VALUES(section_title),
|
|
content = VALUES(content),
|
|
word_count = VALUES(word_count),
|
|
is_free = VALUES(is_free),
|
|
price = VALUES(price),
|
|
updated_at = CURRENT_TIMESTAMP
|
|
`, [
|
|
item.id,
|
|
item.partId || 'part-1',
|
|
item.partTitle || '未分类',
|
|
item.chapterId || 'chapter-1',
|
|
item.chapterTitle || '未分类',
|
|
item.title,
|
|
item.content || '',
|
|
(item.content || '').length,
|
|
item.is_free || false,
|
|
item.price || 1
|
|
])
|
|
imported++
|
|
} catch (e) {
|
|
console.error(`[Book API] 导入章节${item.id}失败:`, e)
|
|
failed++
|
|
}
|
|
}
|
|
|
|
return NextResponse.json({
|
|
success: true,
|
|
message: `导入完成：成功 ${imported} 个章节，失败 ${failed} 个`,
|
|
imported,
|
|
failed
|
|
})
|
|
}
|
|
|
|
return NextResponse.json({
|
|
success: false,
|
|
error: '无效的操作'
|
|
}, { status: 400 })
|
|
|
|
} catch (error) {
|
|
console.error('[Book API] POST错误:', error)
|
|
return NextResponse.json({
|
|
success: false,
|
|
error: '操作失败: ' + (error as Error).message
|
|
}, { status: 500 })
|
|
}
|
|
}
|
|
|
|
/**
|
|
* PUT - 更新章节内容
|
|
* 支持同时更新数据库和文件系统
|
|
*/
|
|
export async function PUT(request: NextRequest) {
|
|
try {
|
|
const body = await request.json()
|
|
const { id, title, content, price, saveToFile = true, partId, chapterId, partTitle, chapterTitle, isFree } = body
|
|
|
|
if (!id) {
|
|
return NextResponse.json({
|
|
success: false,
|
|
error: '章节ID不能为空'
|
|
}, { status: 400 })
|
|
}
|
|
|
|
const sectionInfo = getSectionInfo(id)
|
|
const finalPartId = partId || sectionInfo?.partId || 'part-1'
|
|
const finalPartTitle = partTitle || sectionInfo?.partTitle || '未分类'
|
|
const finalChapterId = chapterId || sectionInfo?.chapterId || 'chapter-1'
|
|
const finalChapterTitle = chapterTitle || sectionInfo?.chapterTitle || '未分类'
|
|
const finalPrice = price ?? sectionInfo?.section?.price ?? 1
|
|
const finalIsFree = isFree ?? sectionInfo?.section?.isFree ?? false
|
|
|
|
// 更新数据库（含新建章节）
|
|
try {
|
|
await query(`
|
|
INSERT INTO chapters (id, part_id, part_title, chapter_id, chapter_title, section_title, content, word_count, is_free, price, status)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'published')
|
|
ON DUPLICATE KEY UPDATE
|
|
part_id = VALUES(part_id),
|
|
part_title = VALUES(part_title),
|
|
chapter_id = VALUES(chapter_id),
|
|
chapter_title = VALUES(chapter_title),
|
|
section_title = VALUES(section_title),
|
|
content = VALUES(content),
|
|
word_count = VALUES(word_count),
|
|
is_free = VALUES(is_free),
|
|
price = VALUES(price),
|
|
updated_at = CURRENT_TIMESTAMP
|
|
`, [
|
|
id,
|
|
finalPartId,
|
|
finalPartTitle,
|
|
finalChapterId,
|
|
finalChapterTitle,
|
|
title || sectionInfo?.section?.title || '',
|
|
content || '',
|
|
(content || '').length,
|
|
finalIsFree,
|
|
finalPrice
|
|
])
|
|
} catch (e) {
|
|
console.error('[Book API] 更新数据库失败:', e)
|
|
}
|
|
|
|
// 同时保存到文件系统
|
|
if (saveToFile && sectionInfo?.section.filePath) {
|
|
const filePath = path.join(process.cwd(), sectionInfo.section.filePath)
|
|
try {
|
|
// 确保目录存在
|
|
const dir = path.dirname(filePath)
|
|
if (!fs.existsSync(dir)) {
|
|
fs.mkdirSync(dir, { recursive: true })
|
|
}
|
|
fs.writeFileSync(filePath, content || '', 'utf-8')
|
|
} catch (e) {
|
|
console.error('[Book API] 保存文件失败:', e)
|
|
}
|
|
}
|
|
|
|
return NextResponse.json({
|
|
success: true,
|
|
message: '章节更新成功',
|
|
id
|
|
})
|
|
|
|
} catch (error) {
|
|
console.error('[Book API] PUT错误:', error)
|
|
return NextResponse.json({
|
|
success: false,
|
|
error: '更新章节失败: ' + (error as Error).message
|
|
}, { status: 500 })
|
|
}
|
|
}
|
|
|
|
/**
|
|
* DELETE - 删除章节
|
|
*/
|
|
export async function DELETE(request: NextRequest) {
|
|
const { searchParams } = new URL(request.url)
|
|
const id = searchParams.get('id')
|
|
|
|
if (!id) {
|
|
return NextResponse.json({
|
|
success: false,
|
|
error: '章节ID不能为空'
|
|
}, { status: 400 })
|
|
}
|
|
|
|
try {
|
|
// 从数据库删除
|
|
await query('DELETE FROM chapters WHERE id = ?', [id])
|
|
|
|
return NextResponse.json({
|
|
success: true,
|
|
message: '章节删除成功',
|
|
id
|
|
})
|
|
|
|
} catch (error) {
|
|
console.error('[Book API] DELETE错误:', error)
|
|
return NextResponse.json({
|
|
success: false,
|
|
error: '删除章节失败: ' + (error as Error).message
|
|
}, { status: 500 })
|
|
}
|
|
}
|