mirror of
https://github.com/dqzboy/Docker-Proxy.git
synced 2026-07-04 15:05:23 +08:00
dqzboy
959 lines
39 KiB
JavaScript
959 lines
39 KiB
JavaScript
/**
|
|
* 文档管理模块
|
|
*/
|
|
|
|
// 文档列表
|
|
let documents = [];
|
|
// 当前正在编辑的文档
|
|
let currentDocument = null;
|
|
// Markdown编辑器实例
|
|
let editorMd = null;
|
|
|
|
// 创建documentManager对象
|
|
const documentManager = {
|
|
// 初始化文档管理
|
|
init: function() {
|
|
console.log('初始化文档管理模块...');
|
|
// 渲染表头
|
|
this.renderDocumentTableHeader();
|
|
// 加载文档列表
|
|
return this.loadDocuments().catch(err => {
|
|
console.error('加载文档列表失败:', err);
|
|
return Promise.resolve(); // 即使失败也继续初始化过程
|
|
});
|
|
},
|
|
|
|
// 渲染文档表格头部
|
|
renderDocumentTableHeader: function() {
|
|
try {
|
|
const documentTable = document.getElementById('documentTable');
|
|
if (!documentTable) {
|
|
console.warn('文档管理表格元素 (id=\"documentTable\") 未找到，无法渲染表头。');
|
|
return;
|
|
}
|
|
|
|
// 查找或创建 thead
|
|
let thead = documentTable.querySelector('thead');
|
|
if (!thead) {
|
|
thead = document.createElement('thead');
|
|
documentTable.insertBefore(thead, documentTable.firstChild); // 确保 thead 在 tbody 之前
|
|
console.log('创建了文档表格的 thead 元素。');
|
|
}
|
|
|
|
// 设置表头内容 (包含 ID 列)
|
|
thead.innerHTML = `
|
|
<tr>
|
|
<th style="width: 5%">#</th>
|
|
<th style="width: 25%">标题</th>
|
|
<th style="width: 20%">创建时间</th>
|
|
<th style="width: 20%">更新时间</th>
|
|
<th style="width: 10%">状态</th>
|
|
<th style="width: 20%">操作</th>
|
|
</tr>
|
|
`;
|
|
console.log('文档表格表头已渲染。');
|
|
} catch (error) {
|
|
console.error('渲染文档表格表头时出错:', error);
|
|
}
|
|
},
|
|
|
|
// 加载文档列表
|
|
loadDocuments: async function() {
|
|
try {
|
|
// 显示加载状态
|
|
const documentTableBody = document.getElementById('documentTableBody');
|
|
if (documentTableBody) {
|
|
documentTableBody.innerHTML = '<tr><td colspan="6" style="text-align: center;"><i class="fas fa-spinner fa-spin"></i> 正在加载文档列表...</td></tr>';
|
|
}
|
|
|
|
// 简化会话检查逻辑，只验证会话是否有效
|
|
let sessionValid = true;
|
|
try {
|
|
const sessionResponse = await fetch('/api/check-session', {
|
|
headers: {
|
|
'Cache-Control': 'no-cache',
|
|
'X-Requested-With': 'XMLHttpRequest'
|
|
},
|
|
credentials: 'same-origin'
|
|
});
|
|
|
|
if (sessionResponse.status === 401) {
|
|
console.warn('会话已过期，无法加载文档');
|
|
sessionValid = false;
|
|
}
|
|
} catch (sessionError) {
|
|
console.warn('检查会话状态发生网络错误:', sessionError);
|
|
// 发生网络错误时继续尝试加载文档
|
|
}
|
|
|
|
// 尝试不同的API路径
|
|
const possiblePaths = [
|
|
'/api/documents',
|
|
'/api/documentation-list',
|
|
'/api/documentation'
|
|
];
|
|
|
|
let success = false;
|
|
let authError = false;
|
|
|
|
for (const path of possiblePaths) {
|
|
try {
|
|
console.log(`尝试从 ${path} 获取文档列表`);
|
|
const response = await fetch(path, {
|
|
credentials: 'same-origin',
|
|
headers: {
|
|
'Cache-Control': 'no-cache',
|
|
'X-Requested-With': 'XMLHttpRequest'
|
|
}
|
|
});
|
|
|
|
if (response.status === 401) {
|
|
console.warn(`API路径 ${path} 返回未授权状态`);
|
|
authError = true;
|
|
continue;
|
|
}
|
|
|
|
if (response.ok) {
|
|
const data = await response.json();
|
|
documents = Array.isArray(data) ? data : [];
|
|
|
|
// 确保每个文档都包含必要的时间字段
|
|
documents = documents.map(doc => {
|
|
if (!doc.createdAt && doc.updatedAt) {
|
|
// 如果没有创建时间但有更新时间，使用更新时间
|
|
doc.createdAt = doc.updatedAt;
|
|
} else if (!doc.createdAt) {
|
|
// 如果都没有，使用当前时间
|
|
doc.createdAt = new Date().toISOString();
|
|
}
|
|
|
|
if (!doc.updatedAt) {
|
|
// 如果没有更新时间，使用创建时间
|
|
doc.updatedAt = doc.createdAt;
|
|
}
|
|
|
|
return doc;
|
|
});
|
|
|
|
// 先渲染表头，再渲染文档列表
|
|
this.renderDocumentTableHeader();
|
|
this.renderDocumentList();
|
|
console.log(`成功从API路径 ${path} 加载文档列表`, documents);
|
|
success = true;
|
|
break;
|
|
}
|
|
} catch (e) {
|
|
console.warn(`从 ${path} 加载文档失败:`, e);
|
|
}
|
|
}
|
|
|
|
// 处理认证错误 - 只有当会话检查和API请求都明确失败时才强制登出
|
|
if ((authError || !sessionValid) && !success && localStorage.getItem('isLoggedIn') === 'true') {
|
|
console.warn('会话检查和API请求均指示会话已过期');
|
|
core.showAlert('会话已过期，请重新登录', 'warning');
|
|
setTimeout(() => {
|
|
localStorage.removeItem('isLoggedIn');
|
|
window.location.reload();
|
|
}, 1500);
|
|
return;
|
|
}
|
|
|
|
// 如果API请求失败但不是认证错误，显示空文档列表
|
|
if (!success) {
|
|
console.log('API请求失败，显示空文档列表');
|
|
documents = [];
|
|
// 仍然需要渲染表头
|
|
this.renderDocumentTableHeader();
|
|
this.renderDocumentList();
|
|
}
|
|
} catch (error) {
|
|
console.error('加载文档失败:', error);
|
|
// 在UI上显示错误
|
|
const documentTableBody = document.getElementById('documentTableBody');
|
|
if (documentTableBody) {
|
|
documentTableBody.innerHTML = `<tr><td colspan="6" style="text-align: center; color: red;">加载文档失败: ${error.message} <button onclick="documentManager.loadDocuments()">重试</button></td></tr>`;
|
|
}
|
|
|
|
// 设置为空文档列表
|
|
documents = [];
|
|
}
|
|
},
|
|
|
|
// 初始化编辑器
|
|
initEditor: function() {
|
|
try {
|
|
const editorContainer = document.getElementById('editor');
|
|
if (!editorContainer) {
|
|
console.error('找不到编辑器容器元素');
|
|
return;
|
|
}
|
|
|
|
// 检查 toastui 是否已加载
|
|
console.log('检查编辑器依赖项:', typeof toastui);
|
|
|
|
// 确保 toastui 对象存在
|
|
if (typeof toastui === 'undefined') {
|
|
console.error('Toast UI Editor 未加载');
|
|
return;
|
|
}
|
|
|
|
// 创建编辑器实例
|
|
editorMd = new toastui.Editor({
|
|
el: editorContainer,
|
|
height: '600px',
|
|
initialValue: '',
|
|
previewStyle: 'vertical',
|
|
initialEditType: 'markdown',
|
|
toolbarItems: [
|
|
['heading', 'bold', 'italic', 'strike'],
|
|
['hr', 'quote'],
|
|
['ul', 'ol', 'task', 'indent', 'outdent'],
|
|
['table', 'image', 'link'],
|
|
['code', 'codeblock']
|
|
]
|
|
});
|
|
|
|
console.log('编辑器初始化完成', editorMd);
|
|
} catch (error) {
|
|
console.error('初始化编辑器出错:', error);
|
|
core.showAlert('初始化编辑器失败: ' + error.message, 'error');
|
|
}
|
|
},
|
|
|
|
// 检查编辑器是否已初始化
|
|
isEditorInitialized: function() {
|
|
return editorMd !== null;
|
|
},
|
|
|
|
// 创建新文档
|
|
newDocument: function() {
|
|
// 首先确保编辑器已初始化
|
|
if (!editorMd) {
|
|
this.initEditor();
|
|
// 等待编辑器初始化完成后再继续
|
|
setTimeout(() => {
|
|
currentDocument = null;
|
|
document.getElementById('documentTitle').value = '';
|
|
editorMd.setMarkdown('');
|
|
this.showEditor();
|
|
}, 500);
|
|
} else {
|
|
currentDocument = null;
|
|
document.getElementById('documentTitle').value = '';
|
|
editorMd.setMarkdown('');
|
|
this.showEditor();
|
|
}
|
|
},
|
|
|
|
// 显示编辑器
|
|
showEditor: function() {
|
|
document.getElementById('documentTable').style.display = 'none';
|
|
document.getElementById('editorContainer').style.display = 'block';
|
|
if (editorMd) {
|
|
// 确保每次显示编辑器时都切换到编辑模式
|
|
editorMd.focus();
|
|
}
|
|
},
|
|
|
|
// 隐藏编辑器
|
|
hideEditor: function() {
|
|
document.getElementById('documentTable').style.display = 'table';
|
|
document.getElementById('editorContainer').style.display = 'none';
|
|
},
|
|
|
|
// 取消编辑
|
|
cancelEdit: function() {
|
|
this.hideEditor();
|
|
},
|
|
|
|
// 保存文档
|
|
saveDocument: async function() {
|
|
const title = document.getElementById('documentTitle').value.trim();
|
|
const content = editorMd.getMarkdown();
|
|
|
|
if (!title) {
|
|
core.showAlert('请输入文档标题', 'error');
|
|
return;
|
|
}
|
|
|
|
// 显示保存中状态
|
|
core.showLoading();
|
|
|
|
try {
|
|
// 简化会话检查逻辑，只验证会话是否有效
|
|
let sessionValid = true;
|
|
try {
|
|
const sessionResponse = await fetch('/api/check-session', {
|
|
headers: {
|
|
'Cache-Control': 'no-cache',
|
|
'X-Requested-With': 'XMLHttpRequest'
|
|
},
|
|
credentials: 'same-origin'
|
|
});
|
|
|
|
if (sessionResponse.status === 401) {
|
|
console.warn('会话已过期，无法保存文档');
|
|
sessionValid = false;
|
|
}
|
|
} catch (sessionError) {
|
|
console.warn('检查会话状态发生网络错误:', sessionError);
|
|
// 发生网络错误时继续尝试保存操作
|
|
}
|
|
|
|
// 只有在会话明确无效时才退出
|
|
if (!sessionValid) {
|
|
core.showAlert('您的会话已过期，请重新登录', 'warning');
|
|
setTimeout(() => {
|
|
localStorage.removeItem('isLoggedIn');
|
|
window.location.reload();
|
|
}, 1500);
|
|
return;
|
|
}
|
|
|
|
// 确保Markdown内容以标题开始
|
|
let processedContent = content;
|
|
if (!content.startsWith('# ')) {
|
|
// 如果内容不是以一级标题开始，则在开头添加标题
|
|
processedContent = `# ${title}\n\n${content}`;
|
|
} else {
|
|
// 如果已经有一级标题，替换为当前标题
|
|
processedContent = content.replace(/^# .*$/m, `# ${title}`);
|
|
}
|
|
|
|
const apiUrl = currentDocument && currentDocument.id
|
|
? `/api/documents/${currentDocument.id}`
|
|
: '/api/documents';
|
|
|
|
const method = currentDocument && currentDocument.id ? 'PUT' : 'POST';
|
|
|
|
console.log(`尝试${method === 'PUT' ? '更新' : '创建'}文档，标题: ${title}`);
|
|
|
|
const response = await fetch(apiUrl, {
|
|
method: method,
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-Requested-With': 'XMLHttpRequest'
|
|
},
|
|
credentials: 'same-origin',
|
|
body: JSON.stringify({
|
|
title,
|
|
content: processedContent,
|
|
published: currentDocument && currentDocument.published ? currentDocument.published : false
|
|
})
|
|
});
|
|
|
|
// 处理响应
|
|
if (response.status === 401) {
|
|
// 明确的未授权响应
|
|
console.warn('保存文档返回401未授权');
|
|
core.showAlert('未登录或会话已过期，请重新登录', 'warning');
|
|
setTimeout(() => {
|
|
localStorage.removeItem('isLoggedIn');
|
|
window.location.reload();
|
|
}, 1500);
|
|
return;
|
|
}
|
|
|
|
if (!response.ok) {
|
|
const errorText = await response.text();
|
|
let errorData;
|
|
try {
|
|
errorData = JSON.parse(errorText);
|
|
} catch (e) {
|
|
// 如果不是有效的JSON，直接使用文本
|
|
throw new Error(errorText || '保存失败，请重试');
|
|
}
|
|
throw new Error(errorData.error || errorData.message || '保存失败，请重试');
|
|
}
|
|
|
|
const savedDoc = await response.json();
|
|
console.log('保存的文档:', savedDoc);
|
|
|
|
// 确保savedDoc包含必要的时间字段
|
|
if (savedDoc) {
|
|
// 如果返回的保存文档中没有时间字段，从API获取完整文档信息
|
|
if (!savedDoc.createdAt || !savedDoc.updatedAt) {
|
|
try {
|
|
const docId = savedDoc.id || (currentDocument ? currentDocument.id : null);
|
|
if (docId) {
|
|
const docResponse = await fetch(`/api/documents/${docId}`, {
|
|
headers: { 'Cache-Control': 'no-cache' },
|
|
credentials: 'same-origin'
|
|
});
|
|
|
|
if (docResponse.ok) {
|
|
const fullDoc = await docResponse.json();
|
|
Object.assign(savedDoc, {
|
|
createdAt: fullDoc.createdAt,
|
|
updatedAt: fullDoc.updatedAt
|
|
});
|
|
console.log('获取到完整的文档时间信息:', fullDoc);
|
|
}
|
|
}
|
|
} catch (timeError) {
|
|
console.warn('获取文档完整时间信息失败:', timeError);
|
|
}
|
|
}
|
|
|
|
// 更新文档列表中的文档
|
|
const existingIndex = documents.findIndex(d => d.id === savedDoc.id);
|
|
if (existingIndex >= 0) {
|
|
documents[existingIndex] = { ...documents[existingIndex], ...savedDoc };
|
|
} else {
|
|
documents.push(savedDoc);
|
|
}
|
|
}
|
|
|
|
core.showAlert('文档保存成功', 'success');
|
|
this.hideEditor();
|
|
await this.loadDocuments(); // 重新加载文档列表
|
|
} catch (error) {
|
|
console.error('保存文档失败:', error);
|
|
core.showAlert('保存文档失败: ' + error.message, 'error');
|
|
} finally {
|
|
core.hideLoading();
|
|
}
|
|
},
|
|
|
|
// 渲染文档列表
|
|
renderDocumentList: function() {
|
|
const tbody = document.getElementById('documentTableBody');
|
|
tbody.innerHTML = '';
|
|
|
|
if (documents.length === 0) {
|
|
tbody.innerHTML = '<tr><td colspan="6" style="text-align: center;">没有找到文档</td></tr>';
|
|
return;
|
|
}
|
|
|
|
documents.forEach((doc, index) => {
|
|
// 确保文档时间有合理默认值
|
|
let createdAt = '未知';
|
|
let updatedAt = '未知';
|
|
|
|
try {
|
|
// 尝试解析创建时间，如果失败则回退到默认值
|
|
if (doc.createdAt) {
|
|
const createdDate = new Date(doc.createdAt);
|
|
if (!isNaN(createdDate.getTime())) {
|
|
createdAt = createdDate.toLocaleString('zh-CN', {
|
|
year: 'numeric',
|
|
month: '2-digit',
|
|
day: '2-digit',
|
|
hour: '2-digit',
|
|
minute: '2-digit',
|
|
second: '2-digit'
|
|
});
|
|
}
|
|
}
|
|
|
|
// 尝试解析更新时间，如果失败则回退到默认值
|
|
if (doc.updatedAt) {
|
|
const updatedDate = new Date(doc.updatedAt);
|
|
if (!isNaN(updatedDate.getTime())) {
|
|
updatedAt = updatedDate.toLocaleString('zh-CN', {
|
|
year: 'numeric',
|
|
month: '2-digit',
|
|
day: '2-digit',
|
|
hour: '2-digit',
|
|
minute: '2-digit',
|
|
second: '2-digit'
|
|
});
|
|
}
|
|
}
|
|
|
|
// 简化时间显示逻辑 - 直接显示时间戳，不添加特殊标记
|
|
if (createdAt === '未知' && updatedAt !== '未知') {
|
|
// 如果没有创建时间但有更新时间
|
|
createdAt = '未记录';
|
|
} else if (updatedAt === '未知' && createdAt !== '未知') {
|
|
// 如果没有更新时间但有创建时间
|
|
updatedAt = '未更新';
|
|
}
|
|
} catch (error) {
|
|
console.warn(`解析文档时间失败:`, error, doc);
|
|
}
|
|
|
|
const statusClasses = doc.published ? 'status-badge status-running' : 'status-badge status-stopped';
|
|
const statusText = doc.published ? '已发布' : '未发布';
|
|
|
|
const row = document.createElement('tr');
|
|
row.innerHTML = `
|
|
<td>${index + 1}</td>
|
|
<td>${doc.title || '无标题文档'}</td>
|
|
<td>${createdAt}</td>
|
|
<td>${updatedAt}</td>
|
|
<td><span class="${statusClasses}">${statusText}</span></td>
|
|
<td class="action-buttons">
|
|
<button class="action-btn edit-btn" title="编辑文档" onclick="documentManager.editDocument('${doc.id}')">
|
|
<i class="fas fa-edit"></i>
|
|
</button>
|
|
<button class="action-btn ${doc.published ? 'unpublish-btn' : 'publish-btn'}"
|
|
title="${doc.published ? '取消发布' : '发布文档'}"
|
|
onclick="documentManager.togglePublish('${doc.id}')">
|
|
<i class="fas ${doc.published ? 'fa-toggle-off' : 'fa-toggle-on'}"></i>
|
|
</button>
|
|
<button class="action-btn delete-btn" title="删除文档" onclick="documentManager.deleteDocument('${doc.id}')">
|
|
<i class="fas fa-trash"></i>
|
|
</button>
|
|
</td>
|
|
`;
|
|
|
|
tbody.appendChild(row);
|
|
});
|
|
},
|
|
|
|
// 编辑文档
|
|
editDocument: async function(id) {
|
|
try {
|
|
console.log(`准备编辑文档，ID: ${id}`);
|
|
core.showLoading();
|
|
|
|
// 检查会话状态，优化会话检查逻辑
|
|
let sessionValid = true;
|
|
try {
|
|
const sessionResponse = await fetch('/api/check-session', {
|
|
headers: {
|
|
'Cache-Control': 'no-cache',
|
|
'X-Requested-With': 'XMLHttpRequest'
|
|
},
|
|
credentials: 'same-origin'
|
|
});
|
|
|
|
if (sessionResponse.status === 401) {
|
|
console.warn('会话已过期，无法编辑文档');
|
|
sessionValid = false;
|
|
}
|
|
} catch (sessionError) {
|
|
console.warn('检查会话状态发生网络错误:', sessionError);
|
|
// 发生网络错误时不立即判定会话失效，继续尝试编辑操作
|
|
}
|
|
|
|
// 只有在明确会话无效时才提示重新登录
|
|
if (!sessionValid) {
|
|
core.showAlert('您的会话已过期，请重新登录', 'warning');
|
|
setTimeout(() => {
|
|
localStorage.removeItem('isLoggedIn');
|
|
window.location.reload();
|
|
}, 1500);
|
|
return;
|
|
}
|
|
|
|
// 在本地查找文档
|
|
currentDocument = documents.find(doc => doc.id === id);
|
|
|
|
// 如果本地未找到，从API获取
|
|
if (!currentDocument && id) {
|
|
try {
|
|
console.log('从API获取文档详情');
|
|
|
|
// 尝试多个可能的API路径
|
|
const apiPaths = [
|
|
`/api/documents/${id}`,
|
|
`/api/documentation/${id}`
|
|
];
|
|
|
|
let docResponse = null;
|
|
let authError = false;
|
|
|
|
for (const apiPath of apiPaths) {
|
|
try {
|
|
console.log(`尝试从 ${apiPath} 获取文档`);
|
|
const response = await fetch(apiPath, {
|
|
credentials: 'same-origin',
|
|
headers: {
|
|
'X-Requested-With': 'XMLHttpRequest'
|
|
}
|
|
});
|
|
|
|
// 只有明确401错误才认定为会话过期
|
|
if (response.status === 401) {
|
|
console.warn(`API ${apiPath} 返回401未授权`);
|
|
authError = true;
|
|
continue;
|
|
}
|
|
|
|
if (response.ok) {
|
|
docResponse = response;
|
|
console.log(`成功从 ${apiPath} 获取文档`);
|
|
break;
|
|
}
|
|
} catch (pathError) {
|
|
console.warn(`从 ${apiPath} 获取文档失败:`, pathError);
|
|
}
|
|
}
|
|
|
|
// 处理认证错误
|
|
if (authError && !docResponse) {
|
|
core.showAlert('未登录或会话已过期，请重新登录', 'warning');
|
|
setTimeout(() => {
|
|
localStorage.removeItem('isLoggedIn');
|
|
window.location.reload();
|
|
}, 1500);
|
|
return;
|
|
}
|
|
|
|
if (docResponse && docResponse.ok) {
|
|
currentDocument = await docResponse.json();
|
|
console.log('获取到文档详情:', currentDocument);
|
|
|
|
// 确保文档包含必要的时间字段
|
|
if (!currentDocument.createdAt && currentDocument.updatedAt) {
|
|
// 如果没有创建时间但有更新时间，使用更新时间
|
|
currentDocument.createdAt = currentDocument.updatedAt;
|
|
} else if (!currentDocument.createdAt) {
|
|
// 如果都没有，使用当前时间
|
|
currentDocument.createdAt = new Date().toISOString();
|
|
}
|
|
|
|
if (!currentDocument.updatedAt) {
|
|
// 如果没有更新时间，使用创建时间
|
|
currentDocument.updatedAt = currentDocument.createdAt;
|
|
}
|
|
|
|
// 将获取到的文档添加到文档列表中
|
|
const existingIndex = documents.findIndex(d => d.id === id);
|
|
if (existingIndex >= 0) {
|
|
documents[existingIndex] = currentDocument;
|
|
} else {
|
|
documents.push(currentDocument);
|
|
}
|
|
} else {
|
|
throw new Error('所有API路径都无法获取文档');
|
|
}
|
|
} catch (apiError) {
|
|
console.error('从API获取文档详情失败:', apiError);
|
|
core.showAlert('获取文档详情失败: ' + apiError.message, 'error');
|
|
}
|
|
}
|
|
|
|
// 如果仍然没有找到文档，显示错误
|
|
if (!currentDocument) {
|
|
core.showAlert('未找到指定的文档', 'error');
|
|
return;
|
|
}
|
|
|
|
// 显示编辑器界面并设置内容
|
|
this.showEditor();
|
|
|
|
// 确保编辑器已初始化
|
|
if (!editorMd) {
|
|
await new Promise(resolve => setTimeout(resolve, 100));
|
|
this.initEditor();
|
|
await new Promise(resolve => setTimeout(resolve, 500));
|
|
}
|
|
|
|
// 设置文档内容
|
|
if (editorMd) {
|
|
document.getElementById('documentTitle').value = currentDocument.title || '';
|
|
|
|
if (currentDocument.content) {
|
|
console.log(`设置文档内容，长度: ${currentDocument.content.length}`);
|
|
editorMd.setMarkdown(currentDocument.content);
|
|
} else {
|
|
console.log('文档内容为空，尝试额外获取内容');
|
|
|
|
// 如果文档内容为空，尝试额外获取内容
|
|
try {
|
|
const contentResponse = await fetch(`/api/documents/${id}/content`, {
|
|
credentials: 'same-origin',
|
|
headers: {
|
|
'X-Requested-With': 'XMLHttpRequest'
|
|
}
|
|
});
|
|
|
|
// 只有明确401错误才提示重新登录
|
|
if (contentResponse.status === 401) {
|
|
core.showAlert('会话已过期，请重新登录', 'warning');
|
|
setTimeout(() => {
|
|
localStorage.removeItem('isLoggedIn');
|
|
window.location.reload();
|
|
}, 1500);
|
|
return;
|
|
}
|
|
|
|
if (contentResponse.ok) {
|
|
const contentData = await contentResponse.json();
|
|
if (contentData.content) {
|
|
currentDocument.content = contentData.content;
|
|
editorMd.setMarkdown(contentData.content);
|
|
console.log('成功获取额外内容');
|
|
}
|
|
}
|
|
} catch (contentError) {
|
|
console.warn('获取额外内容失败:', contentError);
|
|
}
|
|
|
|
// 如果仍然没有内容，设置为空
|
|
if (!currentDocument.content) {
|
|
editorMd.setMarkdown('');
|
|
}
|
|
}
|
|
} else {
|
|
console.error('编辑器初始化失败，无法设置内容');
|
|
core.showAlert('编辑器初始化失败，请刷新页面重试', 'error');
|
|
}
|
|
} catch (error) {
|
|
console.error('编辑文档时出错:', error);
|
|
core.showAlert('编辑文档失败: ' + error.message, 'error');
|
|
} finally {
|
|
core.hideLoading();
|
|
}
|
|
},
|
|
|
|
// 查看文档
|
|
viewDocument: function(id) {
|
|
const doc = documents.find(doc => doc.id === id);
|
|
if (!doc) {
|
|
core.showAlert('未找到指定的文档', 'error');
|
|
return;
|
|
}
|
|
|
|
Swal.fire({
|
|
title: doc.title,
|
|
html: `<div class="document-preview">${marked.parse(doc.content || '')}</div>`,
|
|
width: '70%',
|
|
showCloseButton: true,
|
|
showConfirmButton: false,
|
|
customClass: {
|
|
container: 'document-preview-container',
|
|
popup: 'document-preview-popup',
|
|
content: 'document-preview-content'
|
|
}
|
|
});
|
|
},
|
|
|
|
// 删除文档
|
|
deleteDocument: async function(id) {
|
|
Swal.fire({
|
|
title: '确定要删除此文档吗?',
|
|
text: "此操作无法撤销!",
|
|
icon: 'warning',
|
|
showCancelButton: true,
|
|
confirmButtonColor: '#d33',
|
|
cancelButtonColor: '#3085d6',
|
|
confirmButtonText: '是，删除它',
|
|
cancelButtonText: '取消'
|
|
}).then(async (result) => {
|
|
if (result.isConfirmed) {
|
|
try {
|
|
console.log(`尝试删除文档: ${id}`);
|
|
|
|
// 检查会话状态
|
|
const sessionResponse = await fetch('/api/check-session', {
|
|
headers: { 'Cache-Control': 'no-cache' }
|
|
});
|
|
|
|
if (sessionResponse.status === 401) {
|
|
// 会话已过期，提示用户并重定向到登录
|
|
core.showAlert('您的会话已过期，请重新登录', 'warning');
|
|
setTimeout(() => {
|
|
localStorage.removeItem('isLoggedIn');
|
|
window.location.reload();
|
|
}, 1500);
|
|
return;
|
|
}
|
|
|
|
// 使用正确的API路径删除
|
|
const response = await fetch(`/api/documents/${id}`, {
|
|
method: 'DELETE',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-Requested-With': 'XMLHttpRequest'
|
|
},
|
|
credentials: 'same-origin' // 确保发送cookie
|
|
});
|
|
|
|
if (response.status === 401) {
|
|
// 处理未授权错误
|
|
core.showAlert('未登录或会话已过期，请重新登录', 'warning');
|
|
setTimeout(() => {
|
|
localStorage.removeItem('isLoggedIn');
|
|
window.location.reload();
|
|
}, 1500);
|
|
return;
|
|
}
|
|
|
|
if (!response.ok) {
|
|
const errorData = await response.json();
|
|
throw new Error(errorData.error || '删除文档失败');
|
|
}
|
|
|
|
console.log('文档删除成功响应:', await response.json());
|
|
core.showAlert('文档已成功删除', 'success');
|
|
await this.loadDocuments(); // 重新加载文档列表
|
|
} catch (error) {
|
|
console.error('删除文档失败:', error);
|
|
core.showAlert('删除文档失败: ' + error.message, 'error');
|
|
}
|
|
}
|
|
});
|
|
},
|
|
|
|
// 切换文档发布状态
|
|
togglePublish: async function(id) {
|
|
try {
|
|
const doc = documents.find(d => d.id === id);
|
|
if (!doc) {
|
|
throw new Error('找不到指定文档');
|
|
}
|
|
|
|
// 添加加载指示
|
|
core.showLoading();
|
|
|
|
// 检查会话状态
|
|
const sessionResponse = await fetch('/api/check-session', {
|
|
headers: { 'Cache-Control': 'no-cache' }
|
|
});
|
|
|
|
if (sessionResponse.status === 401) {
|
|
// 会话已过期，提示用户并重定向到登录
|
|
core.showAlert('您的会话已过期，请重新登录', 'warning');
|
|
setTimeout(() => {
|
|
localStorage.removeItem('isLoggedIn');
|
|
window.location.reload();
|
|
}, 1500);
|
|
return;
|
|
}
|
|
|
|
console.log(`尝试切换文档 ${id} 的发布状态，当前状态:`, doc.published);
|
|
|
|
// 构建更新请求数据
|
|
const updateData = {
|
|
id: doc.id,
|
|
title: doc.title,
|
|
published: !doc.published // 切换发布状态
|
|
};
|
|
|
|
// 使用正确的API端点进行更新
|
|
const response = await fetch(`/api/documentation/toggle-publish/${id}`, {
|
|
method: 'PUT',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-Requested-With': 'XMLHttpRequest'
|
|
},
|
|
credentials: 'same-origin', // 确保发送cookie
|
|
body: JSON.stringify(updateData)
|
|
});
|
|
|
|
if (response.status === 401) {
|
|
// 处理未授权错误
|
|
core.showAlert('未登录或会话已过期，请重新登录', 'warning');
|
|
setTimeout(() => {
|
|
localStorage.removeItem('isLoggedIn');
|
|
window.location.reload();
|
|
}, 1500);
|
|
return;
|
|
}
|
|
|
|
if (!response.ok) {
|
|
const errorData = await response.json();
|
|
throw new Error(errorData.error || '更新文档状态失败');
|
|
}
|
|
|
|
// 更新成功
|
|
const updatedDoc = await response.json();
|
|
console.log('文档状态更新响应:', updatedDoc);
|
|
|
|
// 更新本地文档列表
|
|
const docIndex = documents.findIndex(d => d.id === id);
|
|
if (docIndex >= 0) {
|
|
documents[docIndex].published = updatedDoc.published;
|
|
this.renderDocumentList();
|
|
}
|
|
|
|
core.showAlert('文档状态已更新', 'success');
|
|
} catch (error) {
|
|
console.error('更改发布状态失败:', error);
|
|
core.showAlert('更改发布状态失败: ' + error.message, 'error');
|
|
} finally {
|
|
core.hideLoading();
|
|
}
|
|
}
|
|
};
|
|
|
|
// 全局公开文档管理模块
|
|
window.documentManager = documentManager;
|
|
|
|
/**
|
|
* 显示指定文档的内容
|
|
* @param {string} docId 文档ID
|
|
*/
|
|
async function showDocument(docId) {
|
|
try {
|
|
console.log('正在获取文档内容，ID:', docId);
|
|
|
|
// 显示加载状态
|
|
const documentContent = document.getElementById('documentContent');
|
|
if (documentContent) {
|
|
documentContent.innerHTML = '<div class="loading-container"><i class="fas fa-spinner fa-spin"></i> 正在加载文档内容...</div>';
|
|
}
|
|
|
|
// 获取文档内容
|
|
const response = await fetch(`/api/documentation/${docId}`);
|
|
if (!response.ok) {
|
|
throw new Error(`获取文档内容失败，状态码: ${response.status}`);
|
|
}
|
|
|
|
const doc = await response.json();
|
|
console.log('获取到文档:', doc);
|
|
|
|
// 更新文档内容区域
|
|
if (documentContent) {
|
|
if (doc.content) {
|
|
// 使用marked渲染markdown内容
|
|
documentContent.innerHTML = `
|
|
<h1>${doc.title || '无标题'}</h1>
|
|
${doc.lastUpdated ? `<div class="doc-meta">最后更新: ${new Date(doc.lastUpdated).toLocaleDateString('zh-CN')}</div>` : ''}
|
|
<div class="doc-content">${window.marked ? marked.parse(doc.content) : doc.content}</div>
|
|
`;
|
|
} else {
|
|
documentContent.innerHTML = `
|
|
<h1>${doc.title || '无标题'}</h1>
|
|
<div class="empty-content">
|
|
<i class="fas fa-file-alt fa-3x"></i>
|
|
<p>该文档暂无内容</p>
|
|
</div>
|
|
`;
|
|
}
|
|
} else {
|
|
console.error('找不到文档内容容器，ID: documentContent');
|
|
}
|
|
|
|
// 高亮当前选中的文档
|
|
highlightSelectedDocument(docId);
|
|
} catch (error) {
|
|
console.error('获取文档内容失败:', error);
|
|
|
|
// 显示错误信息
|
|
const documentContent = document.getElementById('documentContent');
|
|
if (documentContent) {
|
|
documentContent.innerHTML = `
|
|
<div class="error-container">
|
|
<i class="fas fa-exclamation-triangle fa-3x"></i>
|
|
<h2>加载失败</h2>
|
|
<p>无法获取文档内容: ${error.message}</p>
|
|
<button class="btn btn-retry" onclick="showDocument('${docId}')">重试</button>
|
|
</div>
|
|
`;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 高亮选中的文档
|
|
* @param {string} docId 文档ID
|
|
*/
|
|
function highlightSelectedDocument(docId) {
|
|
// 移除所有高亮
|
|
const docLinks = document.querySelectorAll('.doc-list .doc-item');
|
|
docLinks.forEach(link => link.classList.remove('active'));
|
|
|
|
// 添加当前高亮
|
|
const selectedLink = document.querySelector(`.doc-list .doc-item[data-id="${docId}"]`);
|
|
if (selectedLink) {
|
|
selectedLink.classList.add('active');
|
|
// 确保选中项可见
|
|
selectedLink.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
|
|
}
|
|
}
|