395 lines
11 KiB
TypeScript
395 lines
11 KiB
TypeScript
import type { ApiError, ApiErrorDetail } from '../types';
|
|
|
|
const TOKEN_KEY = 'capacity_report_token';
|
|
const DESKTOP_API_BASE = 'http://127.0.0.1:9081';
|
|
const API_BASE = resolveApiBase();
|
|
const API_FETCH_RETRIES = 8;
|
|
const API_FETCH_RETRY_DELAY_MS = 500;
|
|
const TAURI_HTTP_ERROR_PREFIX = 'CAPAREPORT_HTTP_ERROR:';
|
|
let onUnauthorized: (() => void) | null = null;
|
|
let cachedTauriInvoke: TauriInvoke | null = null;
|
|
|
|
type TauriInvoke = <T>(command: string, args?: Record<string, unknown>) => Promise<T>;
|
|
|
|
export interface DownloadResult {
|
|
saved: boolean;
|
|
path?: string;
|
|
}
|
|
|
|
interface TauriDownloadHeader {
|
|
name: string;
|
|
value: string;
|
|
}
|
|
|
|
interface TauriDownloadRequest {
|
|
url: string;
|
|
method: 'GET' | 'POST';
|
|
filename: string;
|
|
headers: TauriDownloadHeader[];
|
|
body?: string;
|
|
}
|
|
|
|
interface TauriDownloadResult {
|
|
saved: boolean;
|
|
path?: string;
|
|
}
|
|
|
|
export class ApiRequestError extends Error {
|
|
status: number;
|
|
code?: string;
|
|
detail?: ApiErrorDetail;
|
|
|
|
constructor(message: string, status: number, detail?: ApiErrorDetail) {
|
|
super(message);
|
|
this.name = 'ApiRequestError';
|
|
this.status = status;
|
|
this.code = detail?.code;
|
|
this.detail = detail;
|
|
}
|
|
}
|
|
|
|
export function getToken(): string {
|
|
return localStorage.getItem(TOKEN_KEY) || '';
|
|
}
|
|
|
|
export function setToken(token: string): void {
|
|
localStorage.setItem(TOKEN_KEY, token);
|
|
document.cookie = `token=${token}; path=/; max-age=${60 * 60 * 24 * 30}`;
|
|
}
|
|
|
|
export function clearToken(): void {
|
|
localStorage.removeItem(TOKEN_KEY);
|
|
document.cookie = 'token=; path=/; max-age=0';
|
|
}
|
|
|
|
export function setUnauthorizedHandler(handler: () => void): void {
|
|
onUnauthorized = handler;
|
|
}
|
|
|
|
export async function apiGet<T>(url: string): Promise<T> {
|
|
return request<T>(url, { method: 'GET' });
|
|
}
|
|
|
|
export async function apiPost<T>(url: string, body?: unknown): Promise<T> {
|
|
return request<T>(url, {
|
|
method: 'POST',
|
|
body: body === undefined ? undefined : JSON.stringify(body),
|
|
headers: { 'Content-Type': 'application/json' }
|
|
});
|
|
}
|
|
|
|
export async function request<T>(url: string, init: RequestInit = {}): Promise<T> {
|
|
const headers = new Headers(init.headers);
|
|
const token = isLoginRequest(url) ? '' : getToken();
|
|
if (token) {
|
|
headers.set('Authorization', `Bearer ${token}`);
|
|
}
|
|
|
|
const response = await fetchWithRetry(apiUrl(url), { ...init, headers });
|
|
if (response.status === 401) {
|
|
if (isLoginRequest(url)) {
|
|
const error = await readError(response);
|
|
throw new ApiRequestError(error.message, response.status, error.detail);
|
|
}
|
|
|
|
clearToken();
|
|
onUnauthorized?.();
|
|
throw new ApiRequestError('登录已过期，请重新登录', response.status, {
|
|
code: 'UNAUTHORIZED',
|
|
message: '登录已过期，请重新登录'
|
|
});
|
|
}
|
|
|
|
if (!response.ok) {
|
|
const error = await readError(response);
|
|
throw new ApiRequestError(error.message, response.status, error.detail);
|
|
}
|
|
|
|
return response.json() as Promise<T>;
|
|
}
|
|
|
|
export function upload<T>(
|
|
url: string,
|
|
formData: FormData,
|
|
onProgress?: (percent: number) => void
|
|
): Promise<T> {
|
|
return new Promise((resolve, reject) => {
|
|
const xhr = new XMLHttpRequest();
|
|
xhr.open('POST', apiUrl(url));
|
|
|
|
const token = getToken();
|
|
if (token) {
|
|
xhr.setRequestHeader('Authorization', `Bearer ${token}`);
|
|
}
|
|
|
|
xhr.upload.addEventListener('progress', event => {
|
|
if (event.lengthComputable) {
|
|
onProgress?.(Math.round((event.loaded / event.total) * 100));
|
|
}
|
|
});
|
|
|
|
xhr.addEventListener('load', () => {
|
|
if (xhr.status === 401) {
|
|
clearToken();
|
|
onUnauthorized?.();
|
|
reject(
|
|
new ApiRequestError('登录已过期，请重新登录', xhr.status, {
|
|
code: 'UNAUTHORIZED',
|
|
message: '登录已过期，请重新登录'
|
|
})
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (xhr.status < 200 || xhr.status >= 300) {
|
|
reject(new Error(parseXhrError(xhr.responseText)));
|
|
return;
|
|
}
|
|
|
|
resolve(JSON.parse(xhr.responseText) as T);
|
|
});
|
|
|
|
xhr.addEventListener('error', () => reject(new Error('网络错误')));
|
|
xhr.send(formData);
|
|
});
|
|
}
|
|
|
|
export async function download(url: string, body: unknown, filename: string): Promise<DownloadResult> {
|
|
const headers = new Headers({ 'Content-Type': 'application/json' });
|
|
const token = getToken();
|
|
if (token) {
|
|
headers.set('Authorization', `Bearer ${token}`);
|
|
}
|
|
|
|
if (isTauriRuntime()) {
|
|
return await downloadWithTauri({
|
|
url: apiUrl(url),
|
|
method: 'POST',
|
|
filename,
|
|
headers: headersToPairs(headers),
|
|
body: JSON.stringify(body)
|
|
});
|
|
}
|
|
|
|
const response = await fetchWithRetry(apiUrl(url), {
|
|
method: 'POST',
|
|
headers,
|
|
body: JSON.stringify(body)
|
|
});
|
|
|
|
if (!response.ok) {
|
|
const error = await readError(response);
|
|
throw new ApiRequestError(error.message, response.status, error.detail);
|
|
}
|
|
|
|
return await saveBlobResponse(response, parseFilename(response.headers.get('content-disposition')) || filename);
|
|
}
|
|
|
|
export async function downloadGet(url: string, fallbackFilename: string): Promise<DownloadResult> {
|
|
const headers = new Headers();
|
|
const token = getToken();
|
|
if (token) {
|
|
headers.set('Authorization', `Bearer ${token}`);
|
|
}
|
|
|
|
if (isTauriRuntime()) {
|
|
return await downloadWithTauri({
|
|
url: apiUrl(url),
|
|
method: 'GET',
|
|
filename: fallbackFilename,
|
|
headers: headersToPairs(headers)
|
|
});
|
|
}
|
|
|
|
const response = await fetchWithRetry(apiUrl(url), { headers });
|
|
if (response.status === 401) {
|
|
clearToken();
|
|
onUnauthorized?.();
|
|
throw new ApiRequestError('登录已过期，请重新登录', response.status, {
|
|
code: 'UNAUTHORIZED',
|
|
message: '登录已过期，请重新登录'
|
|
});
|
|
}
|
|
|
|
if (!response.ok) {
|
|
const error = await readError(response);
|
|
throw new ApiRequestError(error.message, response.status, error.detail);
|
|
}
|
|
|
|
const filename = parseFilename(response.headers.get('content-disposition')) || fallbackFilename;
|
|
return await saveBlobResponse(response, filename);
|
|
}
|
|
|
|
async function readError(response: Response): Promise<{ message: string; detail?: ApiErrorDetail }> {
|
|
try {
|
|
const data = (await response.json()) as ApiError;
|
|
return parseApiError(data, response.statusText);
|
|
} catch {
|
|
return { message: response.statusText || '请求失败' };
|
|
}
|
|
}
|
|
|
|
function parseXhrError(text: string): string {
|
|
try {
|
|
const data = JSON.parse(text) as ApiError;
|
|
return parseApiError(data, '请求失败').message;
|
|
} catch {
|
|
return text || '请求失败';
|
|
}
|
|
}
|
|
|
|
function parseApiError(data: ApiError, fallback: string): { message: string; detail?: ApiErrorDetail } {
|
|
if (typeof data.detail === 'object' && data.detail !== null) {
|
|
return {
|
|
message: data.detail.message || data.message || data.error || fallback,
|
|
detail: data.detail
|
|
};
|
|
}
|
|
|
|
return {
|
|
message: data.detail || data.error || data.message || fallback,
|
|
detail: data.code ? { code: data.code, message: data.message || data.error } : undefined
|
|
};
|
|
}
|
|
|
|
async function saveBlobResponse(response: Response, filename: string): Promise<DownloadResult> {
|
|
const blob = await response.blob();
|
|
const objectUrl = URL.createObjectURL(blob);
|
|
const link = document.createElement('a');
|
|
link.href = objectUrl;
|
|
link.download = filename;
|
|
link.click();
|
|
URL.revokeObjectURL(objectUrl);
|
|
return { saved: true };
|
|
}
|
|
|
|
async function downloadWithTauri(request: TauriDownloadRequest): Promise<DownloadResult> {
|
|
try {
|
|
const invoke = await getTauriInvoke();
|
|
const result = await invoke<TauriDownloadResult>('download_to_file', { request });
|
|
return { saved: result.saved, path: result.path };
|
|
} catch (error) {
|
|
throw parseTauriDownloadError(error);
|
|
}
|
|
}
|
|
|
|
export async function openPathInFileManager(path: string): Promise<void> {
|
|
if (!isTauriRuntime()) return;
|
|
const invoke = await getTauriInvoke();
|
|
await invoke('open_path_in_file_manager', { path });
|
|
}
|
|
|
|
async function getTauriInvoke(): Promise<TauriInvoke> {
|
|
if (!cachedTauriInvoke) {
|
|
const api = await import('@tauri-apps/api/core');
|
|
cachedTauriInvoke = api.invoke;
|
|
}
|
|
return cachedTauriInvoke;
|
|
}
|
|
|
|
function headersToPairs(headers: Headers): TauriDownloadHeader[] {
|
|
const pairs: TauriDownloadHeader[] = [];
|
|
headers.forEach((value, name) => {
|
|
pairs.push({ name, value });
|
|
});
|
|
return pairs;
|
|
}
|
|
|
|
function parseTauriDownloadError(error: unknown): Error {
|
|
const message = error instanceof Error ? error.message : String(error || '下载失败');
|
|
if (!message.startsWith(TAURI_HTTP_ERROR_PREFIX)) {
|
|
return error instanceof Error ? error : new Error(message);
|
|
}
|
|
|
|
const payload = message.slice(TAURI_HTTP_ERROR_PREFIX.length);
|
|
const separator = payload.indexOf(':');
|
|
const status = Number(payload.slice(0, separator));
|
|
const body = separator >= 0 ? payload.slice(separator + 1) : '';
|
|
const parsed = parseApiErrorText(body, `下载失败 (${status || 'HTTP'})`);
|
|
|
|
if (status === 401) {
|
|
clearToken();
|
|
onUnauthorized?.();
|
|
}
|
|
|
|
return new ApiRequestError(parsed.message, status || 500, parsed.detail);
|
|
}
|
|
|
|
function parseApiErrorText(text: string, fallback: string): { message: string; detail?: ApiErrorDetail } {
|
|
try {
|
|
const data = JSON.parse(text) as ApiError;
|
|
return parseApiError(data, fallback);
|
|
} catch {
|
|
return { message: text || fallback };
|
|
}
|
|
}
|
|
|
|
async function fetchWithRetry(url: string, init: RequestInit): Promise<Response> {
|
|
let lastError: unknown;
|
|
for (let attempt = 0; attempt <= API_FETCH_RETRIES; attempt += 1) {
|
|
try {
|
|
return await fetch(url, init);
|
|
} catch (error) {
|
|
lastError = error;
|
|
if (attempt === API_FETCH_RETRIES) {
|
|
break;
|
|
}
|
|
await sleep(API_FETCH_RETRY_DELAY_MS);
|
|
}
|
|
}
|
|
|
|
throw lastError instanceof Error ? lastError : new Error('网络请求失败');
|
|
}
|
|
|
|
function sleep(ms: number): Promise<void> {
|
|
return new Promise(resolve => window.setTimeout(resolve, ms));
|
|
}
|
|
|
|
function parseFilename(disposition: string | null): string {
|
|
if (!disposition) return '';
|
|
|
|
const utf8Match = disposition.match(/filename\*=UTF-8''([^;]+)/i);
|
|
if (utf8Match?.[1]) {
|
|
return decodeURIComponent(utf8Match[1]);
|
|
}
|
|
|
|
const plainMatch = disposition.match(/filename="?([^";]+)"?/i);
|
|
return plainMatch?.[1] || '';
|
|
}
|
|
|
|
export function apiUrl(url: string): string {
|
|
if (!API_BASE || /^https?:\/\//i.test(url)) {
|
|
return url;
|
|
}
|
|
return `${API_BASE}${url.startsWith('/') ? url : `/${url}`}`;
|
|
}
|
|
|
|
export function getApiBaseUrl(): string {
|
|
return API_BASE || window.location.origin;
|
|
}
|
|
|
|
function resolveApiBase(): string {
|
|
const configured = (import.meta.env.VITE_API_BASE || '').replace(/\/$/, '');
|
|
if (configured) {
|
|
return configured;
|
|
}
|
|
return isTauriRuntime() ? DESKTOP_API_BASE : '';
|
|
}
|
|
|
|
function isTauriRuntime(): boolean {
|
|
const win = window as Window & {
|
|
__TAURI__?: unknown;
|
|
__TAURI_INTERNALS__?: unknown;
|
|
};
|
|
return Boolean(win.__TAURI__ || win.__TAURI_INTERNALS__ || navigator.userAgent.includes('Tauri'));
|
|
}
|
|
|
|
function isLoginRequest(url: string): boolean {
|
|
try {
|
|
const parsed = new URL(url, window.location.origin);
|
|
return parsed.pathname === '/api/login';
|
|
} catch {
|
|
return url.replace(/^https?:\/\/[^/]+/i, '').split('?')[0] === '/api/login';
|
|
}
|
|
}
|