1873 lines
49 KiB
TypeScript
1873 lines
49 KiB
TypeScript
import { useAuth } from '../composables/useAuth'
|
||
|
||
export const API_BASE = '/api'
|
||
|
||
export interface ApiResponse<T = unknown> {
|
||
code: number
|
||
message: string
|
||
result: T
|
||
}
|
||
|
||
export interface ParseApiOptions {
|
||
skipSessionExpired?: boolean
|
||
}
|
||
|
||
export async function parseApiResponse<T>(response: Response, options?: ParseApiOptions): Promise<T> {
|
||
let data: ApiResponse<T>
|
||
try {
|
||
data = await response.json()
|
||
} catch {
|
||
throw new Error('响应解析失败')
|
||
}
|
||
|
||
if (data.code === 401 && !options?.skipSessionExpired) {
|
||
const { handleSessionExpired } = useAuth()
|
||
handleSessionExpired()
|
||
throw new Error(data.message || '登录已过期，请重新登录')
|
||
}
|
||
|
||
if (data.code !== 200) {
|
||
throw new Error(data.message || '请求失败')
|
||
}
|
||
|
||
return data.result
|
||
}
|
||
|
||
// 带认证的 fetch，仅附加 Authorization，业务状态由 parseApiResponse 解析
|
||
export async function authFetch(input: RequestInfo | URL, init: RequestInit = {}): Promise<Response> {
|
||
const { getToken } = useAuth()
|
||
const headers = new Headers(init.headers)
|
||
|
||
const token = getToken()
|
||
if (token && !headers.has('Authorization')) {
|
||
headers.set('Authorization', `Bearer ${token}`)
|
||
}
|
||
|
||
return fetch(input, { ...init, headers })
|
||
}
|
||
|
||
export async function authFetchJson<T>(
|
||
input: RequestInfo | URL,
|
||
init: RequestInit = {},
|
||
options?: ParseApiOptions
|
||
): Promise<T> {
|
||
const response = await authFetch(input, init)
|
||
return parseApiResponse<T>(response, options)
|
||
}
|
||
|
||
export async function fetchJson<T>(
|
||
input: RequestInfo | URL,
|
||
init: RequestInit = {},
|
||
options?: ParseApiOptions
|
||
): Promise<T> {
|
||
const response = await fetch(input, init)
|
||
return parseApiResponse<T>(response, options)
|
||
}
|
||
|
||
// 通用请求头配置
|
||
export const getAuthHeaders = () => {
|
||
const token = localStorage.getItem('token')
|
||
return {
|
||
'Content-Type': 'application/json',
|
||
...(token ? { Authorization: `Bearer ${token}` } : {})
|
||
}
|
||
}
|
||
|
||
// 认证相关类型
|
||
export interface User {
|
||
id: number
|
||
username: string
|
||
email: string
|
||
role: string
|
||
isActive: number
|
||
createdAt: string
|
||
updatedAt: string
|
||
}
|
||
|
||
export interface LoginRequest {
|
||
username: string
|
||
password: string
|
||
}
|
||
|
||
export interface LoginResponse {
|
||
token: string
|
||
user: User
|
||
expire: number
|
||
}
|
||
|
||
// 角色相关类型
|
||
export interface Role {
|
||
id: number
|
||
name: string
|
||
description: string
|
||
createdAt: string
|
||
updatedAt: string
|
||
}
|
||
|
||
// 作品相关类型
|
||
export interface Work {
|
||
id: string
|
||
title: string
|
||
category: string
|
||
year: string
|
||
heroImg: string
|
||
desc: string
|
||
techStack: { category: string; items: string[] }[]
|
||
gallery: string[]
|
||
links: { live?: string; github?: string; demo?: string }
|
||
next: string
|
||
}
|
||
|
||
// 分类相关类型
|
||
export interface Category {
|
||
id: number
|
||
name: string
|
||
slug: string
|
||
description: string
|
||
sortOrder: number
|
||
createdAt: string
|
||
updatedAt: string
|
||
}
|
||
|
||
// 专栏相关类型
|
||
export interface Column {
|
||
id: number
|
||
name: string
|
||
description: string
|
||
cover: string
|
||
isActive: number
|
||
sortOrder: number
|
||
createdAt: string
|
||
updatedAt: string
|
||
}
|
||
|
||
// 标签相关类型
|
||
export interface Tag {
|
||
id: number
|
||
name: string
|
||
slug: string
|
||
createdAt: string
|
||
updatedAt: string
|
||
}
|
||
|
||
// 文章相关类型
|
||
export interface Post {
|
||
id: number
|
||
title: string
|
||
categoryId: number
|
||
categoryName?: string // Display name
|
||
categorySlug?: string
|
||
category?: Category // Optional full object
|
||
columnId?: number | null
|
||
columnName?: string
|
||
tags?: Tag[]
|
||
date: string
|
||
excerpt?: string
|
||
content?: string
|
||
isPublished?: number
|
||
readCount?: number
|
||
}
|
||
|
||
export interface PostHistory {
|
||
id: number
|
||
postId: number
|
||
version: number
|
||
title: string
|
||
categoryId: number
|
||
categoryName?: string
|
||
columnId?: number
|
||
columnName?: string
|
||
tagIds?: number[]
|
||
tagNames?: string[]
|
||
excerpt?: string
|
||
content?: string
|
||
isPublished: number
|
||
modifiedBy: number
|
||
modifiedByName?: string
|
||
modifiedAt: string
|
||
createdAt: string
|
||
}
|
||
|
||
export interface PostHistoryFieldDiff {
|
||
from: string
|
||
to: string
|
||
changed: boolean
|
||
diff?: string
|
||
}
|
||
|
||
export interface PostHistoryDiff {
|
||
fromVersion: number
|
||
toVersion: number
|
||
fields: Record<string, PostHistoryFieldDiff>
|
||
}
|
||
|
||
export interface HotSearchKeyword {
|
||
keyword: string
|
||
count: number
|
||
}
|
||
|
||
// 代码类型
|
||
export interface CodeType {
|
||
id: number
|
||
name: string
|
||
category: number // 0前端 1后端 2其他
|
||
}
|
||
|
||
export const CODE_TYPE_CATEGORY_LABELS: Record<number, string> = {
|
||
0: '前端',
|
||
1: '后端',
|
||
2: '其他'
|
||
}
|
||
|
||
export const getCodeTypes = async (): Promise<CodeType[]> => {
|
||
const response = await fetch(`${API_BASE}/code-types`)
|
||
return await parseApiResponse(response)
|
||
}
|
||
|
||
export const getAdminCodeTypes = async (): Promise<CodeType[]> => {
|
||
const response = await authFetch(`${API_BASE}/admin/code-types`, { headers: getAuthHeaders() })
|
||
return await parseApiResponse(response)
|
||
}
|
||
|
||
export const createCodeType = async (data: Omit<CodeType, 'id'>): Promise<void> => {
|
||
const response = await authFetch(`${API_BASE}/admin/code-types`, {
|
||
method: 'POST',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(data)
|
||
})
|
||
await parseApiResponse(response)
|
||
}
|
||
|
||
export const updateCodeType = async (id: number, data: Omit<CodeType, 'id'>): Promise<void> => {
|
||
const response = await authFetch(`${API_BASE}/admin/code-types/${id}`, {
|
||
method: 'PUT',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(data)
|
||
})
|
||
await parseApiResponse(response)
|
||
}
|
||
|
||
export const deleteCodeType = async (id: number): Promise<void> => {
|
||
const response = await authFetch(`${API_BASE}/admin/code-types/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getAuthHeaders()
|
||
})
|
||
await parseApiResponse(response)
|
||
}
|
||
|
||
// 代码片段相关类型
|
||
export interface Snippet {
|
||
id: string
|
||
title: string
|
||
code: string
|
||
type: string
|
||
codeTypeId?: number
|
||
codeType?: CodeType
|
||
description?: string
|
||
viewCount?: number
|
||
}
|
||
|
||
// 系统配置相关类型
|
||
export interface Setting {
|
||
id: number
|
||
keyName: string
|
||
value: string
|
||
description: string
|
||
createdAt: string
|
||
updatedAt: string
|
||
}
|
||
|
||
// 操作日志相关类型
|
||
export interface OperationLog {
|
||
id: number
|
||
userId: number
|
||
username: string
|
||
ip: string
|
||
region?: string
|
||
path: string
|
||
method: string
|
||
action?: string
|
||
params: string
|
||
status: number
|
||
duration: number
|
||
createdAt: string
|
||
}
|
||
|
||
// 分页响应类型
|
||
export interface PaginationResponse<T> {
|
||
list: T[]
|
||
total: number
|
||
page: number
|
||
size: number
|
||
}
|
||
|
||
// 登录API
|
||
export const login = async (credentials: LoginRequest): Promise<LoginResponse> => {
|
||
try {
|
||
const response = await fetch(`${API_BASE}/admin/login`, {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify(credentials),
|
||
})
|
||
const result = await parseApiResponse<{ token: string; user: User; expire: number }>(response, {
|
||
skipSessionExpired: true,
|
||
})
|
||
return {
|
||
token: result.token,
|
||
user: result.user,
|
||
expire: result.expire,
|
||
}
|
||
} catch (error) {
|
||
console.error('Login error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 用户管理API
|
||
export interface GetUsersParams {
|
||
page?: number
|
||
pageSize?: number
|
||
keyword?: string
|
||
}
|
||
|
||
export const getUsersPaginated = async (params: GetUsersParams = {}): Promise<PaginationResponse<User>> => {
|
||
const page = params.page ?? 1
|
||
const pageSize = params.pageSize ?? 10
|
||
const qs = new URLSearchParams({ page: String(page), pageSize: String(pageSize) })
|
||
if (params.keyword) qs.set('keyword', params.keyword)
|
||
const response = await authFetch(`${API_BASE}/admin/users?${qs}`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response)
|
||
}
|
||
|
||
export const getUsers = async (): Promise<User[]> => {
|
||
try {
|
||
const data = await getUsersPaginated({ page: 1, pageSize: 1000 })
|
||
return data.list
|
||
} catch (error) {
|
||
console.error('Get users error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const fetchUser = async (id: number): Promise<User> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/users/${id}`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error(`Error fetching user ${id}:`, error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const createUser = async (userData: Omit<User, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/users`, {
|
||
method: 'POST',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(userData)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Create user error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const updateUser = async (id: number, userData: Omit<User, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/users/${id}`, {
|
||
method: 'PUT',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(userData)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Update user error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const deleteUser = async (id: number): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/users/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getAuthHeaders()
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Delete user error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 角色管理API
|
||
export const getRoles = async (): Promise<Role[]> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/roles`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
console.error('Get roles error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const createRole = async (roleData: Omit<Role, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/roles`, {
|
||
method: 'POST',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(roleData)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Create role error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const updateRole = async (id: number, roleData: Omit<Role, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/roles/${id}`, {
|
||
method: 'PUT',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(roleData)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Update role error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const deleteRole = async (id: number): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/roles/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getAuthHeaders()
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Delete role error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const fetchRole = async (id: number): Promise<Role> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/roles/${id}`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error(`Error fetching role ${id}:`, error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 作品管理API
|
||
export const getAdminWorks = async (): Promise<Work[]> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/works`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
const data = await parseApiResponse<PaginationResponse<Work>>(response)
|
||
const list = data?.list
|
||
return (list && Array.isArray(list)) ? list : []
|
||
} catch (error) {
|
||
console.error('Get admin works error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const fetchWorks = async (): Promise<Work[]> => {
|
||
try {
|
||
const result = await fetchJson<Work[] | null>(`${API_BASE}/works`)
|
||
if (!result) {
|
||
return []
|
||
}
|
||
if (!Array.isArray(result)) {
|
||
return []
|
||
}
|
||
// 确保每个 work 对象的字段格式正确
|
||
return result.map((work: any) => ({
|
||
id: work.id || '',
|
||
title: work.title || '',
|
||
category: work.category || '',
|
||
year: work.year || '',
|
||
heroImg: work.heroImg || '',
|
||
desc: work.desc || '',
|
||
techStack: Array.isArray(work.techStack) ? work.techStack : [],
|
||
gallery: Array.isArray(work.gallery) ? work.gallery : [],
|
||
links: work.links || {},
|
||
next: work.next || ''
|
||
})) as Work[]
|
||
} catch (error) {
|
||
console.error('Error fetching works:', error)
|
||
return []
|
||
}
|
||
}
|
||
|
||
export const fetchWork = async (id: string): Promise<Work> => {
|
||
try {
|
||
const result = await fetchJson<Work>(`${API_BASE}/works/${id}`)
|
||
if (!result) {
|
||
throw new Error('Work not found')
|
||
}
|
||
// 确保 techStack 和 gallery 始终是数组
|
||
if (!Array.isArray(result.techStack)) {
|
||
result.techStack = []
|
||
}
|
||
if (!Array.isArray(result.gallery)) {
|
||
result.gallery = []
|
||
}
|
||
return result
|
||
} catch (error) {
|
||
console.error(`Error fetching work ${id}:`, error)
|
||
return {
|
||
id: 'default',
|
||
title: '默认作品',
|
||
category: '默认分类',
|
||
year: '2024',
|
||
heroImg: '',
|
||
desc: '',
|
||
techStack: [],
|
||
gallery: [],
|
||
links: {},
|
||
next: ''
|
||
}
|
||
}
|
||
}
|
||
|
||
export const createWork = async (workData: Omit<Work, 'id' | 'next'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/works`, {
|
||
method: 'POST',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(workData)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Create work error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const updateWork = async (id: string, workData: Omit<Work, 'id' | 'next'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/works/${id}`, {
|
||
method: 'PUT',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(workData)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Update work error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const deleteWork = async (id: string): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/works/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getAuthHeaders()
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Delete work error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 文章管理API
|
||
export const getAdminPosts = async (
|
||
page: number = 1,
|
||
pageSize: number = 20,
|
||
keyword?: string
|
||
): Promise<PaginationResponse<Post>> => {
|
||
try {
|
||
const params = new URLSearchParams()
|
||
params.append('page', page.toString())
|
||
params.append('pageSize', pageSize.toString())
|
||
if (keyword) {
|
||
params.append('keyword', keyword)
|
||
}
|
||
|
||
const response = await authFetch(`${API_BASE}/admin/posts?${params.toString()}`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Get admin posts error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const fetchPosts = async (
|
||
query?: string,
|
||
categoryId?: number,
|
||
tagId?: number,
|
||
columnId?: number,
|
||
page?: number,
|
||
pageSize?: number
|
||
): Promise<PaginationResponse<Post>> => {
|
||
try {
|
||
let url = `${API_BASE}/posts`
|
||
const params = new URLSearchParams()
|
||
if (query) params.append('q', query)
|
||
if (categoryId) params.append('category', categoryId.toString())
|
||
if (tagId) params.append('tag', tagId.toString())
|
||
if (columnId) params.append('column', columnId.toString())
|
||
if (page) params.append('page', page.toString())
|
||
if (pageSize) params.append('pageSize', pageSize.toString())
|
||
|
||
if (params.toString()) {
|
||
url += `?${params.toString()}`
|
||
}
|
||
|
||
const data = await fetchJson<PaginationResponse<Post> | Post[]>(url)
|
||
|
||
// 返回分页格式的响应
|
||
if (data && typeof data === 'object' && 'list' in data) {
|
||
return data as PaginationResponse<Post>
|
||
}
|
||
|
||
// 兼容旧格式（直接返回数组）
|
||
const list = Array.isArray(data) ? data : []
|
||
return {
|
||
list,
|
||
total: list.length,
|
||
page: page || 1,
|
||
size: pageSize || list.length
|
||
}
|
||
} catch (error) {
|
||
console.error('Error fetching posts:', error)
|
||
return {
|
||
list: [],
|
||
total: 0,
|
||
page: page || 1,
|
||
size: pageSize || 10
|
||
}
|
||
}
|
||
}
|
||
|
||
export const fetchPost = async (id: number | string): Promise<Post> => {
|
||
try {
|
||
const response = await fetch(`${API_BASE}/posts/${id}`)
|
||
return await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error(`Error fetching post ${id}:`, error)
|
||
// Return empty fallback
|
||
return {
|
||
id: Number(id),
|
||
title: '未知文章',
|
||
categoryId: 0,
|
||
date: '2024-01-01'
|
||
}
|
||
}
|
||
}
|
||
|
||
// 获取推荐文章（基于IP的协同过滤）
|
||
export const getRecommendedPosts = async (postId: number | string, limit: number = 3): Promise<Post[]> => {
|
||
try {
|
||
const response = await fetch(`${API_BASE}/posts/${postId}/recommendations?limit=${limit}`)
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
console.error(`Error fetching recommended posts for ${postId}:`, error)
|
||
return []
|
||
}
|
||
}
|
||
|
||
export const createPost = async (postData: Omit<Post, 'id'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/posts`, {
|
||
method: 'POST',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(postData)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Create post error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const updatePost = async (id: number | string, postData: Omit<Post, 'id'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/posts/${id}`, {
|
||
method: 'PUT',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(postData)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Update post error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 更新文章关联关系（只更新分类、专栏、标签，不更新内容）
|
||
export const updatePostRelations = async (
|
||
id: number | string,
|
||
relations: { categoryId: number; columnId: number | null; tagIds: number[] }
|
||
): Promise<void> => {
|
||
try {
|
||
const payload: any = {
|
||
categoryId: relations.categoryId,
|
||
tagIds: relations.tagIds
|
||
}
|
||
|
||
if (relations.columnId !== null && relations.columnId > 0) {
|
||
payload.columnId = relations.columnId
|
||
} else {
|
||
payload.columnId = null
|
||
}
|
||
|
||
const response = await authFetch(`${API_BASE}/admin/posts/${id}/relations`, {
|
||
method: 'PATCH',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(payload)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Update post relations error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const togglePostStatus = async (id: number, isPublished: number): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/posts/${id}/status`, {
|
||
method: 'PATCH',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify({ isPublished })
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Toggle post status error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const deletePost = async (id: number | string): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/posts/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getAuthHeaders()
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Delete post error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 分类管理API
|
||
export const fetchCategories = async (): Promise<Category[]> => {
|
||
try {
|
||
const response = await fetch(`${API_BASE}/categories`)
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
console.error('Fetch categories error:', error)
|
||
return []
|
||
}
|
||
}
|
||
|
||
export const getAdminCategories = async (): Promise<Category[]> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/categories`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
console.error('Get admin categories error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const createCategory = async (data: Omit<Category, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/categories`, {
|
||
method: 'POST',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(data)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const updateCategory = async (id: number, data: Omit<Category, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/categories/${id}`, {
|
||
method: 'PUT',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(data)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const deleteCategory = async (id: number): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/categories/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getAuthHeaders()
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 专栏管理API
|
||
export const fetchColumns = async (): Promise<Column[]> => {
|
||
try {
|
||
const response = await fetch(`${API_BASE}/columns`)
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
return []
|
||
}
|
||
}
|
||
|
||
export const fetchColumn = async (id: number): Promise<Column> => {
|
||
try {
|
||
const response = await fetch(`${API_BASE}/columns/${id}`)
|
||
return await parseApiResponse(response)
|
||
} catch (error) {
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const getAdminColumns = async (): Promise<Column[]> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/columns`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const createColumn = async (data: Omit<Column, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/columns`, {
|
||
method: 'POST',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(data)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const updateColumn = async (id: number, data: Omit<Column, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/columns/${id}`, {
|
||
method: 'PUT',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(data)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const deleteColumn = async (id: number): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/columns/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getAuthHeaders()
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const fetchColumnPosts = async (id: number): Promise<Post[]> => {
|
||
try {
|
||
const response = await fetch(`${API_BASE}/columns/${id}/posts`)
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
console.error('Fetch column posts error:', error)
|
||
return []
|
||
}
|
||
}
|
||
|
||
export const addPostToColumn = async (columnId: number, postId: number): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/columns/${columnId}/posts`, {
|
||
method: 'POST',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify({ postId })
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const removePostFromColumn = async (columnId: number, postId: number): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/columns/${columnId}/posts/${postId}`, {
|
||
method: 'DELETE',
|
||
headers: getAuthHeaders()
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 标签管理API (复用现有 Tag 类型)
|
||
export const fetchTags = async (): Promise<Tag[]> => {
|
||
try {
|
||
const response = await fetch(`${API_BASE}/tags`)
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
return []
|
||
}
|
||
}
|
||
|
||
export const adminGetTags = async (): Promise<Tag[]> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/tags`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const adminGetTag = async (id: number): Promise<Tag> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/tags/${id}`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response) // Adapt to standard response
|
||
} catch (error) {
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const createTag = async (data: { name: string; slug: string }): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/tags`, {
|
||
method: 'POST',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(data)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const updateTag = async (id: number, data: { name: string; slug: string }): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/tags/${id}`, {
|
||
method: 'PUT',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(data)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const deleteTag = async (id: number): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/tags/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getAuthHeaders()
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 文章历史记录API
|
||
export const getPostHistory = async (postId: number | string): Promise<PostHistory[]> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/posts/${postId}/history`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
console.error('Get post history error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const getPostHistoryByVersion = async (postId: number | string, version: number): Promise<PostHistory> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/posts/${postId}/history/${version}`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Get post history by version error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const getPostHistoryDiff = async (
|
||
postId: number | string,
|
||
fromVersion: number,
|
||
toVersion: number
|
||
): Promise<PostHistoryDiff> => {
|
||
const response = await authFetch(
|
||
`${API_BASE}/admin/posts/${postId}/history/diff?from=${fromVersion}&to=${toVersion}`,
|
||
{ headers: getAuthHeaders() }
|
||
)
|
||
return await parseApiResponse(response)
|
||
}
|
||
|
||
export const restorePostHistory = async (postId: number | string, version: number): Promise<Post> => {
|
||
const response = await authFetch(`${API_BASE}/admin/posts/${postId}/history/${version}/restore`, {
|
||
method: 'POST',
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response)
|
||
}
|
||
|
||
export const getHotSearches = async (limit = 10, days = 30): Promise<HotSearchKeyword[]> => {
|
||
return (await fetchJson<HotSearchKeyword[]>(`${API_BASE}/search/hot?limit=${limit}&days=${days}`)) || []
|
||
}
|
||
|
||
// 代码片段管理API
|
||
export const getAdminSnippets = async (): Promise<Snippet[]> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/snippets`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
const data = await parseApiResponse<any>(response)
|
||
return (data?.list || []) as Snippet[]
|
||
} catch (error) {
|
||
console.error('Get admin snippets error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const fetchSnippets = async (): Promise<Snippet[]> => {
|
||
try {
|
||
const response = await fetch(`${API_BASE}/snippets`)
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
console.error('Error fetching snippets:', error)
|
||
return []
|
||
}
|
||
}
|
||
|
||
export const fetchSnippet = async (id: string): Promise<Snippet> => {
|
||
try {
|
||
const response = await fetch(`${API_BASE}/snippets/${id}`)
|
||
return await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error(`Error fetching snippet ${id}:`, error)
|
||
return {
|
||
id: id,
|
||
title: '默认代码片段',
|
||
code: 'console.log("Hello World");',
|
||
type: 'js'
|
||
}
|
||
}
|
||
}
|
||
|
||
export const createSnippet = async (snippetData: Omit<Snippet, 'id' | 'viewCount' | 'codeType' | 'type'> & { type?: string }): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/snippets`, {
|
||
method: 'POST',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(snippetData)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Create snippet error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const updateSnippet = async (id: string, snippetData: Omit<Snippet, 'id' | 'viewCount' | 'codeType' | 'type'> & { type?: string }): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/snippets/${id}`, {
|
||
method: 'PUT',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(snippetData)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Update snippet error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const deleteSnippet = async (id: string): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/snippets/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getAuthHeaders()
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Delete snippet error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 系统配置API
|
||
export const getSettings = async (): Promise<Setting[]> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/settings`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
const data = await parseApiResponse<Setting[]>(response)
|
||
if (!data) {
|
||
return []
|
||
}
|
||
return Array.isArray(data) ? data : []
|
||
} catch (error) {
|
||
console.error('Get settings error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const createSetting = async (settingData: Omit<Setting, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/settings`, {
|
||
method: 'POST',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(settingData)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Create setting error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const updateSetting = async (settingData: Omit<Setting, 'createdAt' | 'updatedAt'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/settings`, {
|
||
method: 'PUT',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(settingData)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Update setting error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const deleteSetting = async (keyName: string): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/settings/${keyName}`, {
|
||
method: 'DELETE',
|
||
headers: getAuthHeaders()
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Delete setting error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 公开设置API（前端使用，无需认证）
|
||
export interface PublicSettings {
|
||
site_title?: string
|
||
site_description?: string
|
||
site_author?: string
|
||
site_keywords?: string
|
||
visible_menus?: string
|
||
posts_per_page?: string
|
||
}
|
||
|
||
export const getPublicSettings = async (): Promise<PublicSettings> => {
|
||
try {
|
||
const response = await fetch(`${API_BASE}/settings`)
|
||
return await parseApiResponse(response) || {}
|
||
} catch (error) {
|
||
console.error('Get public settings error:', error)
|
||
// 返回空对象，前端使用默认值
|
||
return {}
|
||
}
|
||
}
|
||
|
||
// 操作日志筛选参数
|
||
export interface OperationLogFilters {
|
||
action?: string
|
||
method?: string
|
||
status?: number
|
||
userId?: number
|
||
startDate?: string
|
||
endDate?: string
|
||
}
|
||
|
||
// 操作日志API
|
||
export const getOperationLogs = async (
|
||
page: number = 1,
|
||
pageSize: number = 10,
|
||
filters: OperationLogFilters = {}
|
||
): Promise<PaginationResponse<OperationLog>> => {
|
||
try {
|
||
const qs = new URLSearchParams({ page: String(page), pageSize: String(pageSize) })
|
||
if (filters.action) qs.set('action', filters.action)
|
||
if (filters.method) qs.set('method', filters.method)
|
||
if (filters.status) qs.set('status', String(filters.status))
|
||
if (filters.userId) qs.set('userId', String(filters.userId))
|
||
if (filters.startDate) qs.set('startDate', filters.startDate)
|
||
if (filters.endDate) qs.set('endDate', filters.endDate)
|
||
const response = await authFetch(`${API_BASE}/admin/operation-logs?${qs}`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Get operation logs error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 访问日志类型
|
||
export interface AccessLog {
|
||
id: number
|
||
ip: string
|
||
userAgent: string
|
||
path: string
|
||
method: string
|
||
statusCode: number
|
||
responseTime: number
|
||
region: string
|
||
createdAt: string
|
||
}
|
||
|
||
// 访问日志筛选参数
|
||
export interface AccessLogFilters {
|
||
path?: string
|
||
region?: string
|
||
startDate?: string
|
||
endDate?: string
|
||
}
|
||
|
||
// 访问日志API
|
||
export const getAccessLogs = async (
|
||
page: number = 1,
|
||
pageSize: number = 10,
|
||
filters: AccessLogFilters = {}
|
||
): Promise<PaginationResponse<AccessLog>> => {
|
||
try {
|
||
const qs = new URLSearchParams({ page: String(page), pageSize: String(pageSize) })
|
||
if (filters.path) qs.set('path', filters.path)
|
||
if (filters.region) qs.set('region', filters.region)
|
||
if (filters.startDate) qs.set('startDate', filters.startDate)
|
||
if (filters.endDate) qs.set('endDate', filters.endDate)
|
||
const response = await authFetch(`${API_BASE}/admin/access-logs?${qs}`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Get access logs error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 文章访问记录类型（来自 user_access_logs 表）
|
||
export interface PostAccessLog {
|
||
id: number
|
||
userId: number
|
||
ip: string
|
||
region: string
|
||
articleId: number
|
||
createdAt: string
|
||
}
|
||
|
||
// 获取指定文章的访问记录
|
||
export const getPostAccessLogs = async (postId: number, page: number = 1, pageSize: number = 20): Promise<PaginationResponse<PostAccessLog>> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/posts/${postId}/access-logs?page=${page}&pageSize=${pageSize}`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Get post access logs error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 仪表盘数据类型
|
||
export interface DashboardStats {
|
||
users: number
|
||
posts: number
|
||
works: number
|
||
snippets: number
|
||
}
|
||
|
||
// 最近活动类型
|
||
export interface RecentActivity {
|
||
id: number
|
||
icon: string
|
||
text: string
|
||
time: string
|
||
}
|
||
|
||
// 仪表盘API
|
||
export const getDashboardStats = async (startDate?: string, endDate?: string): Promise<DashboardStats> => {
|
||
try {
|
||
let url = `${API_BASE}/admin/dashboard/stats`
|
||
const params = new URLSearchParams()
|
||
if (startDate) params.append('startDate', startDate)
|
||
if (endDate) params.append('endDate', endDate)
|
||
if (params.toString()) url += `?${params.toString()}`
|
||
|
||
return await authFetchJson<DashboardStats>(url, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
} catch (error) {
|
||
console.error('Get dashboard stats error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 获取最近活动
|
||
export const getRecentActivities = async (): Promise<RecentActivity[]> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/dashboard/activities`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
console.error('Get recent activities error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 关于页面相关类型
|
||
export interface Experience {
|
||
year: string
|
||
role: string
|
||
company: string
|
||
}
|
||
|
||
export interface AboutProfile {
|
||
id: number
|
||
name: string
|
||
avatar: string
|
||
location: string
|
||
bio: string
|
||
email: string
|
||
wechat: string
|
||
techStack: string[]
|
||
experiences: Experience[]
|
||
isPrimary: boolean
|
||
createdAt: string
|
||
updatedAt: string
|
||
}
|
||
|
||
// 关于页面API
|
||
export const fetchAboutProfile = async (): Promise<AboutProfile> => {
|
||
try {
|
||
const result = await fetchJson<AboutProfile>(`${API_BASE}/about`)
|
||
if (!result) {
|
||
throw new Error('个人资料数据为空')
|
||
}
|
||
// 确保 techStack 和 experiences 始终是数组
|
||
if (!Array.isArray(result.techStack)) {
|
||
result.techStack = []
|
||
}
|
||
if (!Array.isArray(result.experiences)) {
|
||
result.experiences = []
|
||
}
|
||
return result
|
||
} catch (error) {
|
||
console.error('Fetch about profile error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const getAdminAboutProfiles = async (): Promise<AboutProfile[]> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/about`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
console.error('Get admin about profiles error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const createAboutProfile = async (profileData: Omit<AboutProfile, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/about`, {
|
||
method: 'POST',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(profileData)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Create about profile error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const updateAboutProfile = async (id: number, profileData: Omit<AboutProfile, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/about/${id}`, {
|
||
method: 'PUT',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(profileData)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Update about profile error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const deleteAboutProfile = async (id: number): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/about/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getAuthHeaders()
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Delete about profile error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 客户评价相关类型
|
||
export interface Testimonial {
|
||
id: number
|
||
content: string
|
||
author: string
|
||
role: string
|
||
avatar: string
|
||
rating: number
|
||
createdAt: string
|
||
updatedAt: string
|
||
}
|
||
|
||
// 合作伙伴相关类型
|
||
export interface Partner {
|
||
id: number
|
||
name: string
|
||
logo: string
|
||
description: string
|
||
website: string
|
||
createdAt: string
|
||
updatedAt: string
|
||
}
|
||
|
||
// 客户评价API
|
||
export const fetchTestimonials = async (): Promise<Testimonial[]> => {
|
||
try {
|
||
const response = await fetch(`${API_BASE}/testimonials`)
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
console.error('Fetch testimonials error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const createTestimonial = async (data: Omit<Testimonial, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/testimonials`, {
|
||
method: 'POST',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(data)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Create testimonial error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const updateTestimonial = async (id: number, data: Omit<Testimonial, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/testimonials/${id}`, {
|
||
method: 'PUT',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(data)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Update testimonial error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const deleteTestimonial = async (id: number): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/testimonials/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getAuthHeaders()
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Delete testimonial error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 合作伙伴API
|
||
export const fetchPartners = async (): Promise<Partner[]> => {
|
||
try {
|
||
const response = await fetch(`${API_BASE}/partners`)
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
console.error('Fetch partners error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const createPartner = async (data: Omit<Partner, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/partners`, {
|
||
method: 'POST',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(data)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Create partner error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const updatePartner = async (id: number, data: Omit<Partner, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/partners/${id}`, {
|
||
method: 'PUT',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(data)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Update partner error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const deletePartner = async (id: number): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/partners/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getAuthHeaders()
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Delete partner error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 咨询相关类型
|
||
export interface Inquiry {
|
||
id?: number
|
||
name: string
|
||
company: string
|
||
contactMethod: string
|
||
contactValue: string
|
||
budget: string
|
||
description: string
|
||
status?: number // 0-Unread, 1-Read, 2-Contacted
|
||
createdAt?: string
|
||
}
|
||
|
||
// OSS配置相关类型
|
||
export interface OSSConfig {
|
||
id: number
|
||
name: string
|
||
storageType: string
|
||
// 通用字段（向后兼容）
|
||
accessKey?: string
|
||
secretKey?: string
|
||
bucket?: string
|
||
region?: string
|
||
domain?: string
|
||
// 阿里云OSS专用字段
|
||
ossAccessKeyId?: string
|
||
ossAccessKeySecret?: string
|
||
ossEndpoint?: string
|
||
ossBucket?: string
|
||
ossDomain?: string
|
||
// 腾讯云COS专用字段
|
||
qcloudSecretId?: string
|
||
qcloudSecretKey?: string
|
||
qcloudRegion?: string
|
||
qcloudBucket?: string
|
||
qcloudDomain?: string
|
||
// 七牛云专用字段
|
||
qiniuAccessKey?: string
|
||
qiniuSecretKey?: string
|
||
qiniuBucket?: string
|
||
qiniuRegion?: string
|
||
qiniuDomain?: string
|
||
isActive: number
|
||
createdAt: string
|
||
updatedAt: string
|
||
}
|
||
|
||
// 向后兼容的旧接口定义（已废弃，保留用于类型兼容）
|
||
export interface OSSConfigOld {
|
||
id: number
|
||
name: string
|
||
storageType: string // local/qcloud/aliyun/qiniu
|
||
accessKey: string // 加密存储，返回时显示为 ***
|
||
secretKey: string // 加密存储，返回时显示为 ***
|
||
bucket: string
|
||
region: string
|
||
domain: string
|
||
isActive: number
|
||
createdAt: string
|
||
updatedAt: string
|
||
}
|
||
|
||
export interface EmailSuffix {
|
||
id: number
|
||
suffix: string
|
||
isActive: boolean
|
||
sortOrder: number
|
||
createdAt: string
|
||
updatedAt: string
|
||
}
|
||
|
||
// 咨询相关API
|
||
export const submitInquiry = async (data: Inquiry): Promise<void> => {
|
||
try {
|
||
await fetchJson(`${API_BASE}/inquiries`, {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify(data)
|
||
})
|
||
} catch (error) {
|
||
console.error('Submit inquiry error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const fetchEmailSuffixes = async (): Promise<EmailSuffix[]> => {
|
||
try {
|
||
const response = await fetch(`${API_BASE}/email-suffixes`)
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
console.error('Fetch email suffixes error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const fetchInquiries = async (): Promise<Inquiry[]> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/inquiries`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
console.error('Fetch inquiries error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// OSS配置相关API
|
||
export const getOSSConfigs = async (): Promise<OSSConfig[]> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/oss-configs`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
console.error('Get OSS configs error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const createOSSConfig = async (configData: Omit<OSSConfig, 'id' | 'createdAt' | 'updatedAt'>): Promise<OSSConfig> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/oss-configs`, {
|
||
method: 'POST',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(configData)
|
||
})
|
||
return await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Create OSS config error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const updateOSSConfig = async (id: number, configData: Partial<Omit<OSSConfig, 'id' | 'createdAt' | 'updatedAt'>>): Promise<OSSConfig> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/oss-configs/${id}`, {
|
||
method: 'PUT',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(configData)
|
||
})
|
||
return await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Update OSS config error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const deleteOSSConfig = async (id: number): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/oss-configs/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getAuthHeaders()
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Delete OSS config error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 附件相关类型
|
||
export interface Attachment {
|
||
id: number
|
||
categoryId?: number
|
||
category?: {
|
||
id: number
|
||
name: string
|
||
}
|
||
originalName: string
|
||
storedName: string
|
||
filePath: string
|
||
fileUrl: string
|
||
fileSize: number
|
||
fileType: string
|
||
mimeType: string
|
||
storageType: string
|
||
ossConfigId?: number
|
||
createdAt: string
|
||
updatedAt: string
|
||
}
|
||
|
||
// 附件分类相关类型
|
||
export interface AttachmentCategory {
|
||
id: number
|
||
name: string
|
||
description: string
|
||
sortOrder: number
|
||
createdAt: string
|
||
updatedAt: string
|
||
}
|
||
|
||
// 附件管理API
|
||
export const getAdminAttachments = async (params?: {
|
||
page?: number
|
||
pageSize?: number
|
||
categoryId?: number
|
||
fileType?: string
|
||
keyword?: string
|
||
}): Promise<{ list: Attachment[], total: number, page: number, size: number }> => {
|
||
try {
|
||
const queryParams = new URLSearchParams()
|
||
if (params?.page) queryParams.append('page', params.page.toString())
|
||
if (params?.pageSize) queryParams.append('pageSize', params.pageSize.toString())
|
||
if (params?.categoryId) queryParams.append('categoryId', params.categoryId.toString())
|
||
if (params?.fileType) queryParams.append('fileType', params.fileType)
|
||
if (params?.keyword) queryParams.append('keyword', params.keyword)
|
||
|
||
const url = `${API_BASE}/admin/attachments${queryParams.toString() ? '?' + queryParams.toString() : ''}`
|
||
const data = await authFetchJson<PaginationResponse<Attachment>>(url, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return {
|
||
list: data?.list || [],
|
||
total: data?.total || 0,
|
||
page: data?.page || 1,
|
||
size: data?.size || 20
|
||
}
|
||
} catch (error) {
|
||
console.error('Get admin attachments error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const updateAttachment = async (id: number, data: { categoryId?: number | null }): Promise<Attachment> => {
|
||
try {
|
||
return await authFetchJson<Attachment>(`${API_BASE}/admin/attachments/${id}`, {
|
||
method: 'PUT',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(data)
|
||
})
|
||
} catch (error) {
|
||
console.error('Update attachment error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 附件分类管理API
|
||
export const getAttachmentCategories = async (): Promise<AttachmentCategory[]> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/attachment-categories`, {
|
||
headers: getAuthHeaders()
|
||
})
|
||
return await parseApiResponse(response) || []
|
||
} catch (error) {
|
||
console.error('Get attachment categories error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const createAttachmentCategory = async (categoryData: Omit<AttachmentCategory, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/attachment-categories`, {
|
||
method: 'POST',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(categoryData)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Create attachment category error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const updateAttachmentCategory = async (id: number, categoryData: Partial<Omit<AttachmentCategory, 'id' | 'createdAt' | 'updatedAt'>>): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/attachment-categories/${id}`, {
|
||
method: 'PUT',
|
||
headers: getAuthHeaders(),
|
||
body: JSON.stringify(categoryData)
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Update attachment category error:', error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export const deleteAttachmentCategory = async (id: number): Promise<void> => {
|
||
try {
|
||
const response = await authFetch(`${API_BASE}/admin/attachment-categories/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getAuthHeaders()
|
||
})
|
||
await parseApiResponse(response)
|
||
} catch (error) {
|
||
console.error('Delete attachment category error:', error)
|
||
throw error
|
||
}
|
||
}
|