(function() {
'use strict';
const { formatBytes, escapeHtml, fallbackCopy, setupJsonAutoIndent } = window.BucketDetailUtils || {
formatBytes: (bytes) => {
if (!Number.isFinite(bytes)) return `${bytes} bytes`;
const units = ['bytes', 'KB', 'MB', 'GB', 'TB'];
let i = 0;
let size = bytes;
while (size >= 1024 && i < units.length - 1) {
size /= 1024;
i++;
}
return `${size.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
},
escapeHtml: (value) => {
if (value === null || value === undefined) return '';
return String(value)
.replace(/&/g, '&')
.replace(//g, '>')
.replace(/"/g, '"')
.replace(/'/g, ''');
},
fallbackCopy: () => false,
setupJsonAutoIndent: () => {}
};
setupJsonAutoIndent(document.getElementById('policyDocument'));
const selectAllCheckbox = document.querySelector('[data-select-all]');
const bulkDeleteButton = document.querySelector('[data-bulk-delete-trigger]');
const bulkDeleteLabel = bulkDeleteButton?.querySelector('[data-bulk-delete-label]');
const bulkDeleteModalEl = document.getElementById('bulkDeleteModal');
const bulkDeleteModal = bulkDeleteModalEl ? new bootstrap.Modal(bulkDeleteModalEl) : null;
const bulkDeleteList = document.getElementById('bulkDeleteList');
const bulkDeleteCount = document.getElementById('bulkDeleteCount');
const bulkDeleteStatus = document.getElementById('bulkDeleteStatus');
const bulkDeleteConfirm = document.getElementById('bulkDeleteConfirm');
const bulkDeletePurge = document.getElementById('bulkDeletePurge');
const previewPanel = document.getElementById('preview-panel');
const previewEmpty = document.getElementById('preview-empty');
const previewKey = document.getElementById('preview-key');
const previewSize = document.getElementById('preview-size');
const previewModified = document.getElementById('preview-modified');
const previewEtag = document.getElementById('preview-etag');
const previewMetadata = document.getElementById('preview-metadata');
const previewMetadataList = document.getElementById('preview-metadata-list');
const previewPlaceholder = document.getElementById('preview-placeholder');
const previewImage = document.getElementById('preview-image');
const previewVideo = document.getElementById('preview-video');
const previewIframe = document.getElementById('preview-iframe');
const downloadButton = document.getElementById('downloadButton');
const presignButton = document.getElementById('presignButton');
const presignModalEl = document.getElementById('presignModal');
const presignModal = presignModalEl ? new bootstrap.Modal(presignModalEl) : null;
const presignMethod = document.getElementById('presignMethod');
const presignTtl = document.getElementById('presignTtl');
const presignLink = document.getElementById('presignLink');
const copyPresignLink = document.getElementById('copyPresignLink');
const copyPresignDefaultLabel = copyPresignLink?.textContent?.trim() || 'Copy';
const generatePresignButton = document.getElementById('generatePresignButton');
const policyForm = document.getElementById('bucketPolicyForm');
const policyTextarea = document.getElementById('policyDocument');
const policyPreset = document.getElementById('policyPreset');
const policyMode = document.getElementById('policyMode');
const uploadForm = document.querySelector('[data-upload-form]');
const uploadModalEl = document.getElementById('uploadModal');
const uploadModal = uploadModalEl ? bootstrap.Modal.getOrCreateInstance(uploadModalEl) : null;
const uploadFileInput = uploadForm?.querySelector('input[name="object"]');
const uploadDropZone = uploadForm?.querySelector('[data-dropzone]');
const uploadDropZoneLabel = uploadDropZone?.querySelector('[data-dropzone-label]');
const messageModalEl = document.getElementById('messageModal');
const messageModal = messageModalEl ? new bootstrap.Modal(messageModalEl) : null;
const messageModalTitle = document.getElementById('messageModalTitle');
const messageModalBody = document.getElementById('messageModalBody');
const messageModalAction = document.getElementById('messageModalAction');
let messageModalActionHandler = null;
let isGeneratingPresign = false;
const objectsContainer = document.querySelector('.objects-table-container[data-bucket]');
const bulkDeleteEndpoint = objectsContainer?.dataset.bulkDeleteEndpoint || '';
const objectsApiUrl = objectsContainer?.dataset.objectsApi || '';
const objectsStreamUrl = objectsContainer?.dataset.objectsStream || '';
const versionPanel = document.getElementById('version-panel');
const versionList = document.getElementById('version-list');
const refreshVersionsButton = document.getElementById('refreshVersionsButton');
const archivedCard = document.getElementById('archived-objects-card');
const archivedBody = archivedCard?.querySelector('[data-archived-body]');
const archivedCountBadge = archivedCard?.querySelector('[data-archived-count]');
const archivedRefreshButton = archivedCard?.querySelector('[data-archived-refresh]');
const archivedEndpoint = archivedCard?.dataset.archivedEndpoint;
let versioningEnabled = objectsContainer?.dataset.versioning === 'true';
const versionsCache = new Map();
let activeRow = null;
const selectedRows = new Map();
let bulkDeleting = false;
if (presignButton) presignButton.disabled = true;
if (generatePresignButton) generatePresignButton.disabled = true;
if (downloadButton) downloadButton.classList.add('disabled');
const objectCountBadge = document.getElementById('object-count-badge');
const loadMoreContainer = document.getElementById('load-more-container');
const loadMoreSpinner = document.getElementById('load-more-spinner');
const loadMoreStatus = document.getElementById('load-more-status');
const objectsLoadingRow = document.getElementById('objects-loading-row');
let nextContinuationToken = null;
let totalObjectCount = 0;
let loadedObjectCount = 0;
let isLoadingObjects = false;
let hasMoreObjects = false;
let currentFilterTerm = '';
let pageSize = 5000;
let currentPrefix = '';
let allObjects = [];
let urlTemplates = null;
let streamAbortController = null;
let useStreaming = !!objectsStreamUrl;
let streamingComplete = false;
const STREAM_RENDER_BATCH = 500;
let pendingStreamObjects = [];
let streamRenderScheduled = false;
const buildUrlFromTemplate = (template, key) => {
if (!template) return '';
return template.replace('KEY_PLACEHOLDER', encodeURIComponent(key).replace(/%2F/g, '/'));
};
const ROW_HEIGHT = 53;
const BUFFER_ROWS = 10;
let visibleItems = [];
let renderedRange = { start: 0, end: 0 };
const createObjectRow = (obj, displayKey = null) => {
const tr = document.createElement('tr');
tr.dataset.objectRow = '';
tr.dataset.key = obj.key;
tr.dataset.size = obj.size;
tr.dataset.lastModified = obj.lastModified || obj.last_modified;
tr.dataset.etag = obj.etag;
tr.dataset.previewUrl = obj.previewUrl || obj.preview_url;
tr.dataset.downloadUrl = obj.downloadUrl || obj.download_url;
tr.dataset.presignEndpoint = obj.presignEndpoint || obj.presign_endpoint;
tr.dataset.deleteEndpoint = obj.deleteEndpoint || obj.delete_endpoint;
tr.dataset.metadata = typeof obj.metadata === 'string' ? obj.metadata : JSON.stringify(obj.metadata || {});
tr.dataset.versionsEndpoint = obj.versionsEndpoint || obj.versions_endpoint;
tr.dataset.restoreTemplate = obj.restoreTemplate || obj.restore_template;
tr.dataset.tagsUrl = obj.tagsUrl || obj.tags_url;
tr.dataset.copyUrl = obj.copyUrl || obj.copy_url;
tr.dataset.moveUrl = obj.moveUrl || obj.move_url;
const keyToShow = displayKey || obj.key;
const lastModDisplay = obj.lastModifiedDisplay || obj.last_modified_display || new Date(obj.lastModified || obj.last_modified).toLocaleDateString();
tr.innerHTML = `
${escapeHtml(keyToShow)}
Modified ${escapeHtml(lastModDisplay)}
${formatBytes(obj.size)}
`;
return tr;
};
const showEmptyState = () => {
if (!objectsTableBody) return;
objectsTableBody.innerHTML = `
No objects yet
Drag and drop files here or click Upload to get started.
Upload Files
`;
};
const showLoadError = (message) => {
if (!objectsTableBody) return;
objectsTableBody.innerHTML = `
Failed to load objects
${escapeHtml(message)}
Retry
`;
};
const updateObjectCountBadge = () => {
if (!objectCountBadge) return;
if (totalObjectCount === 0) {
objectCountBadge.textContent = '0 objects';
} else {
objectCountBadge.textContent = `${totalObjectCount.toLocaleString()} object${totalObjectCount !== 1 ? 's' : ''}`;
}
};
let topSpacer = null;
let bottomSpacer = null;
const initVirtualScrollElements = () => {
if (!objectsTableBody) return;
if (!topSpacer) {
topSpacer = document.createElement('tr');
topSpacer.id = 'virtual-top-spacer';
topSpacer.innerHTML = '
Empty folder
This folder contains no objects${hasMoreObjects ? ' yet. Loading more...' : '.'}
`;
}
} else {
renderVirtualRows();
}
updateFolderViewStatus();
};
const updateFolderViewStatus = () => {
const folderViewStatusEl = document.getElementById('folder-view-status');
if (!folderViewStatusEl) return;
if (currentPrefix) {
const folderCount = visibleItems.filter(i => i.type === 'folder').length;
const fileCount = visibleItems.filter(i => i.type === 'file').length;
folderViewStatusEl.innerHTML = `${folderCount} folder${folderCount !== 1 ? 's' : ''}, ${fileCount} file${fileCount !== 1 ? 's' : ''} in this view `;
folderViewStatusEl.classList.remove('d-none');
} else {
folderViewStatusEl.classList.add('d-none');
}
};
const processStreamObject = (obj) => {
const key = obj.key;
return {
key: key,
size: obj.size,
lastModified: obj.last_modified,
lastModifiedDisplay: obj.last_modified_display,
etag: obj.etag,
previewUrl: urlTemplates ? buildUrlFromTemplate(urlTemplates.preview, key) : '',
downloadUrl: urlTemplates ? buildUrlFromTemplate(urlTemplates.download, key) : '',
presignEndpoint: urlTemplates ? buildUrlFromTemplate(urlTemplates.presign, key) : '',
deleteEndpoint: urlTemplates ? buildUrlFromTemplate(urlTemplates.delete, key) : '',
metadata: '{}',
versionsEndpoint: urlTemplates ? buildUrlFromTemplate(urlTemplates.versions, key) : '',
restoreTemplate: urlTemplates ? urlTemplates.restore.replace('KEY_PLACEHOLDER', encodeURIComponent(key).replace(/%2F/g, '/')) : '',
tagsUrl: urlTemplates ? buildUrlFromTemplate(urlTemplates.tags, key) : '',
copyUrl: urlTemplates ? buildUrlFromTemplate(urlTemplates.copy, key) : '',
moveUrl: urlTemplates ? buildUrlFromTemplate(urlTemplates.move, key) : ''
};
};
const flushPendingStreamObjects = () => {
if (pendingStreamObjects.length === 0) return;
const batch = pendingStreamObjects.splice(0, pendingStreamObjects.length);
batch.forEach(obj => {
loadedObjectCount++;
allObjects.push(obj);
});
updateObjectCountBadge();
if (loadMoreStatus) {
if (streamingComplete) {
loadMoreStatus.textContent = `${loadedObjectCount.toLocaleString()} objects`;
} else {
const countText = totalObjectCount > 0 ? ` of ${totalObjectCount.toLocaleString()}` : '';
loadMoreStatus.textContent = `${loadedObjectCount.toLocaleString()}${countText} loading...`;
}
}
refreshVirtualList();
streamRenderScheduled = false;
};
const scheduleStreamRender = () => {
if (streamRenderScheduled) return;
streamRenderScheduled = true;
requestAnimationFrame(flushPendingStreamObjects);
};
const loadObjectsStreaming = async () => {
if (isLoadingObjects) return;
isLoadingObjects = true;
streamingComplete = false;
if (objectsLoadingRow) objectsLoadingRow.style.display = '';
nextContinuationToken = null;
loadedObjectCount = 0;
totalObjectCount = 0;
allObjects = [];
pendingStreamObjects = [];
streamAbortController = new AbortController();
try {
const params = new URLSearchParams();
if (currentPrefix) params.set('prefix', currentPrefix);
const response = await fetch(`${objectsStreamUrl}?${params}`, {
signal: streamAbortController.signal
});
if (!response.ok) {
throw new Error(`HTTP ${response.status}`);
}
if (objectsLoadingRow) objectsLoadingRow.remove();
const reader = response.body.getReader();
const decoder = new TextDecoder();
let buffer = '';
while (true) {
const { done, value } = await reader.read();
if (done) break;
buffer += decoder.decode(value, { stream: true });
const lines = buffer.split('\n');
buffer = lines.pop() || '';
for (const line of lines) {
if (!line.trim()) continue;
try {
const msg = JSON.parse(line);
switch (msg.type) {
case 'meta':
urlTemplates = msg.url_templates;
versioningEnabled = msg.versioning_enabled;
if (objectsContainer) {
objectsContainer.dataset.versioning = versioningEnabled ? 'true' : 'false';
}
break;
case 'count':
totalObjectCount = msg.total_count || 0;
break;
case 'object':
pendingStreamObjects.push(processStreamObject(msg));
if (pendingStreamObjects.length >= STREAM_RENDER_BATCH) {
scheduleStreamRender();
}
break;
case 'error':
throw new Error(msg.error);
case 'done':
streamingComplete = true;
break;
}
} catch (parseErr) {
console.warn('Failed to parse stream line:', line, parseErr);
}
}
if (pendingStreamObjects.length > 0) {
scheduleStreamRender();
}
}
if (buffer.trim()) {
try {
const msg = JSON.parse(buffer);
if (msg.type === 'object') {
pendingStreamObjects.push(processStreamObject(msg));
} else if (msg.type === 'done') {
streamingComplete = true;
}
} catch (e) {}
}
flushPendingStreamObjects();
streamingComplete = true;
hasMoreObjects = false;
updateObjectCountBadge();
if (loadMoreStatus) {
loadMoreStatus.textContent = `${loadedObjectCount.toLocaleString()} objects`;
}
if (typeof updateLoadMoreButton === 'function') {
updateLoadMoreButton();
}
refreshVirtualList();
renderBreadcrumb(currentPrefix);
} catch (error) {
if (error.name === 'AbortError') return;
console.error('Streaming failed, falling back to paginated:', error);
useStreaming = false;
isLoadingObjects = false;
await loadObjectsPaginated(false);
return;
} finally {
isLoadingObjects = false;
streamAbortController = null;
}
};
const loadObjectsPaginated = async (append = false) => {
if (isLoadingObjects) return;
isLoadingObjects = true;
if (!append) {
if (objectsLoadingRow) objectsLoadingRow.style.display = '';
nextContinuationToken = null;
loadedObjectCount = 0;
totalObjectCount = 0;
allObjects = [];
}
if (append && loadMoreSpinner) {
loadMoreSpinner.classList.remove('d-none');
}
try {
const params = new URLSearchParams({ max_keys: String(pageSize) });
if (nextContinuationToken) {
params.set('continuation_token', nextContinuationToken);
}
const response = await fetch(`${objectsApiUrl}?${params}`);
if (!response.ok) {
const data = await response.json().catch(() => ({}));
throw new Error(data.error || `HTTP ${response.status}`);
}
const data = await response.json();
versioningEnabled = data.versioning_enabled;
if (objectsContainer) {
objectsContainer.dataset.versioning = versioningEnabled ? 'true' : 'false';
}
totalObjectCount = data.total_count || 0;
nextContinuationToken = data.next_continuation_token;
if (!append && objectsLoadingRow) {
objectsLoadingRow.remove();
}
if (data.url_templates && !urlTemplates) {
urlTemplates = data.url_templates;
}
data.objects.forEach(obj => {
loadedObjectCount++;
allObjects.push(processStreamObject(obj));
});
updateObjectCountBadge();
hasMoreObjects = data.is_truncated;
if (loadMoreStatus) {
if (data.is_truncated) {
loadMoreStatus.textContent = `${loadedObjectCount.toLocaleString()} of ${totalObjectCount.toLocaleString()} loaded`;
} else {
loadMoreStatus.textContent = `${loadedObjectCount.toLocaleString()} objects`;
}
}
if (typeof updateLoadMoreButton === 'function') {
updateLoadMoreButton();
}
refreshVirtualList();
renderBreadcrumb(currentPrefix);
} catch (error) {
console.error('Failed to load objects:', error);
if (!append) {
showLoadError(error.message);
} else {
showMessage({ title: 'Load Failed', body: error.message, variant: 'danger' });
}
} finally {
isLoadingObjects = false;
if (loadMoreSpinner) {
loadMoreSpinner.classList.add('d-none');
}
}
};
const loadObjects = async (append = false) => {
if (useStreaming && !append) {
return loadObjectsStreaming();
}
return loadObjectsPaginated(append);
};
const attachRowHandlers = () => {
const objectRows = document.querySelectorAll('[data-object-row]');
objectRows.forEach(row => {
if (row.dataset.handlersAttached) return;
row.dataset.handlersAttached = 'true';
const deleteBtn = row.querySelector('[data-delete-object]');
deleteBtn?.addEventListener('click', (e) => {
e.stopPropagation();
const deleteModalEl = document.getElementById('deleteObjectModal');
const deleteModal = deleteModalEl ? bootstrap.Modal.getOrCreateInstance(deleteModalEl) : null;
const deleteObjectForm = document.getElementById('deleteObjectForm');
const deleteObjectKey = document.getElementById('deleteObjectKey');
if (deleteModal && deleteObjectForm) {
deleteObjectForm.setAttribute('action', row.dataset.deleteEndpoint);
if (deleteObjectKey) deleteObjectKey.textContent = row.dataset.key;
deleteModal.show();
}
});
const selectCheckbox = row.querySelector('[data-object-select]');
selectCheckbox?.addEventListener('click', (event) => event.stopPropagation());
selectCheckbox?.addEventListener('change', () => {
toggleRowSelection(row, selectCheckbox.checked);
});
if (selectedRows.has(row.dataset.key)) {
selectCheckbox.checked = true;
row.classList.add('table-active');
}
});
const folderRows = document.querySelectorAll('.folder-row');
folderRows.forEach(row => {
if (row.dataset.handlersAttached) return;
row.dataset.handlersAttached = 'true';
const folderPath = row.dataset.folderPath;
const checkbox = row.querySelector('[data-folder-select]');
checkbox?.addEventListener('change', (e) => {
e.stopPropagation();
const folderObjects = allObjects.filter(obj => obj.key.startsWith(folderPath));
folderObjects.forEach(obj => {
if (checkbox.checked) {
selectedRows.set(obj.key, obj);
} else {
selectedRows.delete(obj.key);
}
});
updateBulkDeleteState();
});
const folderBtn = row.querySelector('button');
folderBtn?.addEventListener('click', (e) => {
e.stopPropagation();
navigateToFolder(folderPath);
});
row.addEventListener('click', (e) => {
if (e.target.closest('[data-folder-select]') || e.target.closest('button')) return;
navigateToFolder(folderPath);
});
});
updateBulkDeleteState();
};
const scrollSentinel = document.getElementById('scroll-sentinel');
const scrollContainer = document.querySelector('.objects-table-container');
const loadMoreBtn = document.getElementById('load-more-btn');
if (scrollContainer) {
scrollContainer.addEventListener('scroll', handleVirtualScroll, { passive: true });
}
loadMoreBtn?.addEventListener('click', () => {
if (hasMoreObjects && !isLoadingObjects) {
loadObjects(true);
}
});
function updateLoadMoreButton() {
if (loadMoreBtn) {
loadMoreBtn.classList.toggle('d-none', !hasMoreObjects);
}
}
if (scrollSentinel && scrollContainer) {
const containerObserver = new IntersectionObserver((entries) => {
entries.forEach(entry => {
if (entry.isIntersecting && hasMoreObjects && !isLoadingObjects) {
loadObjects(true);
}
});
}, {
root: scrollContainer,
rootMargin: '500px',
threshold: 0
});
containerObserver.observe(scrollSentinel);
const viewportObserver = new IntersectionObserver((entries) => {
entries.forEach(entry => {
if (entry.isIntersecting && hasMoreObjects && !isLoadingObjects) {
loadObjects(true);
}
});
}, {
root: null,
rootMargin: '500px',
threshold: 0
});
viewportObserver.observe(scrollSentinel);
}
const pageSizeSelect = document.getElementById('page-size-select');
pageSizeSelect?.addEventListener('change', (e) => {
pageSize = parseInt(e.target.value, 10);
});
if (objectsApiUrl) {
loadObjects();
}
const folderBreadcrumb = document.getElementById('folder-breadcrumb');
const objectsTableBody = document.querySelector('#objects-table tbody');
if (objectsTableBody) {
objectsTableBody.addEventListener('click', (e) => {
const row = e.target.closest('[data-object-row]');
if (!row) return;
if (e.target.closest('[data-delete-object]') || e.target.closest('[data-object-select]') || e.target.closest('a')) {
return;
}
selectRow(row);
});
}
const hasFolders = () => allObjects.some(obj => obj.key.includes('/'));
const getFoldersAtPrefix = (prefix) => {
const folders = new Set();
const files = [];
allObjects.forEach(obj => {
const key = obj.key;
if (!key.startsWith(prefix)) return;
const remainder = key.slice(prefix.length);
const slashIndex = remainder.indexOf('/');
if (slashIndex === -1) {
files.push(obj);
} else {
const folderName = remainder.slice(0, slashIndex + 1);
folders.add(prefix + folderName);
}
});
return { folders: Array.from(folders).sort(), files };
};
const countObjectsInFolder = (folderPrefix) => {
const count = allObjects.filter(obj => obj.key.startsWith(folderPrefix)).length;
return { count, mayHaveMore: hasMoreObjects };
};
const renderBreadcrumb = (prefix) => {
if (!folderBreadcrumb) return;
if (!prefix && !hasFolders()) {
folderBreadcrumb.classList.add('d-none');
return;
}
folderBreadcrumb.classList.remove('d-none');
const ol = folderBreadcrumb.querySelector('ol');
ol.innerHTML = '';
const rootLi = document.createElement('li');
rootLi.className = 'breadcrumb-item';
if (!prefix) {
rootLi.classList.add('active');
rootLi.setAttribute('aria-current', 'page');
rootLi.innerHTML = `
Root
`;
} else {
rootLi.innerHTML = `
Root
`;
}
ol.appendChild(rootLi);
if (prefix) {
const parts = prefix.split('/').filter(Boolean);
let accumulated = '';
parts.forEach((part, index) => {
accumulated += part + '/';
const li = document.createElement('li');
li.className = 'breadcrumb-item';
if (index === parts.length - 1) {
li.classList.add('active');
li.setAttribute('aria-current', 'page');
li.textContent = part;
} else {
const a = document.createElement('a');
a.href = '#';
a.className = 'text-decoration-none';
a.dataset.folderNav = accumulated;
a.textContent = part;
li.appendChild(a);
}
ol.appendChild(li);
});
}
ol.querySelectorAll('[data-folder-nav]').forEach(link => {
link.addEventListener('click', (e) => {
e.preventDefault();
navigateToFolder(link.dataset.folderNav);
});
});
};
const getObjectsInFolder = (folderPrefix) => {
return allObjects.filter(obj => obj.key.startsWith(folderPrefix));
};
const createFolderRow = (folderPath, displayName = null) => {
const folderName = displayName || folderPath.slice(currentPrefix.length).replace(/\/$/, '');
const { count: objectCount, mayHaveMore } = countObjectsInFolder(folderPath);
const countDisplay = mayHaveMore ? `${objectCount}+` : objectCount;
const tr = document.createElement('tr');
tr.className = 'folder-row';
tr.dataset.folderPath = folderPath;
tr.style.cursor = 'pointer';
tr.innerHTML = `
${escapeHtml(folderName)}/
${countDisplay} object${objectCount !== 1 ? 's' : ''}
—
`;
return tr;
};
const navigateToFolder = (prefix) => {
currentPrefix = prefix;
if (scrollContainer) scrollContainer.scrollTop = 0;
refreshVirtualList();
renderBreadcrumb(prefix);
selectedRows.clear();
if (typeof updateBulkDeleteState === 'function') {
updateBulkDeleteState();
}
if (previewPanel) previewPanel.classList.add('d-none');
if (previewEmpty) previewEmpty.classList.remove('d-none');
activeRow = null;
};
const renderObjectsView = () => {
if (!objectsTableBody) return;
const { folders, files } = getFoldersAtPrefix(currentPrefix);
objectsTableBody.innerHTML = '';
folders.forEach(folderPath => {
objectsTableBody.appendChild(createFolderRow(folderPath));
});
files.forEach(obj => {
objectsTableBody.appendChild(obj.element);
obj.element.style.display = '';
const keyCell = obj.element.querySelector('.object-key .fw-medium');
if (keyCell && currentPrefix) {
const displayName = obj.key.slice(currentPrefix.length);
keyCell.textContent = displayName;
keyCell.closest('.object-key').title = obj.key;
} else if (keyCell) {
keyCell.textContent = obj.key;
}
});
allObjects.forEach(obj => {
if (!files.includes(obj)) {
obj.element.style.display = 'none';
}
});
if (folders.length === 0 && files.length === 0) {
const emptyRow = document.createElement('tr');
emptyRow.innerHTML = `
Empty folder
This folder contains no objects.
`;
objectsTableBody.appendChild(emptyRow);
}
if (typeof updateBulkDeleteState === 'function') {
updateBulkDeleteState();
}
};
const showMessage = ({ title = 'Notice', body = '', bodyHtml = null, variant = 'info', actionText = null, onAction = null }) => {
if (!actionText && !onAction && window.showToast) {
window.showToast(body || title, title, variant);
return;
}
if (!messageModal) {
window.alert(body || title);
return;
}
document.querySelectorAll('.modal.show').forEach(modal => {
const instance = bootstrap.Modal.getInstance(modal);
if (instance && modal.id !== 'messageModal') {
instance.hide();
}
});
const iconEl = document.getElementById('messageModalIcon');
if (iconEl) {
const iconPaths = {
success: '
Target: ${escapeHtml(targetLabel)}
Version ID: ${escapeHtml(version.version_id)}
Timestamp: ${escapeHtml(timestamp)}
Size: ${escapeHtml(sizeLabel)}
Reason: ${escapeHtml(reasonLabel)}
${metadataHtml}
`;
const fallbackText = `Restore ${targetLabel} from ${timestamp}? Size ${sizeLabel}. Reason: ${reasonLabel}.`;
showMessage({
title: 'Restore archived version?',
body: fallbackText,
bodyHtml: summaryHtml,
variant: 'warning',
actionText: 'Restore version',
onAction: () => {
if (typeof onConfirm === 'function') {
onConfirm();
} else {
restoreVersion(row, version);
}
},
});
};
const updateArchivedCount = (count) => {
if (!archivedCountBadge) return;
const label = count === 1 ? 'item' : 'items';
archivedCountBadge.textContent = `${count} ${label}`;
};
function renderArchivedRows(items) {
if (!archivedBody) return;
archivedBody.innerHTML = '';
if (!items || items.length === 0) {
archivedBody.innerHTML = 'No archived-only objects. ${ts}
${sizeLabel} · ${describeVersionReason(item.latest.reason)}
`;
} else {
latestCell.innerHTML = 'Unknown ';
}
const countCell = document.createElement('td');
countCell.className = 'text-end text-muted';
countCell.textContent = item.versions;
const actionsCell = document.createElement('td');
actionsCell.className = 'text-end';
const btnGroup = document.createElement('div');
btnGroup.className = 'btn-group btn-group-sm';
const restoreButton = document.createElement('button');
restoreButton.type = 'button';
restoreButton.className = 'btn btn-outline-primary';
restoreButton.textContent = 'Restore';
restoreButton.disabled = !item.latest || !item.restore_url;
restoreButton.addEventListener('click', () => confirmVersionRestore(null, item.latest, item.key, () => restoreArchivedObject(item)));
const purgeButton = document.createElement('button');
purgeButton.type = 'button';
purgeButton.className = 'btn btn-outline-danger';
purgeButton.textContent = 'Delete versions';
purgeButton.addEventListener('click', () => confirmArchivedPurge(item));
btnGroup.appendChild(restoreButton);
btnGroup.appendChild(purgeButton);
actionsCell.appendChild(btnGroup);
row.appendChild(keyCell);
row.appendChild(latestCell);
row.appendChild(countCell);
row.appendChild(actionsCell);
archivedBody.appendChild(row);
});
}
async function restoreArchivedObject(item) {
if (!item?.restore_url) return;
try {
const response = await fetch(item.restore_url, { method: 'POST' });
let data = {};
try {
data = await response.json();
} catch {
data = {};
}
if (!response.ok) {
throw new Error(data.error || 'Unable to restore archived object');
}
showMessage({ title: 'Restore scheduled', body: data.message || 'Object restored from archive.', variant: 'success' });
await loadArchivedObjects();
loadObjects(false);
} catch (error) {
showMessage({ title: 'Restore failed', body: (error && error.message) || 'Unable to restore archived object', variant: 'danger' });
}
}
async function purgeArchivedObject(item) {
if (!item?.purge_url) return;
try {
const response = await fetch(item.purge_url, {
method: 'POST',
headers: { 'X-Requested-With': 'XMLHttpRequest' },
});
let data = {};
try {
data = await response.json();
} catch {
data = {};
}
if (!response.ok) {
throw new Error(data.error || 'Unable to delete archived versions');
}
showMessage({ title: 'Archived versions removed', body: data.message || 'All archived data for this key has been deleted.', variant: 'success' });
await loadArchivedObjects();
} catch (error) {
showMessage({ title: 'Delete failed', body: (error && error.message) || 'Unable to delete archived versions', variant: 'danger' });
}
}
function confirmArchivedPurge(item) {
const label = item?.key || 'this object';
const count = item?.versions || 0;
const countLabel = count === 1 ? 'version' : 'versions';
showMessage({
title: 'Delete archived versions?',
body: `Permanently remove ${count} archived ${countLabel} for ${label}? This cannot be undone.`,
variant: 'danger',
actionText: 'Delete versions',
onAction: () => purgeArchivedObject(item),
});
}
async function loadArchivedObjects() {
if (!archivedEndpoint || !archivedBody) return;
archivedBody.innerHTML = 'Loading… ${(error && error.message) || 'Unable to load archived objects'} No previous versions yet.
';
return;
}
versionList.innerHTML = '';
entries.forEach((entry, index) => {
const versionNumber = index + 1;
const item = document.createElement('div');
item.className = 'd-flex align-items-center justify-content-between py-2 border-bottom';
const textStack = document.createElement('div');
textStack.className = 'me-3';
const heading = document.createElement('div');
heading.className = 'd-flex align-items-center';
const badge = document.createElement('span');
badge.className = 'badge text-bg-secondary me-2';
badge.textContent = `#${versionNumber}`;
const title = document.createElement('div');
title.className = 'fw-semibold small';
const timestamp = entry.archived_at ? new Date(entry.archived_at).toLocaleString() : entry.version_id;
title.textContent = timestamp;
heading.appendChild(badge);
heading.appendChild(title);
const meta = document.createElement('div');
meta.className = 'text-muted small';
const reason = describeVersionReason(entry.reason);
const sizeLabel = formatBytes(Number(entry.size) || 0);
meta.textContent = `${sizeLabel} · ${reason}`;
textStack.appendChild(heading);
textStack.appendChild(meta);
const restoreButton = document.createElement('button');
restoreButton.type = 'button';
restoreButton.className = 'btn btn-outline-primary btn-sm';
restoreButton.textContent = 'Restore';
restoreButton.addEventListener('click', () => confirmVersionRestore(row, entry));
item.appendChild(textStack);
item.appendChild(restoreButton);
versionList.appendChild(item);
});
}
async function loadObjectVersions(row, { force = false } = {}) {
if (!versionPanel || !versionList || !versioningEnabled) {
versionPanel?.classList.add('d-none');
return;
}
if (!row) {
versionPanel.classList.add('d-none');
return;
}
const endpoint = row.dataset.versionsEndpoint;
if (!endpoint) {
versionPanel.classList.add('d-none');
return;
}
versionPanel.classList.remove('d-none');
if (!force && versionsCache.has(endpoint)) {
renderVersionEntries(versionsCache.get(endpoint), row);
return;
}
versionList.innerHTML = 'Loading versions…
';
try {
const response = await fetch(endpoint);
let data = {};
try {
data = await response.json();
} catch {
data = {};
}
if (!response.ok) {
throw new Error(data.error || 'Unable to load versions');
}
const entries = Array.isArray(data.versions) ? data.versions : [];
versionsCache.set(endpoint, entries);
renderVersionEntries(entries, row);
} catch (error) {
versionList.innerHTML = `${(error && error.message) || 'Unable to load versions'}
`;
}
}
renderMetadata(null);
const deleteModalEl = document.getElementById('deleteObjectModal');
const deleteModal = deleteModalEl ? new bootstrap.Modal(deleteModalEl) : null;
const deleteObjectForm = document.getElementById('deleteObjectForm');
const deleteObjectKey = document.getElementById('deleteObjectKey');
if (deleteObjectForm) {
deleteObjectForm.addEventListener('submit', async (e) => {
e.preventDefault();
const submitBtn = deleteObjectForm.querySelector('[type="submit"]');
const originalHtml = submitBtn ? submitBtn.innerHTML : '';
try {
if (submitBtn) {
submitBtn.disabled = true;
submitBtn.innerHTML = 'Select an object to view versions.
';
return;
}
const endpoint = activeRow.dataset.versionsEndpoint;
if (endpoint) {
versionsCache.delete(endpoint);
}
loadObjectVersions(activeRow, { force: true });
});
presignButton?.addEventListener('click', () => {
if (!activeRow) {
showMessage({ title: 'Select an object', body: 'Choose an object before generating a presigned URL.', variant: 'warning' });
return;
}
presignLink.value = '';
presignModal?.show();
requestPresignedUrl();
});
generatePresignButton?.addEventListener('click', () => {
requestPresignedUrl();
});
copyPresignLink?.addEventListener('click', async () => {
if (!presignLink?.value) {
return;
}
const fallbackCopy = (text) => {
const textArea = document.createElement('textarea');
textArea.value = text;
textArea.style.position = 'fixed';
textArea.style.left = '-999999px';
textArea.style.top = '-999999px';
document.body.appendChild(textArea);
textArea.focus();
textArea.select();
let success = false;
try {
success = document.execCommand('copy');
} catch (err) {
success = false;
}
textArea.remove();
return success;
};
let copied = false;
if (navigator.clipboard && window.isSecureContext) {
try {
await navigator.clipboard.writeText(presignLink.value);
copied = true;
} catch (error) {
}
}
if (!copied) {
copied = fallbackCopy(presignLink.value);
}
if (copied) {
copyPresignLink.textContent = 'Copied!';
window.setTimeout(() => {
copyPresignLink.textContent = copyPresignDefaultLabel;
}, 1500);
} else {
showMessage({ title: 'Copy Failed', body: 'Unable to copy link to clipboard. Please select the link and copy manually.', variant: 'warning' });
}
});
if (uploadForm && uploadFileInput) {
const uploadSubmitBtn = document.getElementById('uploadSubmitBtn');
const uploadCancelBtn = document.getElementById('uploadCancelBtn');
const uploadBtnText = document.getElementById('uploadBtnText');
const bulkUploadProgress = document.getElementById('bulkUploadProgress');
const bulkUploadStatus = document.getElementById('bulkUploadStatus');
const bulkUploadCounter = document.getElementById('bulkUploadCounter');
const bulkUploadProgressBar = document.getElementById('bulkUploadProgressBar');
const bulkUploadCurrentFile = document.getElementById('bulkUploadCurrentFile');
const bulkUploadResults = document.getElementById('bulkUploadResults');
const bulkUploadSuccessAlert = document.getElementById('bulkUploadSuccessAlert');
const bulkUploadErrorAlert = document.getElementById('bulkUploadErrorAlert');
const bulkUploadSuccessCount = document.getElementById('bulkUploadSuccessCount');
const bulkUploadErrorCount = document.getElementById('bulkUploadErrorCount');
const bulkUploadErrorList = document.getElementById('bulkUploadErrorList');
const uploadKeyPrefix = document.getElementById('uploadKeyPrefix');
const singleFileOptions = document.getElementById('singleFileOptions');
const floatingProgress = document.getElementById('floatingUploadProgress');
const floatingProgressBar = document.getElementById('floatingUploadProgressBar');
const floatingProgressStatus = document.getElementById('floatingUploadStatus');
const floatingProgressTitle = document.getElementById('floatingUploadTitle');
const floatingProgressExpand = document.getElementById('floatingUploadExpand');
const floatingProgressCancel = document.getElementById('floatingUploadCancel');
const uploadQueueContainer = document.getElementById('uploadQueueContainer');
const uploadQueueList = document.getElementById('uploadQueueList');
const uploadQueueCount = document.getElementById('uploadQueueCount');
const clearUploadQueueBtn = document.getElementById('clearUploadQueueBtn');
let isUploading = false;
let uploadQueue = [];
let activeXHRs = [];
let activeMultipartUpload = null;
let uploadCancelled = false;
let uploadStats = {
totalFiles: 0,
completedFiles: 0,
totalBytes: 0,
uploadedBytes: 0,
currentFileBytes: 0,
currentFileLoaded: 0,
currentFileName: ''
};
window.addEventListener('beforeunload', (e) => {
if (isUploading) {
e.preventDefault();
e.returnValue = 'Upload in progress. Are you sure you want to leave?';
return e.returnValue;
}
});
const showFloatingProgress = () => {
if (floatingProgress) {
floatingProgress.classList.remove('d-none');
}
};
const hideFloatingProgress = () => {
if (floatingProgress) {
floatingProgress.classList.add('d-none');
}
};
const updateFloatingProgress = () => {
const { totalFiles, completedFiles, totalBytes, uploadedBytes, currentFileLoaded, currentFileName } = uploadStats;
const effectiveUploaded = uploadedBytes + currentFileLoaded;
if (floatingProgressBar && totalBytes > 0) {
const percent = Math.round((effectiveUploaded / totalBytes) * 100);
floatingProgressBar.style.width = `${percent}%`;
}
if (floatingProgressStatus) {
const bytesText = `${formatBytes(effectiveUploaded)} / ${formatBytes(totalBytes)}`;
const queuedCount = uploadQueue.length;
let statusText = `${completedFiles}/${totalFiles} files`;
if (queuedCount > 0) {
statusText += ` (+${queuedCount} queued)`;
}
statusText += ` • ${bytesText}`;
floatingProgressStatus.textContent = statusText;
}
if (floatingProgressTitle) {
const remaining = totalFiles - completedFiles;
const queuedCount = uploadQueue.length;
let title = `Uploading ${remaining} file${remaining !== 1 ? 's' : ''}`;
if (queuedCount > 0) {
title += ` (+${queuedCount} queued)`;
}
floatingProgressTitle.textContent = title + '...';
}
};
floatingProgressExpand?.addEventListener('click', () => {
if (uploadModal) {
uploadModal.show();
}
});
const cancelAllUploads = async () => {
uploadCancelled = true;
activeXHRs.forEach(xhr => {
try { xhr.abort(); } catch {}
});
activeXHRs = [];
if (activeMultipartUpload) {
const { abortUrl } = activeMultipartUpload;
const csrfToken = document.querySelector('input[name="csrf_token"]')?.value;
try {
await fetch(abortUrl, { method: 'DELETE', headers: { 'X-CSRFToken': csrfToken || '' } });
} catch {}
activeMultipartUpload = null;
}
uploadQueue = [];
isProcessingQueue = false;
isUploading = false;
setUploadLockState(false);
hideFloatingProgress();
resetUploadUI();
showMessage({ title: 'Upload cancelled', body: 'All uploads have been cancelled.', variant: 'info' });
loadObjects(false);
};
floatingProgressCancel?.addEventListener('click', () => {
cancelAllUploads();
});
const refreshUploadDropLabel = () => {
if (!uploadDropZoneLabel) return;
if (isUploading) {
uploadDropZoneLabel.textContent = 'Drop files here to add to queue';
if (singleFileOptions) singleFileOptions.classList.add('d-none');
return;
}
const files = uploadFileInput.files;
if (!files || files.length === 0) {
uploadDropZoneLabel.textContent = 'No file selected';
if (singleFileOptions) singleFileOptions.classList.remove('d-none');
return;
}
uploadDropZoneLabel.textContent = files.length === 1 ? files[0].name : `${files.length} files selected`;
if (singleFileOptions) {
singleFileOptions.classList.toggle('d-none', files.length > 1);
}
};
const updateUploadBtnText = () => {
if (!uploadBtnText) return;
if (isUploading) {
const files = uploadFileInput.files;
if (files && files.length > 0) {
uploadBtnText.textContent = `Add ${files.length} to queue`;
if (uploadSubmitBtn) uploadSubmitBtn.disabled = false;
} else {
uploadBtnText.textContent = 'Uploading...';
}
return;
}
const files = uploadFileInput.files;
if (!files || files.length <= 1) {
uploadBtnText.textContent = 'Upload';
} else {
uploadBtnText.textContent = `Upload ${files.length} files`;
}
};
const resetUploadUI = () => {
if (bulkUploadProgress) bulkUploadProgress.classList.add('d-none');
if (bulkUploadResults) bulkUploadResults.classList.add('d-none');
if (bulkUploadSuccessAlert) bulkUploadSuccessAlert.classList.remove('d-none');
if (bulkUploadErrorAlert) bulkUploadErrorAlert.classList.add('d-none');
if (bulkUploadErrorList) bulkUploadErrorList.innerHTML = '';
if (uploadSubmitBtn) uploadSubmitBtn.disabled = false;
if (uploadFileInput) uploadFileInput.disabled = false;
const progressStack = document.querySelector('[data-upload-progress]');
if (progressStack) progressStack.innerHTML = '';
if (uploadDropZone) {
uploadDropZone.classList.remove('upload-locked');
uploadDropZone.style.pointerEvents = '';
}
isUploading = false;
hideFloatingProgress();
};
const MULTIPART_THRESHOLD = 8 * 1024 * 1024;
const CHUNK_SIZE = 8 * 1024 * 1024;
const uploadProgressStack = document.querySelector('[data-upload-progress]');
const multipartInitUrl = uploadForm.dataset.multipartInitUrl;
const multipartPartTemplate = uploadForm.dataset.multipartPartTemplate;
const multipartCompleteTemplate = uploadForm.dataset.multipartCompleteTemplate;
const multipartAbortTemplate = uploadForm.dataset.multipartAbortTemplate;
const createProgressItem = (file) => {
const item = document.createElement('div');
item.className = 'upload-progress-item';
item.dataset.state = 'uploading';
item.innerHTML = `
${escapeHtml(file.name)}
${formatBytes(file.size)}
Preparing...
`;
return item;
};
const updateProgressItem = (item, { loaded, total, status, state, error }) => {
if (state) item.dataset.state = state;
const statusEl = item.querySelector('.upload-status');
const progressBar = item.querySelector('.progress-bar');
const progressLoaded = item.querySelector('.progress-loaded');
const progressPercent = item.querySelector('.progress-percent');
if (status) {
statusEl.textContent = status;
statusEl.className = 'upload-status text-end ms-2';
if (state === 'success') statusEl.classList.add('success');
if (state === 'error') statusEl.classList.add('error');
}
if (typeof loaded === 'number' && typeof total === 'number' && total > 0) {
const percent = Math.round((loaded / total) * 100);
progressBar.style.width = `${percent}%`;
progressLoaded.textContent = `${formatBytes(loaded)} / ${formatBytes(total)}`;
progressPercent.textContent = `${percent}%`;
}
if (error) {
const progressContainer = item.querySelector('.progress-container');
if (progressContainer) {
progressContainer.innerHTML = `${escapeHtml(error)}
`;
}
}
};
const uploadMultipart = async (file, objectKey, metadata, progressItem) => {
const csrfToken = document.querySelector('input[name="csrf_token"]')?.value;
if (uploadCancelled) throw new Error('Upload cancelled');
updateProgressItem(progressItem, { status: 'Initiating...', loaded: 0, total: file.size });
const initResp = await fetch(multipartInitUrl, {
method: 'POST',
headers: { 'Content-Type': 'application/json', 'X-CSRFToken': csrfToken || '' },
body: JSON.stringify({ object_key: objectKey, metadata })
});
if (!initResp.ok) {
const err = await initResp.json().catch(() => ({}));
throw new Error(err.error || 'Failed to initiate upload');
}
const { upload_id } = await initResp.json();
const partUrl = multipartPartTemplate.replace('UPLOAD_ID_PLACEHOLDER', upload_id);
const completeUrl = multipartCompleteTemplate.replace('UPLOAD_ID_PLACEHOLDER', upload_id);
const abortUrl = multipartAbortTemplate.replace('UPLOAD_ID_PLACEHOLDER', upload_id);
activeMultipartUpload = { upload_id, abortUrl };
const parts = [];
const totalParts = Math.ceil(file.size / CHUNK_SIZE);
let uploadedBytes = 0;
try {
for (let partNumber = 1; partNumber <= totalParts; partNumber++) {
if (uploadCancelled) throw new Error('Upload cancelled');
const start = (partNumber - 1) * CHUNK_SIZE;
const end = Math.min(start + CHUNK_SIZE, file.size);
const chunk = file.slice(start, end);
updateProgressItem(progressItem, {
status: `Part ${partNumber}/${totalParts}`,
loaded: uploadedBytes,
total: file.size
});
uploadStats.currentFileLoaded = uploadedBytes;
updateFloatingProgress();
const partResp = await fetch(`${partUrl}?partNumber=${partNumber}`, {
method: 'PUT',
headers: {
'X-CSRFToken': csrfToken || '',
'Content-Type': 'application/octet-stream'
},
body: chunk
});
if (uploadCancelled) throw new Error('Upload cancelled');
if (!partResp.ok) {
const err = await partResp.json().catch(() => ({}));
throw new Error(err.error || `Part ${partNumber} failed`);
}
const partData = await partResp.json();
parts.push({ part_number: partNumber, etag: partData.etag });
uploadedBytes += chunk.size;
updateProgressItem(progressItem, {
loaded: uploadedBytes,
total: file.size
});
uploadStats.currentFileLoaded = uploadedBytes;
updateFloatingProgress();
}
updateProgressItem(progressItem, { status: 'Completing...', loaded: file.size, total: file.size });
const completeResp = await fetch(completeUrl, {
method: 'POST',
headers: { 'Content-Type': 'application/json', 'X-CSRFToken': csrfToken || '' },
body: JSON.stringify({ parts })
});
if (!completeResp.ok) {
const err = await completeResp.json().catch(() => ({}));
throw new Error(err.error || 'Failed to complete upload');
}
activeMultipartUpload = null;
return await completeResp.json();
} catch (err) {
if (!uploadCancelled) {
try {
await fetch(abortUrl, { method: 'DELETE', headers: { 'X-CSRFToken': csrfToken || '' } });
} catch {}
}
activeMultipartUpload = null;
throw err;
}
};
const uploadRegular = async (file, objectKey, metadata, progressItem) => {
return new Promise((resolve, reject) => {
const formData = new FormData();
formData.append('object', file);
formData.append('object_key', objectKey);
if (metadata) formData.append('metadata', JSON.stringify(metadata));
const csrfToken = document.querySelector('input[name="csrf_token"]')?.value;
if (csrfToken) formData.append('csrf_token', csrfToken);
const xhr = new XMLHttpRequest();
activeXHRs.push(xhr);
xhr.open('POST', uploadForm.action, true);
xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
const removeXHR = () => {
const idx = activeXHRs.indexOf(xhr);
if (idx > -1) activeXHRs.splice(idx, 1);
};
xhr.upload.addEventListener('progress', (e) => {
if (e.lengthComputable) {
updateProgressItem(progressItem, {
status: 'Uploading...',
loaded: e.loaded,
total: e.total
});
uploadStats.currentFileLoaded = e.loaded;
updateFloatingProgress();
}
});
xhr.addEventListener('load', () => {
removeXHR();
if (xhr.status >= 200 && xhr.status < 300) {
try {
const data = JSON.parse(xhr.responseText);
if (data.status === 'error') {
reject(new Error(data.message || 'Upload failed'));
} else {
resolve(data);
}
} catch {
resolve({});
}
} else {
try {
const data = JSON.parse(xhr.responseText);
reject(new Error(data.message || `Upload failed (${xhr.status})`));
} catch {
reject(new Error(`Upload failed (${xhr.status})`));
}
}
});
xhr.addEventListener('error', () => { removeXHR(); reject(new Error('Network error')); });
xhr.addEventListener('abort', () => { removeXHR(); reject(new Error('Upload cancelled')); });
xhr.send(formData);
});
};
const uploadSingleFile = async (file, keyPrefix = '', metadata = null, progressItem = null) => {
const objectKey = keyPrefix ? `${keyPrefix}${file.name}` : file.name;
const shouldUseMultipart = file.size >= MULTIPART_THRESHOLD && multipartInitUrl;
if (!progressItem && uploadProgressStack) {
progressItem = createProgressItem(file);
uploadProgressStack.appendChild(progressItem);
}
try {
let result;
if (shouldUseMultipart) {
updateProgressItem(progressItem, { status: 'Multipart upload...', loaded: 0, total: file.size });
result = await uploadMultipart(file, objectKey, metadata, progressItem);
} else {
updateProgressItem(progressItem, { status: 'Uploading...', loaded: 0, total: file.size });
result = await uploadRegular(file, objectKey, metadata, progressItem);
}
updateProgressItem(progressItem, { state: 'success', status: 'Complete', loaded: file.size, total: file.size });
return result;
} catch (err) {
updateProgressItem(progressItem, { state: 'error', status: 'Failed', error: err.message });
throw err;
}
};
const setUploadLockState = (locked) => {
if (uploadDropZone) {
uploadDropZone.classList.toggle('upload-locked', locked);
}
};
let uploadSuccessFiles = [];
let uploadErrorFiles = [];
let isProcessingQueue = false;
const updateQueueListDisplay = () => {
if (!uploadQueueList || !uploadQueueContainer || !uploadQueueCount) return;
if (uploadQueue.length === 0) {
uploadQueueContainer.classList.add('d-none');
return;
}
uploadQueueContainer.classList.remove('d-none');
uploadQueueCount.textContent = uploadQueue.length;
uploadQueueList.innerHTML = uploadQueue.map((item, idx) => `
${escapeHtml(item.file.name)}
${formatBytes(item.file.size)}
`).join('');
};
const addFilesToQueue = (files, keyPrefix, metadata) => {
for (const file of files) {
uploadQueue.push({ file, keyPrefix, metadata });
uploadStats.totalFiles++;
uploadStats.totalBytes += file.size;
}
updateFloatingProgress();
updateQueueListDisplay();
};
const clearUploadQueue = () => {
const clearedCount = uploadQueue.length;
if (clearedCount === 0) return;
for (const item of uploadQueue) {
uploadStats.totalFiles--;
uploadStats.totalBytes -= item.file.size;
}
uploadQueue.length = 0;
updateFloatingProgress();
updateQueueListDisplay();
};
if (clearUploadQueueBtn) {
clearUploadQueueBtn.addEventListener('click', clearUploadQueue);
}
const processUploadQueue = async () => {
if (isProcessingQueue) return;
isProcessingQueue = true;
while (uploadQueue.length > 0 && !uploadCancelled) {
const item = uploadQueue.shift();
const { file, keyPrefix, metadata } = item;
updateQueueListDisplay();
uploadStats.currentFileName = file.name;
uploadStats.currentFileBytes = file.size;
uploadStats.currentFileLoaded = 0;
if (bulkUploadCounter) {
const queuedCount = uploadQueue.length;
let counterText = `${uploadStats.completedFiles + 1}/${uploadStats.totalFiles}`;
if (queuedCount > 0) {
counterText += ` (+${queuedCount} queued)`;
}
bulkUploadCounter.textContent = counterText;
}
if (bulkUploadCurrentFile) {
bulkUploadCurrentFile.textContent = `Uploading: ${file.name}`;
}
if (bulkUploadProgressBar) {
const percent = Math.round(((uploadStats.completedFiles + 1) / uploadStats.totalFiles) * 100);
bulkUploadProgressBar.style.width = `${percent}%`;
}
updateFloatingProgress();
try {
await uploadSingleFile(file, keyPrefix, metadata);
uploadSuccessFiles.push(file.name);
} catch (error) {
uploadErrorFiles.push({ name: file.name, error: error.message || 'Unknown error' });
}
uploadStats.uploadedBytes += file.size;
uploadStats.completedFiles++;
uploadStats.currentFileLoaded = 0;
updateFloatingProgress();
}
isProcessingQueue = false;
if (uploadQueue.length === 0 && !uploadCancelled) {
finishUploadSession();
}
};
const finishUploadSession = () => {
if (bulkUploadProgress) bulkUploadProgress.classList.add('d-none');
if (bulkUploadResults) bulkUploadResults.classList.remove('d-none');
hideFloatingProgress();
if (bulkUploadSuccessCount) bulkUploadSuccessCount.textContent = uploadSuccessFiles.length;
if (uploadSuccessFiles.length === 0 && bulkUploadSuccessAlert) {
bulkUploadSuccessAlert.classList.add('d-none');
}
if (uploadErrorFiles.length > 0) {
if (bulkUploadErrorCount) bulkUploadErrorCount.textContent = uploadErrorFiles.length;
if (bulkUploadErrorAlert) bulkUploadErrorAlert.classList.remove('d-none');
if (bulkUploadErrorList) {
bulkUploadErrorList.innerHTML = uploadErrorFiles
.map(f => `${escapeHtml(f.name)} : ${escapeHtml(f.error)}
Paused (Endpoint Unavailable) `;
}
// Hide the pause button since replication is effectively already paused
if (pauseForm) pauseForm.classList.add('d-none');
} else {
// Hide warning and show success alert
if (endpointWarning) endpointWarning.classList.add('d-none');
if (statusAlert) statusAlert.classList.remove('d-none');
// Restore status badge to show "Enabled"
if (statusBadge) {
statusBadge.className = 'badge bg-success-subtle text-success px-3 py-2';
statusBadge.innerHTML = `
Enabled `;
}
// Show the pause button
if (pauseForm) pauseForm.classList.remove('d-none');
}
if (syncedEl) syncedEl.textContent = data.objects_synced;
if (pendingEl) {
pendingEl.textContent = data.objects_pending;
if (data.objects_pending > 0) pendingEl.classList.add('text-warning');
}
if (orphanedEl) orphanedEl.textContent = data.objects_orphaned;
if (bytesEl) bytesEl.textContent = formatBytes(data.bytes_synced);
if (data.last_sync_at && lastSyncEl) {
lastSyncEl.style.display = '';
const date = new Date(data.last_sync_at * 1000);
if (lastSyncTimeEl) lastSyncTimeEl.textContent = date.toLocaleString();
if (lastSyncKeyEl && data.last_sync_key) {
lastSyncKeyEl.innerHTML = ' — ' + escapeHtml(data.last_sync_key) + '';
}
}
} catch (err) {
console.error('Failed to load replication stats:', err);
if (syncedEl) syncedEl.textContent = '—';
if (pendingEl) pendingEl.textContent = '—';
if (orphanedEl) orphanedEl.textContent = '—';
if (bytesEl) bytesEl.textContent = '—';
}
};
loadReplicationStats();
if (window.pollingManager) {
window.pollingManager.start('replication', loadReplicationStats);
}
const refreshBtn = document.querySelector('[data-refresh-replication]');
refreshBtn?.addEventListener('click', () => {
if (syncedEl) syncedEl.innerHTML = '
${escapeHtml(f.object_key)}
${escapeHtml(f.error_message)}
${new Date(f.timestamp * 1000).toLocaleString()}
${f.failure_count}
`).join('');
};
window.retryFailure = async (btn, objectKey) => {
const originalHtml = btn.innerHTML;
btn.disabled = true;
btn.innerHTML = '
Loading...${escapeHtml(err.message)} No lifecycle rules configured
${escapeHtml(rule.ID || '')}${escapeHtml(rule.Filter?.Prefix || '*')}${escapeHtml(rule.Status)} ${expiration}
${noncurrent}
`;
}).join('');
};
window.editLifecycleRule = (idx) => {
const rule = lifecycleRules[idx];
if (!rule) return;
document.getElementById('lifecycleRuleId').value = rule.ID || '';
document.getElementById('lifecycleRuleStatus').value = rule.Status || 'Enabled';
document.getElementById('lifecycleRulePrefix').value = rule.Filter?.Prefix || '';
document.getElementById('lifecycleExpirationDays').value = rule.Expiration?.Days || '';
document.getElementById('lifecycleNoncurrentDays').value = rule.NoncurrentVersionExpiration?.NoncurrentDays || '';
document.getElementById('lifecycleAbortMpuDays').value = rule.AbortIncompleteMultipartUpload?.DaysAfterInitiation || '';
window.editingLifecycleIdx = idx;
addLifecycleRuleModal?.show();
};
window.editingLifecycleIdx = null;
window.deleteLifecycleRule = async (idx) => {
lifecycleRules.splice(idx, 1);
await saveLifecycleRules();
};
const saveLifecycleRules = async () => {
if (!lifecycleUrl) return;
try {
const resp = await fetch(lifecycleUrl, {
method: 'POST',
headers: { 'Content-Type': 'application/json', 'X-CSRFToken': window.getCsrfToken ? window.getCsrfToken() : '' },
body: JSON.stringify({ rules: lifecycleRules })
});
const data = await resp.json();
if (!resp.ok) throw new Error(data.error || 'Failed to save');
showMessage({ title: 'Lifecycle rules saved', body: 'Configuration updated successfully.', variant: 'success' });
renderLifecycleRules();
} catch (err) {
showMessage({ title: 'Save failed', body: err.message, variant: 'danger' });
}
};
document.getElementById('addLifecycleRuleConfirm')?.addEventListener('click', async () => {
const ruleId = document.getElementById('lifecycleRuleId')?.value?.trim();
const status = document.getElementById('lifecycleRuleStatus')?.value || 'Enabled';
const prefix = document.getElementById('lifecycleRulePrefix')?.value?.trim() || '';
const expDays = parseInt(document.getElementById('lifecycleExpirationDays')?.value) || 0;
const ncDays = parseInt(document.getElementById('lifecycleNoncurrentDays')?.value) || 0;
const abortDays = parseInt(document.getElementById('lifecycleAbortMpuDays')?.value) || 0;
if (!ruleId) { showMessage({ title: 'Validation error', body: 'Rule ID is required', variant: 'warning' }); return; }
if (expDays === 0 && ncDays === 0 && abortDays === 0) { showMessage({ title: 'Validation error', body: 'At least one action is required', variant: 'warning' }); return; }
const rule = { ID: ruleId, Status: status, Filter: { Prefix: prefix } };
if (expDays > 0) rule.Expiration = { Days: expDays };
if (ncDays > 0) rule.NoncurrentVersionExpiration = { NoncurrentDays: ncDays };
if (abortDays > 0) rule.AbortIncompleteMultipartUpload = { DaysAfterInitiation: abortDays };
if (typeof window.editingLifecycleIdx === 'number' && window.editingLifecycleIdx !== null) {
lifecycleRules[window.editingLifecycleIdx] = rule;
window.editingLifecycleIdx = null;
} else {
lifecycleRules.push(rule);
}
await saveLifecycleRules();
addLifecycleRuleModal?.hide();
document.getElementById('lifecycleRuleId').value = '';
document.getElementById('lifecycleRulePrefix').value = '';
document.getElementById('lifecycleExpirationDays').value = '';
document.getElementById('lifecycleNoncurrentDays').value = '';
document.getElementById('lifecycleAbortMpuDays').value = '';
document.getElementById('lifecycleRuleStatus').value = 'Enabled';
});
const corsCard = document.getElementById('cors-rules-card');
const corsUrl = corsCard?.dataset.corsUrl;
const corsRulesBody = document.getElementById('cors-rules-body');
const addCorsRuleModalEl = document.getElementById('addCorsRuleModal');
const addCorsRuleModal = addCorsRuleModalEl ? new bootstrap.Modal(addCorsRuleModalEl) : null;
let corsRules = [];
const loadCorsRules = async () => {
if (!corsUrl || !corsRulesBody) return;
corsRulesBody.innerHTML = '
Loading...${escapeHtml(err.message)} No CORS rules configured ${escapeHtml(o)}`).join(', ');
const methods = (rule.AllowedMethods || []).map(m => `${escapeHtml(m)} `).join(' ');
const headers = (rule.AllowedHeaders || []).slice(0, 3).map(h => `${escapeHtml(h)}`).join(', ');
return `
${origins || 'None '}
${methods || 'None '}
${headers || '* '}
${rule.MaxAgeSeconds || '- '}
`;
}).join('');
};
window.editCorsRule = (idx) => {
const rule = corsRules[idx];
if (!rule) return;
document.getElementById('corsAllowedOrigins').value = (rule.AllowedOrigins || []).join('\n');
document.getElementById('corsAllowedHeaders').value = (rule.AllowedHeaders || []).join('\n');
document.getElementById('corsExposeHeaders').value = (rule.ExposeHeaders || []).join('\n');
document.getElementById('corsMaxAge').value = rule.MaxAgeSeconds || '';
document.getElementById('corsMethodGet').checked = (rule.AllowedMethods || []).includes('GET');
document.getElementById('corsMethodPut').checked = (rule.AllowedMethods || []).includes('PUT');
document.getElementById('corsMethodPost').checked = (rule.AllowedMethods || []).includes('POST');
document.getElementById('corsMethodDelete').checked = (rule.AllowedMethods || []).includes('DELETE');
document.getElementById('corsMethodHead').checked = (rule.AllowedMethods || []).includes('HEAD');
window.editingCorsIdx = idx;
addCorsRuleModal?.show();
};
window.editingCorsIdx = null;
window.deleteCorsRule = async (idx) => {
corsRules.splice(idx, 1);
await saveCorsRules();
};
const saveCorsRules = async () => {
if (!corsUrl) return;
try {
const resp = await fetch(corsUrl, {
method: 'POST',
headers: { 'Content-Type': 'application/json', 'X-CSRFToken': window.getCsrfToken ? window.getCsrfToken() : '' },
body: JSON.stringify({ rules: corsRules })
});
const data = await resp.json();
if (!resp.ok) throw new Error(data.error || 'Failed to save');
showMessage({ title: 'CORS rules saved', body: 'Configuration updated successfully.', variant: 'success' });
renderCorsRules();
} catch (err) {
showMessage({ title: 'Save failed', body: err.message, variant: 'danger' });
}
};
document.getElementById('addCorsRuleConfirm')?.addEventListener('click', async () => {
const originsRaw = document.getElementById('corsAllowedOrigins')?.value?.trim() || '';
const origins = originsRaw.split('\n').map(s => s.trim()).filter(Boolean);
const methods = [];
if (document.getElementById('corsMethodGet')?.checked) methods.push('GET');
if (document.getElementById('corsMethodPut')?.checked) methods.push('PUT');
if (document.getElementById('corsMethodPost')?.checked) methods.push('POST');
if (document.getElementById('corsMethodDelete')?.checked) methods.push('DELETE');
if (document.getElementById('corsMethodHead')?.checked) methods.push('HEAD');
const headersRaw = document.getElementById('corsAllowedHeaders')?.value?.trim() || '';
const headers = headersRaw.split('\n').map(s => s.trim()).filter(Boolean);
const exposeRaw = document.getElementById('corsExposeHeaders')?.value?.trim() || '';
const expose = exposeRaw.split('\n').map(s => s.trim()).filter(Boolean);
const maxAge = parseInt(document.getElementById('corsMaxAge')?.value) || 0;
if (origins.length === 0) { showMessage({ title: 'Validation error', body: 'At least one origin is required', variant: 'warning' }); return; }
if (methods.length === 0) { showMessage({ title: 'Validation error', body: 'At least one method is required', variant: 'warning' }); return; }
const rule = { AllowedOrigins: origins, AllowedMethods: methods };
if (headers.length > 0) rule.AllowedHeaders = headers;
if (expose.length > 0) rule.ExposeHeaders = expose;
if (maxAge > 0) rule.MaxAgeSeconds = maxAge;
if (typeof window.editingCorsIdx === 'number' && window.editingCorsIdx !== null) {
corsRules[window.editingCorsIdx] = rule;
window.editingCorsIdx = null;
} else {
corsRules.push(rule);
}
await saveCorsRules();
addCorsRuleModal?.hide();
document.getElementById('corsAllowedOrigins').value = '';
document.getElementById('corsAllowedHeaders').value = '';
document.getElementById('corsExposeHeaders').value = '';
document.getElementById('corsMaxAge').value = '';
document.getElementById('corsMethodGet').checked = false;
document.getElementById('corsMethodPut').checked = false;
document.getElementById('corsMethodPost').checked = false;
document.getElementById('corsMethodDelete').checked = false;
document.getElementById('corsMethodHead').checked = false;
});
const aclCard = document.getElementById('bucket-acl-card');
const aclUrl = aclCard?.dataset.aclUrl;
const aclOwnerEl = document.getElementById('acl-owner');
const aclGrantsList = document.getElementById('acl-grants-list');
const aclLoading = document.getElementById('acl-loading');
const aclContent = document.getElementById('acl-content');
const cannedAclSelect = document.getElementById('cannedAclSelect');
const loadAcl = async () => {
if (!aclUrl) return;
try {
const resp = await fetch(aclUrl);
const data = await resp.json();
if (!resp.ok) throw new Error(data.error || 'Failed to load ACL');
if (aclOwnerEl) aclOwnerEl.textContent = data.owner || '-';
if (aclGrantsList) {
const grants = data.grants || [];
if (grants.length === 0) {
aclGrantsList.innerHTML = 'No grants
';
} else {
aclGrantsList.innerHTML = grants.map(g => `${escapeHtml(g.grantee)}${escapeHtml(g.permission)}
`).join('');
}
}
if (aclLoading) aclLoading.classList.add('d-none');
if (aclContent) aclContent.classList.remove('d-none');
} catch (err) {
if (aclLoading) aclLoading.classList.add('d-none');
if (aclContent) aclContent.classList.remove('d-none');
if (aclGrantsList) aclGrantsList.innerHTML = `${escapeHtml(err.message)}
`;
}
};
cannedAclSelect?.addEventListener('change', async () => {
const canned = cannedAclSelect.value;
if (!canned || !aclUrl) return;
try {
const resp = await fetch(aclUrl, {
method: 'POST',
headers: { 'Content-Type': 'application/json', 'X-CSRFToken': window.getCsrfToken ? window.getCsrfToken() : '' },
body: JSON.stringify({ canned_acl: canned })
});
const data = await resp.json();
if (!resp.ok) throw new Error(data.error || 'Failed to set ACL');
showMessage({ title: 'ACL updated', body: `Bucket ACL set to "${canned}"`, variant: 'success' });
await loadAcl();
} catch (err) {
showMessage({ title: 'ACL update failed', body: err.message, variant: 'danger' });
}
});
document.querySelectorAll('[data-set-acl]').forEach(btn => {
btn.addEventListener('click', async () => {
const canned = btn.dataset.setAcl;
if (!canned || !aclUrl) return;
btn.disabled = true;
const originalText = btn.innerHTML;
btn.innerHTML = '${escapeHtml(t.Key)}=${escapeHtml(t.Value)} `).join('');
}
};
const renderTagEditor = () => {
if (!previewTagsInputs) return;
previewTagsInputs.innerHTML = currentObjectTags.map((t, idx) => `
`).join('');
};
window.removeTagRow = (idx) => {
currentObjectTags.splice(idx, 1);
renderTagEditor();
};
editTagsButton?.addEventListener('click', () => {
isEditingTags = true;
previewTagsList.classList.add('d-none');
previewTagsEmpty.classList.add('d-none');
previewTagsEditor?.classList.remove('d-none');
renderTagEditor();
});
cancelTagsButton?.addEventListener('click', () => {
isEditingTags = false;
previewTagsEditor?.classList.add('d-none');
previewTagsList.classList.remove('d-none');
renderObjectTags();
});
addTagRow?.addEventListener('click', () => {
if (currentObjectTags.length >= 10) {
showMessage({ title: 'Limit reached', body: 'Maximum 10 tags allowed per object.', variant: 'warning' });
return;
}
currentObjectTags.push({ Key: '', Value: '' });
renderTagEditor();
});
saveTagsButton?.addEventListener('click', async () => {
if (!activeRow) return;
const tagsUrl = activeRow.dataset.tagsUrl;
if (!tagsUrl) return;
const inputs = previewTagsInputs?.querySelectorAll('.input-group');
const newTags = [];
inputs?.forEach((group, idx) => {
const key = group.querySelector(`[data-tag-key="${idx}"]`)?.value?.trim() || '';
const value = group.querySelector(`[data-tag-value="${idx}"]`)?.value?.trim() || '';
if (key) newTags.push({ Key: key, Value: value });
});
try {
const resp = await fetch(tagsUrl, {
method: 'POST',
headers: { 'Content-Type': 'application/json', 'X-CSRFToken': window.getCsrfToken ? window.getCsrfToken() : '' },
body: JSON.stringify({ tags: newTags })
});
const data = await resp.json();
if (!resp.ok) throw new Error(data.error || 'Failed to save tags');
currentObjectTags = newTags;
isEditingTags = false;
previewTagsEditor?.classList.add('d-none');
previewTagsList.classList.remove('d-none');
renderObjectTags();
showMessage({ title: 'Tags saved', body: 'Object tags updated successfully.', variant: 'success' });
} catch (err) {
showMessage({ title: 'Save failed', body: err.message, variant: 'danger' });
}
});
const copyMoveModalEl = document.getElementById('copyMoveModal');
const copyMoveModal = copyMoveModalEl ? new bootstrap.Modal(copyMoveModalEl) : null;
const copyMoveActionLabel = document.getElementById('copyMoveActionLabel');
const copyMoveConfirmLabel = document.getElementById('copyMoveConfirmLabel');
const copyMoveSource = document.getElementById('copyMoveSource');
const copyMoveDestBucket = document.getElementById('copyMoveDestBucket');
const copyMoveDestKey = document.getElementById('copyMoveDestKey');
const copyMoveConfirm = document.getElementById('copyMoveConfirm');
const bucketsForCopyUrl = objectsContainer?.dataset.bucketsForCopyUrl;
let copyMoveAction = 'copy';
let copyMoveSourceKey = '';
window.openCopyMoveModal = async (action, key) => {
copyMoveAction = action;
copyMoveSourceKey = key;
if (copyMoveActionLabel) copyMoveActionLabel.textContent = action === 'move' ? 'Move' : 'Copy';
if (copyMoveConfirmLabel) copyMoveConfirmLabel.textContent = action === 'move' ? 'Move' : 'Copy';
if (copyMoveSource) copyMoveSource.textContent = key;
if (copyMoveDestKey) copyMoveDestKey.value = key;
if (copyMoveDestBucket) {
copyMoveDestBucket.innerHTML = 'Loading buckets... ';
try {
const resp = await fetch(bucketsForCopyUrl);
const data = await resp.json();
const buckets = data.buckets || [];
copyMoveDestBucket.innerHTML = buckets.map(b => `${escapeHtml(b)} `).join('');
} catch {
copyMoveDestBucket.innerHTML = 'Failed to load buckets ';
}
}
copyMoveModal?.show();
};
copyMoveConfirm?.addEventListener('click', async () => {
const destBucket = copyMoveDestBucket?.value;
const destKey = copyMoveDestKey?.value?.trim();
if (!destBucket || !destKey) { showMessage({ title: 'Validation error', body: 'Destination bucket and key are required', variant: 'warning' }); return; }
const actionUrl = copyMoveAction === 'move'
? urlTemplates?.move?.replace('KEY_PLACEHOLDER', encodeURIComponent(copyMoveSourceKey).replace(/%2F/g, '/'))
: urlTemplates?.copy?.replace('KEY_PLACEHOLDER', encodeURIComponent(copyMoveSourceKey).replace(/%2F/g, '/'));
if (!actionUrl) { showMessage({ title: 'Error', body: 'Copy/move URL not configured', variant: 'danger' }); return; }
try {
const resp = await fetch(actionUrl, {
method: 'POST',
headers: { 'Content-Type': 'application/json', 'X-CSRFToken': window.getCsrfToken ? window.getCsrfToken() : '' },
body: JSON.stringify({ dest_bucket: destBucket, dest_key: destKey })
});
const data = await resp.json();
if (!resp.ok) throw new Error(data.error || `Failed to ${copyMoveAction} object`);
showMessage({ title: `Object ${copyMoveAction === 'move' ? 'moved' : 'copied'}`, body: `Successfully ${copyMoveAction === 'move' ? 'moved' : 'copied'} to ${destBucket}/${destKey}`, variant: 'success' });
copyMoveModal?.hide();
if (copyMoveAction === 'move') {
previewEmpty.classList.remove('d-none');
previewPanel.classList.add('d-none');
activeRow = null;
loadObjects(false);
}
} catch (err) {
showMessage({ title: `${copyMoveAction === 'move' ? 'Move' : 'Copy'} failed`, body: err.message, variant: 'danger' });
}
});
const originalSelectRow = selectRow;
selectRow = (row) => {
originalSelectRow(row);
loadObjectTags(row);
};
if (lifecycleCard) loadLifecycleRules();
const lifecycleHistoryCard = document.getElementById('lifecycle-history-card');
const lifecycleHistoryBody = document.getElementById('lifecycle-history-body');
const lifecycleHistoryPagination = document.getElementById('lifecycle-history-pagination');
const showMoreHistoryBtn = document.getElementById('show-more-history');
const historyShownCount = document.getElementById('history-shown-count');
let historyExpanded = false;
const loadLifecycleHistory = async () => {
if (!lifecycleHistoryCard || !lifecycleHistoryBody) return;
const endpoint = lifecycleHistoryCard.dataset.historyEndpoint;
const limit = historyExpanded ? 50 : 5;
lifecycleHistoryBody.innerHTML = '
Loading...Lifecycle enforcement is not enabled No executions recorded yet Errors ';
} else if (hasActivity) {
statusBadge = 'Success ';
} else {
statusBadge = 'No action ';
}
const errorTooltip = hasErrors ? ` title="${escapeHtml(e.errors.join('; '))}"` : '';
return `
${date.toLocaleString()}
${e.objects_deleted} ${e.versions_deleted} ${e.uploads_aborted} ${statusBadge}
`;
}).join('');
if (total > 5 && !historyExpanded) {
lifecycleHistoryPagination.style.display = '';
historyShownCount.textContent = `Showing ${Math.min(5, total)} of ${total}`;
} else {
lifecycleHistoryPagination.style.display = 'none';
}
} catch (err) {
console.error('Failed to load lifecycle history:', err);
lifecycleHistoryBody.innerHTML = 'Failed to load history ' +
' ';
badge.innerHTML = icon + (enabled ? 'Versioning On' : 'Versioning Off');
versioningEnabled = enabled;
}
function interceptForm(formId, options) {
var form = document.getElementById(formId);
if (!form) return;
form.addEventListener('submit', function(e) {
e.preventDefault();
window.UICore.submitFormAjax(form, {
successMessage: options.successMessage || 'Operation completed',
onSuccess: function(data) {
if (options.onSuccess) options.onSuccess(data);
if (options.closeModal) {
var modal = bootstrap.Modal.getInstance(document.getElementById(options.closeModal));
if (modal) modal.hide();
}
if (options.reload) {
setTimeout(function() { location.reload(); }, 500);
}
}
});
});
}
function updateVersioningCard(enabled) {
var card = document.getElementById('bucket-versioning-card');
if (!card) return;
var cardBody = card.querySelector('.card-body');
if (!cardBody) return;
var enabledHtml = '' +
'
' +
' Versioning is enabled ' +
'
All previous versions of objects are preserved. You can roll back accidental changes or deletions at any time.
' +
'
' +
'' +
' Suspend Versioning ';
var disabledHtml = '' +
'
' +
' Versioning is suspended ' +
'
New object uploads overwrite existing objects. Enable versioning to preserve previous versions.
' +
'
' +
' Default encryption enabled (' + algoText + ') ' +
'
All new objects uploaded to this bucket will be automatically encrypted.
' +
' Default encryption disabled ' +
'
Objects are stored without default encryption. You can enable server-side encryption below.
' +
' Storage quota active ' +
'
This bucket is limited to ' + quotaParts.join(' and ') + '.
' +
' No storage quota ' +
'
This bucket has no storage or object count limits. Set limits below to control usage.
' +
' Policy attached ' +
'
A bucket policy is attached to this bucket. Access is granted via both IAM and bucket policy rules.
' +
' IAM only ' +
'
No bucket policy is attached. Access is controlled by IAM policies only.