mirror of
https://github.com/router-for-me/Cli-Proxy-API-Management-Center.git
synced 2026-02-03 11:20:50 +08:00
1045 lines
40 KiB
JavaScript
1045 lines
40 KiB
JavaScript
export const authFilesModule = {
|
|
// 加载认证文件
|
|
async loadAuthFiles(keyStats = null) {
|
|
try {
|
|
const data = await this.makeRequest('/auth-files');
|
|
if (!keyStats) {
|
|
keyStats = await this.getKeyStats();
|
|
}
|
|
await this.renderAuthFiles(data.files || [], keyStats);
|
|
} catch (error) {
|
|
console.error('加载认证文件失败:', error);
|
|
}
|
|
},
|
|
|
|
// 渲染认证文件列表
|
|
async renderAuthFiles(files, keyStats = null) {
|
|
const container = document.getElementById('auth-files-list');
|
|
if (!container) {
|
|
return;
|
|
}
|
|
|
|
const allFiles = Array.isArray(files) ? files : [];
|
|
const visibleFiles = allFiles.filter(file => {
|
|
if (!file) return false;
|
|
return this.shouldDisplayDisabledGeminiCli(file) || file.disabled !== true;
|
|
});
|
|
const stats = keyStats || await this.getKeyStats();
|
|
|
|
this.cachedAuthFiles = visibleFiles.map(file => ({ ...file }));
|
|
this.authFileStatsCache = stats || { bySource: {}, byAuthIndex: {} };
|
|
this.syncAuthFileControls();
|
|
|
|
if (this.cachedAuthFiles.length === 0) {
|
|
container.innerHTML = `
|
|
<div class="empty-state">
|
|
<i class="fas fa-file-alt"></i>
|
|
<h3>${i18n.t('auth_files.empty_title')}</h3>
|
|
<p>${i18n.t('auth_files.empty_desc')}</p>
|
|
</div>
|
|
`;
|
|
this.updateFilterButtons(new Set(['all']));
|
|
this.bindAuthFileFilterEvents();
|
|
this.applyAuthFileFilterState(false);
|
|
this.authFilesPagination.currentPage = 1;
|
|
this.authFilesPagination.totalPages = 1;
|
|
this.updatePaginationControls(0);
|
|
return;
|
|
}
|
|
|
|
const existingTypes = new Set(['all']);
|
|
this.cachedAuthFiles.forEach(file => {
|
|
if (file.type) {
|
|
existingTypes.add(file.type);
|
|
}
|
|
});
|
|
|
|
this.updateFilterButtons(existingTypes);
|
|
this.bindAuthFileFilterEvents();
|
|
this.applyAuthFileFilterState(false);
|
|
this.renderAuthFilesPage(this.authFilesPagination.currentPage);
|
|
this.bindAuthFileActionEvents();
|
|
},
|
|
|
|
isRuntimeOnlyAuthFile(file) {
|
|
if (!file) return false;
|
|
const runtimeValue = file.runtime_only;
|
|
return runtimeValue === true || runtimeValue === 'true';
|
|
},
|
|
|
|
shouldDisplayDisabledGeminiCli(file) {
|
|
if (!file) return false;
|
|
const provider = typeof file.provider === 'string' ? file.provider.toLowerCase() : '';
|
|
const type = typeof file.type === 'string' ? file.type.toLowerCase() : '';
|
|
const isGeminiCli = provider === 'gemini-cli' || type === 'gemini-cli';
|
|
return isGeminiCli && !this.isRuntimeOnlyAuthFile(file);
|
|
},
|
|
|
|
resolveAuthFileStats(file, stats = {}) {
|
|
const statsBySource = (stats && stats.bySource) || stats || {};
|
|
const statsByAuthIndex = (stats && stats.byAuthIndex) || {};
|
|
const rawFileName = typeof file?.name === 'string' ? file.name : '';
|
|
const defaultStats = { success: 0, failure: 0 };
|
|
const authIndexKey = this.normalizeAuthIndexValue(file?.auth_index);
|
|
|
|
if (authIndexKey && statsByAuthIndex[authIndexKey]) {
|
|
return statsByAuthIndex[authIndexKey];
|
|
}
|
|
|
|
if (!rawFileName) {
|
|
return defaultStats;
|
|
}
|
|
|
|
const fromName = statsBySource[rawFileName];
|
|
if (fromName && (fromName.success > 0 || fromName.failure > 0)) {
|
|
return fromName;
|
|
}
|
|
|
|
let fileStats = fromName || defaultStats;
|
|
if (fileStats.success === 0 && fileStats.failure === 0) {
|
|
const nameWithoutExt = rawFileName.replace(/\.[^/.]+$/, "");
|
|
|
|
if (nameWithoutExt && nameWithoutExt !== rawFileName) {
|
|
const candidateNames = new Set([nameWithoutExt]);
|
|
const normalizedName = nameWithoutExt.toLowerCase();
|
|
const typePrefix = typeof file?.type === 'string' ? file.type.trim().toLowerCase() : '';
|
|
const providerPrefix = typeof file?.provider === 'string' ? file.provider.trim().toLowerCase() : '';
|
|
const prefixList = [];
|
|
|
|
if (typePrefix) {
|
|
prefixList.push(`${typePrefix}-`);
|
|
}
|
|
if (providerPrefix && providerPrefix !== typePrefix) {
|
|
prefixList.push(`${providerPrefix}-`);
|
|
}
|
|
|
|
prefixList.forEach(prefix => {
|
|
if (prefix && normalizedName.startsWith(prefix)) {
|
|
const trimmed = nameWithoutExt.substring(prefix.length);
|
|
if (trimmed) {
|
|
candidateNames.add(trimmed);
|
|
}
|
|
}
|
|
});
|
|
|
|
for (const candidate of candidateNames) {
|
|
const candidateStats = statsBySource[candidate];
|
|
if (candidateStats && (candidateStats.success > 0 || candidateStats.failure > 0)) {
|
|
fileStats = candidateStats;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return fileStats || defaultStats;
|
|
},
|
|
|
|
normalizeAuthIndexValue(value) {
|
|
if (typeof value === 'number' && Number.isFinite(value)) {
|
|
return value.toString();
|
|
}
|
|
if (typeof value === 'string') {
|
|
const trimmed = value.trim();
|
|
return trimmed ? trimmed : null;
|
|
}
|
|
return null;
|
|
},
|
|
|
|
buildAuthFileItemHtml(file) {
|
|
const rawFileName = typeof file?.name === 'string' ? file.name : '';
|
|
const safeFileName = this.escapeHtml(rawFileName);
|
|
const stats = this.authFileStatsCache || {};
|
|
const fileStats = this.resolveAuthFileStats(file, stats);
|
|
const fileType = file.type || 'unknown';
|
|
let typeDisplayKey;
|
|
switch (fileType) {
|
|
case 'qwen':
|
|
typeDisplayKey = 'auth_files.type_qwen';
|
|
break;
|
|
case 'gemini':
|
|
typeDisplayKey = 'auth_files.type_gemini';
|
|
break;
|
|
case 'gemini-cli':
|
|
typeDisplayKey = 'auth_files.type_gemini-cli';
|
|
break;
|
|
case 'aistudio':
|
|
typeDisplayKey = 'auth_files.type_aistudio';
|
|
break;
|
|
case 'claude':
|
|
typeDisplayKey = 'auth_files.type_claude';
|
|
break;
|
|
case 'codex':
|
|
typeDisplayKey = 'auth_files.type_codex';
|
|
break;
|
|
case 'iflow':
|
|
typeDisplayKey = 'auth_files.type_iflow';
|
|
break;
|
|
case 'vertex':
|
|
typeDisplayKey = 'auth_files.type_vertex';
|
|
break;
|
|
case 'empty':
|
|
typeDisplayKey = 'auth_files.type_empty';
|
|
break;
|
|
default:
|
|
typeDisplayKey = 'auth_files.type_unknown';
|
|
break;
|
|
}
|
|
const typeBadge = `<span class="file-type-badge ${fileType}">${i18n.t(typeDisplayKey)}</span>`;
|
|
const isRuntimeOnly = this.isRuntimeOnlyAuthFile(file);
|
|
const shouldShowMainFlag = this.shouldDisplayDisabledGeminiCli(file);
|
|
const mainFlagButton = shouldShowMainFlag ? `
|
|
<button class="btn-small btn-warning main-flag-btn" title="主" disabled>主</button>` : '';
|
|
const actionsHtml = isRuntimeOnly ? `
|
|
<div class="item-actions">
|
|
<span class="virtual-auth-badge">虚拟认证文件</span>
|
|
</div>` : `
|
|
<div class="item-actions" data-filename="${safeFileName}">
|
|
${mainFlagButton}
|
|
<button class="btn-small btn-info" data-action="showDetails" title="详细信息">
|
|
<i class="fas fa-info-circle"></i>
|
|
</button>
|
|
<button class="btn-small btn-primary" data-action="download" title="下载">
|
|
<i class="fas fa-download"></i>
|
|
</button>
|
|
<button class="btn-small btn-danger" data-action="delete" title="删除">
|
|
<i class="fas fa-trash"></i>
|
|
</button>
|
|
</div>`;
|
|
|
|
return `
|
|
<div class="file-item" data-file-type="${fileType}" data-file-name="${safeFileName}" ${isRuntimeOnly ? 'data-runtime-only="true"' : ''}>
|
|
<div class="item-content">
|
|
<div class="item-title">${typeBadge}${safeFileName}</div>
|
|
<div class="item-meta">
|
|
<span class="item-subtitle">${i18n.t('auth_files.file_modified')}: ${new Date(file.modtime).toLocaleString(i18n.currentLanguage === 'zh-CN' ? 'zh-CN' : 'en-US')}</span>
|
|
<span class="item-subtitle">${i18n.t('auth_files.file_size')}: ${this.formatFileSize(file.size)}</span>
|
|
</div>
|
|
<div class="item-footer">
|
|
<div class="item-stats">
|
|
<span class="stat-badge stat-success">
|
|
<i class="fas fa-check-circle"></i> ${i18n.t('stats.success')}: ${fileStats.success}
|
|
</span>
|
|
<span class="stat-badge stat-failure">
|
|
<i class="fas fa-times-circle"></i> ${i18n.t('stats.failure')}: ${fileStats.failure}
|
|
</span>
|
|
</div>
|
|
${actionsHtml}
|
|
</div>
|
|
</div>
|
|
</div>
|
|
`;
|
|
},
|
|
|
|
getFilteredAuthFiles(filterType = this.currentAuthFileFilter) {
|
|
const files = Array.isArray(this.cachedAuthFiles) ? this.cachedAuthFiles : [];
|
|
if (!files.length) {
|
|
return [];
|
|
}
|
|
|
|
const typeFilter = (filterType || 'all').toLowerCase();
|
|
const keyword = (this.authFileSearchQuery || '').trim().toLowerCase();
|
|
|
|
return files.filter(file => {
|
|
const name = String(file?.name || '').toLowerCase();
|
|
const type = String(file?.type || '').toLowerCase();
|
|
const provider = String(file?.provider || '').toLowerCase();
|
|
|
|
if (typeFilter !== 'all') {
|
|
if (!type) return false;
|
|
if (type !== typeFilter) {
|
|
if (!provider || provider !== typeFilter) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!keyword) return true;
|
|
return name.includes(keyword) || type.includes(keyword) || provider.includes(keyword);
|
|
});
|
|
},
|
|
|
|
updateAuthFileSearchQuery(value = '') {
|
|
const normalized = (value || '').trim();
|
|
if (this.authFileSearchQuery === normalized) {
|
|
return;
|
|
}
|
|
this.authFileSearchQuery = normalized;
|
|
this.authFilesPagination.currentPage = 1;
|
|
this.renderAuthFilesPage(1);
|
|
},
|
|
|
|
updateAuthFilesPageSize(value) {
|
|
const normalized = this.normalizeAuthFilesPageSize(value);
|
|
if (this.authFilesPagination?.pageSize === normalized) {
|
|
this.syncAuthFileControls();
|
|
return;
|
|
}
|
|
this.authFilesPagination.pageSize = normalized;
|
|
this.authFilesPagination.currentPage = 1;
|
|
try {
|
|
localStorage.setItem(this.authFilesPageSizeKey, `${normalized}`);
|
|
} catch (error) {
|
|
console.warn('Failed to persist auth files page size:', error);
|
|
}
|
|
this.syncAuthFileControls();
|
|
this.renderAuthFilesPage(1);
|
|
},
|
|
|
|
syncAuthFileControls() {
|
|
const searchInput = document.getElementById('auth-files-search-input');
|
|
if (searchInput && searchInput.value !== this.authFileSearchQuery) {
|
|
searchInput.value = this.authFileSearchQuery;
|
|
}
|
|
|
|
const pageSizeInput = document.getElementById('auth-files-page-size-input');
|
|
const targetSize = this.authFilesPagination?.pageSize || 9;
|
|
if (pageSizeInput && parseInt(pageSizeInput.value, 10) !== targetSize) {
|
|
pageSizeInput.value = targetSize;
|
|
}
|
|
},
|
|
|
|
bindAuthFilesSearchControl() {
|
|
const searchInput = document.getElementById('auth-files-search-input');
|
|
if (!searchInput) return;
|
|
|
|
if (searchInput._authFileSearchListener) {
|
|
searchInput.removeEventListener('input', searchInput._authFileSearchListener);
|
|
}
|
|
|
|
const debounced = this.debounce((value) => {
|
|
this.updateAuthFileSearchQuery(value);
|
|
}, 250);
|
|
|
|
const listener = (event) => {
|
|
const value = event?.target?.value ?? '';
|
|
debounced(value);
|
|
};
|
|
|
|
searchInput._authFileSearchListener = listener;
|
|
searchInput.addEventListener('input', listener);
|
|
},
|
|
|
|
bindAuthFilesPageSizeControl() {
|
|
const pageSizeInput = document.getElementById('auth-files-page-size-input');
|
|
if (!pageSizeInput) return;
|
|
|
|
if (pageSizeInput._authFilePageSizeListener) {
|
|
pageSizeInput.removeEventListener('change', pageSizeInput._authFilePageSizeListener);
|
|
}
|
|
|
|
const listener = (event) => {
|
|
const value = parseInt(event?.target?.value, 10);
|
|
if (!Number.isFinite(value)) {
|
|
return;
|
|
}
|
|
this.updateAuthFilesPageSize(value);
|
|
};
|
|
|
|
pageSizeInput._authFilePageSizeListener = listener;
|
|
pageSizeInput.addEventListener('change', listener);
|
|
|
|
if (pageSizeInput._authFilePageSizeBlur) {
|
|
pageSizeInput.removeEventListener('blur', pageSizeInput._authFilePageSizeBlur);
|
|
}
|
|
|
|
const blurListener = () => {
|
|
if (!pageSizeInput.value) {
|
|
this.syncAuthFileControls();
|
|
}
|
|
};
|
|
|
|
pageSizeInput._authFilePageSizeBlur = blurListener;
|
|
pageSizeInput.addEventListener('blur', blurListener);
|
|
},
|
|
|
|
renderAuthFilesPage(page = null) {
|
|
const container = document.getElementById('auth-files-list');
|
|
if (!container) return;
|
|
|
|
const pageSize = this.authFilesPagination?.pageSize || 9;
|
|
const filteredFiles = this.getFilteredAuthFiles();
|
|
const totalItems = filteredFiles.length;
|
|
const hasCachedFiles = Array.isArray(this.cachedAuthFiles) && this.cachedAuthFiles.length > 0;
|
|
const filterApplied = (this.currentAuthFileFilter && this.currentAuthFileFilter !== 'all');
|
|
const searchApplied = Boolean((this.authFileSearchQuery || '').trim());
|
|
|
|
if (totalItems === 0) {
|
|
const titleKey = hasCachedFiles && (filterApplied || searchApplied)
|
|
? 'auth_files.search_empty_title'
|
|
: 'auth_files.empty_title';
|
|
const descKey = hasCachedFiles && (filterApplied || searchApplied)
|
|
? 'auth_files.search_empty_desc'
|
|
: 'auth_files.empty_desc';
|
|
container.innerHTML = `
|
|
<div class="empty-state">
|
|
<i class="fas fa-file-alt"></i>
|
|
<h3>${i18n.t(titleKey)}</h3>
|
|
<p>${i18n.t(descKey)}</p>
|
|
</div>
|
|
`;
|
|
this.authFilesPagination.currentPage = 1;
|
|
this.updatePaginationControls(0);
|
|
return;
|
|
}
|
|
|
|
const maxPages = Math.max(1, Math.ceil(totalItems / pageSize));
|
|
let currentPage = page == null ? (this.authFilesPagination.currentPage || 1) : page;
|
|
if (currentPage > maxPages) {
|
|
currentPage = maxPages;
|
|
}
|
|
if (currentPage < 1) {
|
|
currentPage = 1;
|
|
}
|
|
this.authFilesPagination.currentPage = currentPage;
|
|
this.authFilesPagination.totalPages = maxPages;
|
|
|
|
const startIndex = (currentPage - 1) * pageSize;
|
|
const pageFiles = filteredFiles.slice(startIndex, startIndex + pageSize);
|
|
|
|
container.innerHTML = pageFiles.map(file => this.buildAuthFileItemHtml(file)).join('');
|
|
this.updatePaginationControls(totalItems);
|
|
this.bindAuthFileActionEvents();
|
|
},
|
|
|
|
bindAuthFilesPaginationEvents() {
|
|
const container = document.getElementById('auth-files-pagination');
|
|
if (!container) return;
|
|
|
|
const oldListener = container._paginationListener;
|
|
if (oldListener) {
|
|
container.removeEventListener('click', oldListener);
|
|
}
|
|
|
|
const listener = (event) => {
|
|
const button = event.target.closest('button[data-action]');
|
|
if (!button || !container.contains(button)) return;
|
|
event.preventDefault();
|
|
const action = button.dataset.action;
|
|
const currentPage = this.authFilesPagination?.currentPage || 1;
|
|
if (action === 'prev') {
|
|
this.renderAuthFilesPage(currentPage - 1);
|
|
} else if (action === 'next') {
|
|
this.renderAuthFilesPage(currentPage + 1);
|
|
}
|
|
};
|
|
|
|
container._paginationListener = listener;
|
|
container.addEventListener('click', listener);
|
|
},
|
|
|
|
updatePaginationControls(totalItems = 0) {
|
|
const paginationContainer = document.getElementById('auth-files-pagination');
|
|
const infoEl = document.getElementById('auth-files-pagination-info');
|
|
if (!paginationContainer || !infoEl) return;
|
|
|
|
const prevBtn = paginationContainer.querySelector('button[data-action=\"prev\"]');
|
|
const nextBtn = paginationContainer.querySelector('button[data-action=\"next\"]');
|
|
const pageSize = this.authFilesPagination?.pageSize || 9;
|
|
const totalPages = this.authFilesPagination?.totalPages || 1;
|
|
const currentPage = Math.min(this.authFilesPagination?.currentPage || 1, totalPages);
|
|
const shouldShow = totalItems > pageSize;
|
|
|
|
paginationContainer.style.display = shouldShow ? 'flex' : 'none';
|
|
|
|
const infoParams = totalItems === 0
|
|
? { current: 0, total: 0, count: 0 }
|
|
: { current: currentPage, total: totalPages, count: totalItems };
|
|
infoEl.textContent = i18n.t('auth_files.pagination_info', infoParams);
|
|
|
|
if (prevBtn) {
|
|
prevBtn.disabled = currentPage <= 1;
|
|
}
|
|
if (nextBtn) {
|
|
nextBtn.disabled = currentPage >= totalPages;
|
|
}
|
|
},
|
|
|
|
updateFilterButtons(existingTypes) {
|
|
const filterContainer = document.querySelector('.auth-file-filter');
|
|
if (!filterContainer) return;
|
|
|
|
const predefinedTypes = [
|
|
{ type: 'all', labelKey: 'auth_files.filter_all' },
|
|
{ type: 'qwen', labelKey: 'auth_files.filter_qwen' },
|
|
{ type: 'gemini', labelKey: 'auth_files.filter_gemini' },
|
|
{ type: 'gemini-cli', labelKey: 'auth_files.filter_gemini-cli' },
|
|
{ type: 'aistudio', labelKey: 'auth_files.filter_aistudio' },
|
|
{ type: 'claude', labelKey: 'auth_files.filter_claude' },
|
|
{ type: 'codex', labelKey: 'auth_files.filter_codex' },
|
|
{ type: 'iflow', labelKey: 'auth_files.filter_iflow' },
|
|
{ type: 'vertex', labelKey: 'auth_files.filter_vertex' },
|
|
{ type: 'empty', labelKey: 'auth_files.filter_empty' }
|
|
];
|
|
|
|
const existingButtons = filterContainer.querySelectorAll('.filter-btn');
|
|
const existingButtonTypes = new Set();
|
|
existingButtons.forEach(btn => {
|
|
existingButtonTypes.add(btn.dataset.type);
|
|
});
|
|
|
|
existingButtons.forEach(btn => {
|
|
const btnType = btn.dataset.type;
|
|
if (existingTypes.has(btnType)) {
|
|
btn.style.display = 'inline-block';
|
|
const match = predefinedTypes.find(item => item.type === btnType);
|
|
if (match) {
|
|
btn.textContent = i18n.t(match.labelKey);
|
|
btn.setAttribute('data-i18n-text', match.labelKey);
|
|
}
|
|
} else {
|
|
btn.style.display = 'none';
|
|
}
|
|
});
|
|
|
|
const predefinedTypeSet = new Set(predefinedTypes.map(t => t.type));
|
|
existingTypes.forEach(type => {
|
|
if (type !== 'all' && !predefinedTypeSet.has(type) && !existingButtonTypes.has(type)) {
|
|
const btn = document.createElement('button');
|
|
btn.className = 'filter-btn';
|
|
btn.dataset.type = type;
|
|
|
|
const match = predefinedTypes.find(item => item.type === type);
|
|
if (match) {
|
|
btn.setAttribute('data-i18n-text', match.labelKey);
|
|
btn.textContent = i18n.t(match.labelKey);
|
|
} else {
|
|
const dynamicKey = `auth_files.filter_${type}`;
|
|
btn.setAttribute('data-i18n-text', dynamicKey);
|
|
btn.textContent = this.generateDynamicTypeLabel(type);
|
|
}
|
|
|
|
const emptyBtn = filterContainer.querySelector('[data-type=\"empty\"]');
|
|
if (emptyBtn) {
|
|
filterContainer.insertBefore(btn, emptyBtn);
|
|
} else {
|
|
filterContainer.appendChild(btn);
|
|
}
|
|
}
|
|
});
|
|
},
|
|
|
|
handleFilterClick(clickedBtn, options = {}) {
|
|
if (!clickedBtn) return;
|
|
const { skipRender = false } = options;
|
|
const filterBtns = document.querySelectorAll('.auth-file-filter .filter-btn');
|
|
|
|
filterBtns.forEach(b => b.classList.remove('active'));
|
|
clickedBtn.classList.add('active');
|
|
|
|
const filterType = clickedBtn.dataset.type;
|
|
this.currentAuthFileFilter = filterType || 'all';
|
|
|
|
if (!skipRender) {
|
|
this.authFilesPagination.currentPage = 1;
|
|
this.renderAuthFilesPage(1);
|
|
}
|
|
|
|
this.refreshFilterButtonTexts();
|
|
},
|
|
|
|
generateDynamicTypeLabel(type) {
|
|
if (!type) return '';
|
|
const key = `auth_files.type_${type}`;
|
|
const translated = i18n.t(key);
|
|
if (translated && translated !== key) {
|
|
return translated;
|
|
}
|
|
if (type.toLowerCase() === 'iflow') return 'iFlow';
|
|
return type.charAt(0).toUpperCase() + type.slice(1);
|
|
},
|
|
|
|
bindAuthFileFilterEvents() {
|
|
const filterContainer = document.querySelector('.auth-file-filter');
|
|
if (!filterContainer) return;
|
|
|
|
if (filterContainer._filterListener) {
|
|
filterContainer.removeEventListener('click', filterContainer._filterListener);
|
|
}
|
|
|
|
const listener = (event) => {
|
|
const button = event.target.closest('.filter-btn');
|
|
if (!button || !filterContainer.contains(button)) return;
|
|
event.preventDefault();
|
|
this.handleFilterClick(button);
|
|
};
|
|
|
|
filterContainer._filterListener = listener;
|
|
filterContainer.addEventListener('click', listener);
|
|
|
|
this.refreshFilterButtonTexts();
|
|
},
|
|
|
|
applyAuthFileFilterState(shouldRender = false) {
|
|
const filterContainer = document.querySelector('.auth-file-filter');
|
|
if (!filterContainer) return;
|
|
|
|
const currentType = this.currentAuthFileFilter || 'all';
|
|
const buttons = filterContainer.querySelectorAll('.filter-btn');
|
|
if (buttons.length === 0) return;
|
|
|
|
let targetButton = null;
|
|
buttons.forEach(btn => {
|
|
if (btn.dataset.type === currentType) {
|
|
targetButton = btn;
|
|
}
|
|
});
|
|
|
|
if (!targetButton) {
|
|
targetButton = filterContainer.querySelector('.filter-btn[data-type=\"all\"]') || buttons[0];
|
|
if (targetButton) {
|
|
this.currentAuthFileFilter = targetButton.dataset.type || 'all';
|
|
}
|
|
}
|
|
|
|
if (targetButton) {
|
|
this.handleFilterClick(targetButton, { skipRender: !shouldRender });
|
|
}
|
|
},
|
|
|
|
removeAuthFileElements(filenames = []) {
|
|
if (!Array.isArray(filenames) || filenames.length === 0) {
|
|
return;
|
|
}
|
|
|
|
const removalSet = new Set(filenames);
|
|
this.cachedAuthFiles = (this.cachedAuthFiles || []).filter(file => file && !removalSet.has(file.name));
|
|
|
|
if (!this.cachedAuthFiles.length) {
|
|
this.authFilesPagination.currentPage = 1;
|
|
}
|
|
this.renderAuthFilesPage(this.authFilesPagination.currentPage);
|
|
},
|
|
|
|
refreshFilterButtonTexts() {
|
|
document.querySelectorAll('.auth-file-filter .filter-btn[data-i18n-text]').forEach(btn => {
|
|
const key = btn.getAttribute('data-i18n-text');
|
|
if (key) {
|
|
btn.textContent = i18n.t(key);
|
|
}
|
|
});
|
|
},
|
|
|
|
bindAuthFileActionEvents() {
|
|
const container = document.getElementById('auth-files-list');
|
|
if (!container) return;
|
|
|
|
const oldListener = container._authFileActionListener;
|
|
if (oldListener) {
|
|
container.removeEventListener('click', oldListener);
|
|
}
|
|
|
|
const listener = (e) => {
|
|
const button = e.target.closest('button[data-action]');
|
|
if (!button) return;
|
|
|
|
const action = button.dataset.action;
|
|
const actionsContainer = button.closest('.item-actions');
|
|
if (!actionsContainer) return;
|
|
|
|
const filename = actionsContainer.dataset.filename;
|
|
if (!filename) return;
|
|
|
|
switch (action) {
|
|
case 'showDetails':
|
|
this.showAuthFileDetails(filename);
|
|
break;
|
|
case 'download':
|
|
this.downloadAuthFile(filename);
|
|
break;
|
|
case 'delete':
|
|
this.deleteAuthFile(filename);
|
|
break;
|
|
}
|
|
};
|
|
|
|
container._authFileActionListener = listener;
|
|
container.addEventListener('click', listener);
|
|
},
|
|
|
|
formatFileSize(bytes) {
|
|
if (bytes === 0) return '0 Bytes';
|
|
const k = 1024;
|
|
const sizes = ['Bytes', 'KB', 'MB', 'GB'];
|
|
const i = Math.floor(Math.log(bytes) / Math.log(k));
|
|
return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
|
|
},
|
|
|
|
openVertexFilePicker() {
|
|
const fileInput = document.getElementById('vertex-file-input');
|
|
if (fileInput) {
|
|
fileInput.click();
|
|
}
|
|
},
|
|
|
|
handleVertexFileSelection(event) {
|
|
const fileInput = event?.target;
|
|
const file = fileInput?.files?.[0] || null;
|
|
|
|
if (fileInput) {
|
|
fileInput.value = '';
|
|
}
|
|
|
|
if (file && !file.name.toLowerCase().endsWith('.json')) {
|
|
this.showNotification(i18n.t('vertex_import.file_required'), 'error');
|
|
this.vertexImportState.file = null;
|
|
this.updateVertexFileDisplay();
|
|
this.updateVertexImportButtonState();
|
|
return;
|
|
}
|
|
|
|
this.vertexImportState.file = file;
|
|
this.updateVertexFileDisplay(file ? file.name : '');
|
|
this.updateVertexImportButtonState();
|
|
},
|
|
|
|
updateVertexFileDisplay(filename = '') {
|
|
const displayInput = document.getElementById('vertex-file-display');
|
|
if (!displayInput) return;
|
|
displayInput.value = filename || '';
|
|
},
|
|
|
|
updateVertexImportButtonState() {
|
|
const importBtn = document.getElementById('vertex-import-btn');
|
|
if (!importBtn) return;
|
|
const disabled = !this.vertexImportState.file || this.vertexImportState.loading;
|
|
importBtn.disabled = disabled;
|
|
},
|
|
|
|
async importVertexCredential() {
|
|
if (!this.vertexImportState.file) {
|
|
this.showNotification(i18n.t('vertex_import.file_required'), 'error');
|
|
return;
|
|
}
|
|
|
|
const locationInput = document.getElementById('vertex-location');
|
|
const location = locationInput ? locationInput.value.trim() : '';
|
|
const formData = new FormData();
|
|
formData.append('file', this.vertexImportState.file, this.vertexImportState.file.name);
|
|
if (location) {
|
|
formData.append('location', location);
|
|
}
|
|
|
|
try {
|
|
this.vertexImportState.loading = true;
|
|
this.updateVertexImportButtonState();
|
|
|
|
const response = await this.apiClient.requestRaw('/vertex/import', {
|
|
method: 'POST',
|
|
body: formData
|
|
});
|
|
|
|
if (!response.ok) {
|
|
let errorMessage = `HTTP ${response.status}`;
|
|
try {
|
|
const errorData = await response.json();
|
|
errorMessage = errorData?.message || errorData?.error || errorMessage;
|
|
} catch (parseError) {
|
|
const text = await response.text();
|
|
if (text) {
|
|
errorMessage = text;
|
|
}
|
|
}
|
|
throw new Error(errorMessage);
|
|
}
|
|
|
|
const result = await response.json();
|
|
this.vertexImportState.result = result;
|
|
this.renderVertexImportResult(result);
|
|
this.showNotification(i18n.t('vertex_import.success'), 'success');
|
|
this.vertexImportState.file = null;
|
|
this.updateVertexFileDisplay('');
|
|
} catch (error) {
|
|
console.error('Vertex credential import failed:', error);
|
|
this.showNotification(`${i18n.t('notification.import_failed')}: ${error.message}`, 'error');
|
|
} finally {
|
|
this.vertexImportState.loading = false;
|
|
this.updateVertexImportButtonState();
|
|
const fileInput = document.getElementById('vertex-file-input');
|
|
if (fileInput) {
|
|
fileInput.value = '';
|
|
}
|
|
}
|
|
},
|
|
|
|
renderVertexImportResult(result = null) {
|
|
const container = document.getElementById('vertex-import-result');
|
|
const projectEl = document.getElementById('vertex-result-project');
|
|
const emailEl = document.getElementById('vertex-result-email');
|
|
const locationEl = document.getElementById('vertex-result-location');
|
|
const fileEl = document.getElementById('vertex-result-file');
|
|
if (!container || !projectEl || !emailEl || !locationEl || !fileEl) return;
|
|
|
|
if (!result) {
|
|
container.style.display = 'none';
|
|
this.vertexImportState.result = null;
|
|
return;
|
|
}
|
|
|
|
this.vertexImportState.result = result;
|
|
projectEl.textContent = result.project || '-';
|
|
emailEl.textContent = result.email || '-';
|
|
locationEl.textContent = result.location || '-';
|
|
fileEl.textContent = result.file || '-';
|
|
container.style.display = 'block';
|
|
},
|
|
|
|
showAuthFileDetails(filename, content) {
|
|
const file = (this.cachedAuthFiles || []).find(f => f && f.name === filename);
|
|
if (!file) return;
|
|
|
|
const stats = this.resolveAuthFileStats(file, this.authFileStatsCache || {});
|
|
const size = typeof file.size === 'number' ? this.formatFileSize(file.size) : '-';
|
|
const provider = file.provider || '-';
|
|
const type = file.type || '-';
|
|
const createdAt = file.created_at ? new Date(file.created_at).toLocaleString('zh-CN') : '-';
|
|
|
|
const jsonContent = content || JSON.stringify(file, null, 2);
|
|
|
|
// 使用独立的 JSON 弹窗样式，避免被通用 .modal 的 display:none 覆盖
|
|
const modalHtml = `
|
|
<div class="json-modal" id="json-modal">
|
|
<div class="json-modal-content">
|
|
<div class="json-modal-header">
|
|
<h3>${this.escapeHtml(filename)}</h3>
|
|
</div>
|
|
<div class="json-modal-body">
|
|
<pre class="json-content">${this.escapeHtml(jsonContent)}</pre>
|
|
</div>
|
|
<div class="json-modal-footer">
|
|
<button class="btn btn-secondary" data-action="copy">
|
|
<i class="fas fa-copy"></i>
|
|
${i18n.t('common.copy')}
|
|
</button>
|
|
<button class="btn btn-secondary" data-action="close">
|
|
${i18n.t('common.close')}
|
|
</button>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
`;
|
|
|
|
const oldModal = document.getElementById('json-modal');
|
|
if (oldModal) {
|
|
oldModal.remove();
|
|
}
|
|
|
|
document.body.insertAdjacentHTML('beforeend', modalHtml);
|
|
const modal = document.getElementById('json-modal');
|
|
|
|
modal.addEventListener('click', (e) => {
|
|
if (e.target === modal) {
|
|
this.closeJsonModal();
|
|
}
|
|
});
|
|
|
|
this.bindJsonModalEvents(modal);
|
|
},
|
|
|
|
bindJsonModalEvents(modal) {
|
|
modal.addEventListener('click', (e) => {
|
|
const button = e.target.closest('button[data-action]');
|
|
if (!button) return;
|
|
|
|
const action = button.dataset.action;
|
|
switch (action) {
|
|
case 'copy':
|
|
this.copyJsonContent();
|
|
break;
|
|
case 'close':
|
|
this.closeJsonModal();
|
|
break;
|
|
}
|
|
});
|
|
},
|
|
|
|
closeJsonModal() {
|
|
const modal = document.getElementById('json-modal');
|
|
if (modal) {
|
|
modal.remove();
|
|
}
|
|
},
|
|
|
|
copyJsonContent() {
|
|
const jsonContent = document.querySelector('.json-content');
|
|
if (jsonContent) {
|
|
const text = jsonContent.textContent;
|
|
navigator.clipboard.writeText(text).then(() => {
|
|
this.showNotification('内容已复制到剪贴板', 'success');
|
|
}).catch(() => {
|
|
this.showNotification('复制失败', 'error');
|
|
});
|
|
}
|
|
},
|
|
|
|
async downloadAuthFile(filename) {
|
|
try {
|
|
const response = await this.apiClient.requestRaw(`/auth-files/download?name=${encodeURIComponent(filename)}`);
|
|
|
|
if (!response.ok) {
|
|
throw new Error(`HTTP ${response.status}`);
|
|
}
|
|
|
|
const blob = await response.blob();
|
|
const url = window.URL.createObjectURL(blob);
|
|
const a = document.createElement('a');
|
|
a.href = url;
|
|
a.download = filename;
|
|
a.click();
|
|
window.URL.revokeObjectURL(url);
|
|
|
|
this.showNotification(i18n.t('auth_files.download_success'), 'success');
|
|
} catch (error) {
|
|
this.showNotification(`${i18n.t('notification.download_failed')}: ${error.message}`, 'error');
|
|
}
|
|
},
|
|
|
|
async deleteAuthFile(filename) {
|
|
if (!confirm(`${i18n.t('auth_files.delete_confirm')} "${filename}" 吗？`)) return;
|
|
|
|
try {
|
|
await this.makeRequest(`/auth-files?name=${encodeURIComponent(filename)}`, { method: 'DELETE' });
|
|
this.removeAuthFileElements([filename]);
|
|
this.clearCache();
|
|
await this.loadAuthFiles();
|
|
this.showNotification(i18n.t('auth_files.delete_success'), 'success');
|
|
} catch (error) {
|
|
this.showNotification(`${i18n.t('notification.delete_failed')}: ${error.message}`, 'error');
|
|
}
|
|
},
|
|
|
|
async deleteAllAuthFiles() {
|
|
const filterType = (this.currentAuthFileFilter || 'all').toLowerCase();
|
|
const isFiltered = filterType !== 'all';
|
|
const typeLabel = this.generateDynamicTypeLabel(filterType);
|
|
const confirmMessage = isFiltered
|
|
? i18n.t('auth_files.delete_filtered_confirm').replace('{type}', typeLabel)
|
|
: i18n.t('auth_files.delete_all_confirm');
|
|
|
|
if (!confirm(confirmMessage)) return;
|
|
|
|
try {
|
|
if (!isFiltered) {
|
|
const response = await this.makeRequest('/auth-files?all=true', { method: 'DELETE' });
|
|
const currentNames = (this.cachedAuthFiles || []).map(file => file.name).filter(Boolean);
|
|
if (currentNames.length > 0) {
|
|
this.removeAuthFileElements(currentNames);
|
|
}
|
|
this.clearCache();
|
|
this.currentAuthFileFilter = 'all';
|
|
await this.loadAuthFiles();
|
|
this.showNotification(`${i18n.t('auth_files.delete_all_success')} ${response.deleted} ${i18n.t('auth_files.files_count')}`, 'success');
|
|
return;
|
|
}
|
|
|
|
const deletableFiles = (this.cachedAuthFiles || []).filter(file => {
|
|
if (!file || file.runtime_only) return false;
|
|
const fileType = (file.type || 'unknown').toLowerCase();
|
|
return fileType === filterType;
|
|
});
|
|
|
|
if (deletableFiles.length === 0) {
|
|
this.showNotification(i18n.t('auth_files.delete_filtered_none').replace('{type}', typeLabel), 'info');
|
|
return;
|
|
}
|
|
|
|
let success = 0;
|
|
let failed = 0;
|
|
const deletedNames = [];
|
|
|
|
for (const file of deletableFiles) {
|
|
try {
|
|
await this.makeRequest(`/auth-files?name=${encodeURIComponent(file.name)}`, { method: 'DELETE' });
|
|
success++;
|
|
deletedNames.push(file.name);
|
|
} catch (error) {
|
|
console.error('删除认证文件失败:', file?.name, error);
|
|
failed++;
|
|
}
|
|
}
|
|
|
|
if (deletedNames.length > 0) {
|
|
this.removeAuthFileElements(deletedNames);
|
|
}
|
|
|
|
this.clearCache();
|
|
this.currentAuthFileFilter = 'all';
|
|
await this.loadAuthFiles();
|
|
|
|
if (failed === 0) {
|
|
const successMsg = i18n.t('auth_files.delete_filtered_success')
|
|
.replace('{count}', success)
|
|
.replace('{type}', typeLabel);
|
|
this.showNotification(successMsg, 'success');
|
|
} else {
|
|
const warningMsg = i18n.t('auth_files.delete_filtered_partial')
|
|
.replace('{success}', success)
|
|
.replace('{failed}', failed)
|
|
.replace('{type}', typeLabel);
|
|
this.showNotification(warningMsg, 'warning');
|
|
}
|
|
} catch (error) {
|
|
this.showNotification(`${i18n.t('notification.delete_failed')}: ${error.message}`, 'error');
|
|
}
|
|
},
|
|
|
|
// 触发文件上传选择器
|
|
uploadAuthFile() {
|
|
const authFileInput = document.getElementById('auth-file-input');
|
|
if (authFileInput) {
|
|
authFileInput.click();
|
|
}
|
|
},
|
|
|
|
// 处理文件上传
|
|
async handleFileUpload(event) {
|
|
const file = event.target.files[0];
|
|
if (!file) return;
|
|
|
|
if (!file.name.endsWith('.json')) {
|
|
this.showNotification(i18n.t('auth_files.upload_error_json'), 'error');
|
|
event.target.value = '';
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const formData = new FormData();
|
|
formData.append('file', file, file.name);
|
|
|
|
const response = await this.apiClient.requestRaw('/auth-files', {
|
|
method: 'POST',
|
|
body: formData
|
|
});
|
|
|
|
if (!response.ok) {
|
|
const errorData = await response.json().catch(() => ({}));
|
|
throw new Error(errorData.error || `HTTP ${response.status}`);
|
|
}
|
|
|
|
this.clearCache(); // 清除缓存
|
|
await this.loadAuthFiles();
|
|
this.showNotification(i18n.t('auth_files.upload_success'), 'success');
|
|
} catch (error) {
|
|
this.showNotification(`${i18n.t('notification.upload_failed')}: ${error.message}`, 'error');
|
|
} finally {
|
|
// 清空文件输入框,允许重复上传同一文件
|
|
event.target.value = '';
|
|
}
|
|
},
|
|
|
|
registerAuthFilesListeners() {
|
|
if (!this.events || typeof this.events.on !== 'function') {
|
|
return;
|
|
}
|
|
this.events.on('data:config-loaded', async (event) => {
|
|
const detail = event?.detail || {};
|
|
const keyStats = detail.keyStats || null;
|
|
try {
|
|
await this.loadAuthFiles(keyStats);
|
|
} catch (error) {
|
|
console.error('加载认证文件失败:', error);
|
|
}
|
|
});
|
|
}
|
|
};
|