+
${count} imagem${count !== 1 ? 'ns' : ''}
@@ -365,7 +372,7 @@ function renderPatientCards() {
cardW: cs.width, cardH: cs.height,
previewH: pcs ? pcs.height : 'n/a',
previewBg: pcs ? pcs.backgroundImage.substring(0, 60) : 'n/a'
- });
+ });
} else {
_log.error('RENDER_CARDS', '❌ Nenhum card encontrado no DOM após render!');
}
@@ -374,6 +381,38 @@ function renderPatientCards() {
});
}
+// Exclui todas as imagens de um determinado paciente (S3 e Local)
+async function deletePatientImages(patientName) {
+ if (!patientName) return;
+
+ // TODO(security): Usando confirm() para manter coerência com o restante das confirmações do painel do projeto
+ const ok = confirm(`⚠️ ATENÇÃO: Tem certeza que deseja excluir permanentemente todas as imagens do paciente "${patientName}"?\n\nEsta ação apagará os arquivos locais, do Wasabi S3 e do banco de dados, e NÃO poderá ser desfeita.`);
+ if (!ok) return;
+
+ showToast('Excluindo imagens do paciente...', 'info');
+
+ try {
+ const res = await fetchWithAuth(`/api/images/by-patient?name=${encodeURIComponent(patientName)}`, {
+ method: 'DELETE'
+ });
+
+ if (!res.ok) {
+ const err = await res.json();
+ throw new Error(err.error || 'Erro ao excluir imagens do paciente.');
+ }
+
+ showToast('✅ Todas as imagens do paciente foram excluídas!', 'success');
+
+ // Atualizar listagens
+ await loadPatients();
+ await loadClientsList();
+
+ } catch (e) {
+ console.error('Erro na exclusão do paciente:', e);
+ showToast(`Falha ao excluir imagens: ${e.message}`, 'error');
+ }
+}
+
// ================================================================
// VIEW: PATIENT IMAGES
// ================================================================
@@ -435,9 +474,11 @@ async function loadPatientImages(patientName) {
}
function renderPatientImages() {
- imagesGrid.innerHTML = patientImages.map(image => `
+ imagesGrid.innerHTML = patientImages.map(image => {
+ const thumbUrl = image.thumb_filename ? `/uploads/${image.thumb_filename}` : `/uploads/${image.filename}`;
+ return `
- `).join('');
+
-
+
${!image.enabled ? '${escapeHtml(image.image_guid || image.filename)}
@@ -451,8 +492,8 @@ function renderPatientImages() {
Desabilitada
' : ''}
-
- 
+
`).join('');
@@ -526,23 +578,21 @@ async function showTransformModal(imageId) {
// ---------------------------------------------------------------
// Detectar orientação da imagem original → aplicar layout correto
// ---------------------------------------------------------------
- if (transformations.length > 0 && transformations[0].base64) {
- const probe = new Image();
- probe.onload = () => {
- const orientation = probe.naturalWidth >= probe.naturalHeight ? 'landscape' : 'portrait';
- container.classList.remove('grid-landscape', 'grid-portrait');
- container.classList.add(`grid-${orientation}`);
- _log.info('TRANSFORM', `Orientação detectada: ${orientation} (${probe.naturalWidth}×${probe.naturalHeight})`);
- };
- probe.onerror = () => {
- _log.warn('TRANSFORM', 'Não foi possível detectar orientação — usando fallback');
- };
- probe.src = transformations[0].base64;
- }
+ const probe = new Image();
+ probe.onload = () => {
+ const orientation = probe.naturalWidth >= probe.naturalHeight ? 'landscape' : 'portrait';
+ container.classList.remove('grid-landscape', 'grid-portrait');
+ container.classList.add(`grid-${orientation}`);
+ _log.info('TRANSFORM', `Orientação detectada: ${orientation} (${probe.naturalWidth}×${probe.naturalHeight})`);
+ };
+ probe.onerror = () => {
+ _log.warn('TRANSFORM', 'Não foi possível detectar orientação — usando fallback');
+ };
+ probe.src = imageUrl;
} catch (e) {
_log.error('TRANSFORM', '❌ Exceção:', e.message, e);
- showToast('Erro ao gerar variações', 'error');
+ showToast('Erro ao carregar variações', 'error');
transformModal.classList.remove('active');
}
}
@@ -571,6 +621,17 @@ function selectTransform(index) {
el.classList.add('selected');
+ // Reset fine tune angle when selecting a new transform
+ fineTuneAngle = 0;
+ updateFineTuneDisplay();
+
+ // Mover o contêiner de ajuste fino para dentro do card selecionado
+ const ftContainer = document.getElementById('fineTuneContainer');
+ if (ftContainer) {
+ el.appendChild(ftContainer);
+ ftContainer.style.display = 'flex';
+ }
+
// Show action area
document.getElementById('transformActionArea').style.display = 'block';
@@ -585,11 +646,38 @@ function clearTransformSelection() {
const container = document.getElementById('transformOptions');
container.classList.remove('selection-mode');
+ // Mover o contêiner de ajuste fino de volta para o Wrapper e esconder
+ const ftContainer = document.getElementById('fineTuneContainer');
+ if (ftContainer) {
+ const viewWrapper = document.getElementById('transformViewWrapper');
+ if (viewWrapper) {
+ viewWrapper.appendChild(ftContainer);
+ } else {
+ document.body.appendChild(ftContainer);
+ }
+ ftContainer.style.display = 'none';
+ }
+
+ // Restore original transform styles on all images
document.querySelectorAll('.transform-option').forEach(option => {
option.classList.remove('selected');
option.style.display = 'block';
+
+ const optIndex = parseInt(option.getAttribute('data-index'));
+ const transform = currentTransformations[optIndex];
+ const imgEl = option.querySelector('img');
+ if (imgEl && transform) {
+ imgEl.style.transform = transform.css;
+ }
+ const nameEl = option.querySelector('.transform-name');
+ if (nameEl && transform) {
+ nameEl.innerText = transform.name;
+ }
});
+ fineTuneAngle = 0;
+ updateFineTuneDisplay();
+
document.getElementById('transformActionArea').style.display = 'none';
document.getElementById('newImageRemark').value = '';
}
@@ -612,7 +700,7 @@ async function saveSelectedTransform() {
try {
const payload = {
- rotation: transform.rotation,
+ rotation: transform.rotation + fineTuneAngle,
flipH: transform.flipH,
flipV: transform.flipV,
remark: remark
@@ -621,7 +709,7 @@ async function saveSelectedTransform() {
const res = await fetchWithAuth(`/api/images/${selectedImageId}/transform`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
- body: JSON.stringify({ rotation: transform.rotation, flipH: transform.flipH, flipV: transform.flipV })
+ body: JSON.stringify(payload)
});
if (!res.ok) throw new Error('Erro ao salvar');
@@ -634,6 +722,49 @@ async function saveSelectedTransform() {
}
}
+function adjustFineTune(offset) {
+ const selectedEl = document.querySelector('.transform-option.selected');
+ if (!selectedEl) return;
+
+ const index = parseInt(selectedEl.getAttribute('data-index'));
+ const transform = currentTransformations[index];
+
+ fineTuneAngle += offset;
+ updateFineTuneDisplay();
+
+ // Update the image style using the combined transform
+ const imgEl = selectedEl.querySelector('img');
+ if (imgEl) {
+ let totalRotation = transform.rotation + fineTuneAngle;
+ let transformStr = `rotate(${totalRotation}deg)`;
+ if (transform.flipH) transformStr += ` scaleX(-1)`;
+ if (transform.flipV) transformStr += ` scaleY(-1)`;
+ imgEl.style.transform = transformStr;
+ }
+
+ // Update display name inside the card
+ const nameEl = selectedEl.querySelector('.transform-name');
+ if (nameEl) {
+ nameEl.innerText = `${transform.name} (${fineTuneAngle > 0 ? '+' : ''}${fineTuneAngle}°)`;
+ }
+}
+
+function resetFineTune() {
+ adjustFineTune(-fineTuneAngle);
+}
+
+function updateFineTuneDisplay() {
+ const displayEl = document.getElementById('fineTuneValDisplay');
+ if (displayEl) {
+ displayEl.textContent = `${fineTuneAngle > 0 ? '+' : ''}${fineTuneAngle}°`;
+ }
+
+ const resetEl = document.getElementById('btnResetFineTune');
+ if (resetEl) {
+ resetEl.style.display = fineTuneAngle !== 0 ? 'inline-block' : 'none';
+ }
+}
+
async function toggleImageEnabled(imageId) {
try {
const res = await fetchWithAuth(`/api/images/${imageId}/toggle-enabled`, { method: 'PUT' });
@@ -1044,4 +1175,600 @@ async function updateCredentials(event) {
window.openSettingsModal = openSettingsModal;
window.closeSettingsModal = closeSettingsModal;
window.updateCredentials = updateCredentials;
+
+// ================================================================
+// CONFIGURAÇÕES DE PLUGINS (Wasabi Storage)
+// ================================================================
+
+function openPluginsModal() {
+ const modal = document.getElementById('pluginsModal');
+ if (modal) modal.style.display = 'block';
+
+ // Limpar campos
+ document.getElementById('wasabiAccessKey').value = '';
+ document.getElementById('wasabiSecretKey').value = '';
+ document.getElementById('wasabiBucket').value = '';
+ document.getElementById('wasabiRegion').value = '';
+ document.getElementById('wasabiEndpoint').value = '';
+
+ const alertBox = document.getElementById('pluginsStatusAlert');
+ alertBox.style.display = 'none';
+
+ // Carregar configurações atuais
+ loadPluginsConfig();
+}
+
+function closePluginsModal() {
+ const modal = document.getElementById('pluginsModal');
+ if (modal) modal.style.display = 'none';
+}
+
+async function loadPluginsConfig() {
+ try {
+ const res = await fetchWithAuth('/api/system/storage-config');
+ if (!res.ok) throw new Error('Falha ao carregar configurações');
+
+ const config = await res.json();
+
+ document.getElementById('wasabiAccessKey').value = config.wasabiAccessKey || '';
+ document.getElementById('wasabiSecretKey').value = config.wasabiSecretKey || '';
+ document.getElementById('wasabiBucket').value = config.wasabiBucket || '';
+ document.getElementById('wasabiRegion').value = config.wasabiRegion || '';
+ document.getElementById('wasabiEndpoint').value = config.wasabiEndpoint || '';
+
+ const alertBox = document.getElementById('pluginsStatusAlert');
+ if (config.enabled) {
+ alertBox.className = 'alert-success';
+ alertBox.style.background = '#eafaf1';
+ alertBox.style.color = '#27ae60';
+ alertBox.style.border = '1px solid #2ecc7133';
+ alertBox.innerHTML = '🟢 Status: Wasabi Storage está ATIVO e conectado.';
+ } else {
+ alertBox.className = 'alert-warning';
+ alertBox.style.background = '#fffbeb';
+ alertBox.style.color = '#d97706';
+ alertBox.style.border = '1px solid #f59e0b33';
+ alertBox.innerHTML = '🟡 Status: Wasabi Storage está DESATIVADO (utilizando armazenamento local).';
+ }
+ alertBox.style.display = 'block';
+ } catch (e) {
+ console.error(e);
+ showToast('Erro ao carregar configurações do Wasabi.', 'error');
+ }
+}
+
+async function updatePluginsConfig(event) {
+ event.preventDefault();
+
+ const wasabiAccessKey = document.getElementById('wasabiAccessKey').value.trim();
+ const wasabiSecretKey = document.getElementById('wasabiSecretKey').value;
+ const wasabiBucket = document.getElementById('wasabiBucket').value.trim();
+ const wasabiRegion = document.getElementById('wasabiRegion').value.trim();
+ const wasabiEndpoint = document.getElementById('wasabiEndpoint').value.trim();
+
+ const btn = document.getElementById('btnSavePlugins');
+ const originalText = btn.innerHTML;
+ btn.innerHTML = ' Salvando...';
+ btn.disabled = true;
+
+ try {
+ const res = await fetchWithAuth('/api/system/storage-config', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({
+ wasabiAccessKey,
+ wasabiSecretKey,
+ wasabiBucket,
+ wasabiRegion,
+ wasabiEndpoint
+ })
+ });
+
+ if (!res.ok) {
+ const err = await res.json();
+ throw new Error(err.error || 'Erro ao salvar configurações.');
+ }
+
+ showToast('Configurações do Wasabi salvas com sucesso!', 'success');
+
+ // Recarregar o status
+ await loadPluginsConfig();
+
+ // Fechar após 1 segundo
+ setTimeout(closePluginsModal, 1200);
+
+ } catch (e) {
+ console.error(e);
+ showToast(e.message, 'error');
+ } finally {
+ btn.innerHTML = originalText;
+ btn.disabled = false;
+ }
+}
+
+async function triggerSync() {
+ showToast('🔄 Enviando sinal de sincronização para dispositivos...', 'info');
+ try {
+ const res = await fetchWithAuth('/api/system/trigger-sync', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' }
+ });
+
+ if (!res.ok) {
+ const err = await res.json();
+ throw new Error(err.error || 'Erro ao acionar sincronização.');
+ }
+
+ const data = await res.json();
+ if (data.devicesTriggered > 0) {
+ showToast(`✅ Sinal enviado para ${data.devicesTriggered} dispositivo(s) conectado(s)!`, 'success');
+ } else {
+ showToast('⚠️ Nenhum dispositivo Windows conectado no momento.', 'warning');
+ }
+ } catch (e) {
+ console.error(e);
+ showToast(e.message, 'error');
+ }
+}
+
+// Global scope
+window.openPluginsModal = openPluginsModal;
+window.closePluginsModal = closePluginsModal;
+window.updatePluginsConfig = updatePluginsConfig;
+window.triggerSync = triggerSync;
+
+// ================================================================
+// ÁREA DE SINCRONIZAÇÃO E UPLOAD MANUAL
+// ================================================================
+
+let selectedUploadFiles = [];
+
+function openSyncModal() {
+ const modal = document.getElementById('syncModal');
+ if (!modal) return;
+
+ modal.classList.add('active');
+ modal.style.display = 'flex';
+
+ // Resetar abas
+ switchSyncTab('devices');
+
+ // Limpar formulário de upload
+ resetManualUploadForm();
+
+ // Carregar dados
+ loadSyncDevices();
+ refreshUploadPatients();
+
+ // Escuta de clique fora para fechar modal
+ modal.onclick = (e) => {
+ if (e.target === modal) closeSyncModal();
+ };
+}
+
+function closeSyncModal() {
+ const modal = document.getElementById('syncModal');
+ if (!modal) return;
+
+ modal.classList.remove('active');
+ modal.style.display = 'none';
+}
+
+function switchSyncTab(tabName) {
+ const btnDevices = document.getElementById('tabBtnDevices');
+ const btnUpload = document.getElementById('tabBtnUpload');
+ const tabDevices = document.getElementById('tab-devices');
+ const tabUpload = document.getElementById('tab-upload');
+
+ if (!btnDevices || !btnUpload || !tabDevices || !tabUpload) return;
+
+ if (tabName === 'devices') {
+ btnDevices.classList.add('active');
+ btnUpload.classList.remove('active');
+ tabDevices.classList.add('active');
+ tabUpload.classList.remove('active');
+ loadSyncDevices();
+ } else {
+ btnDevices.classList.remove('active');
+ btnUpload.classList.add('active');
+ tabDevices.classList.remove('active');
+ tabUpload.classList.add('active');
+ }
+}
+
+async function loadSyncDevices() {
+ const loader = document.getElementById('syncDevicesLoading');
+ const empty = document.getElementById('syncDevicesEmpty');
+ const list = document.getElementById('syncDeviceList');
+
+ if (!loader || !empty || !list) return;
+
+ loader.style.display = 'block';
+ empty.style.display = 'none';
+ list.style.display = 'none';
+
+ try {
+ const res = await fetchWithAuth('/api/socket/status');
+ if (!res.ok) throw new Error('Falha ao obter status dos dispositivos.');
+ const data = await res.json();
+
+ list.replaceChildren();
+
+ const windowsClients = (data.identified || []).filter(c => c.type === 'client' || c.type === 'windows');
+
+ if (windowsClients.length === 0) {
+ loader.style.display = 'none';
+ empty.style.display = 'block';
+ list.style.display = 'none';
+ return;
+ }
+
+ windowsClients.forEach(client => {
+ const card = document.createElement('div');
+ card.className = 'sync-device-card';
+
+ const left = document.createElement('div');
+ left.className = 'device-card-left';
+
+ const title = document.createElement('div');
+ title.className = 'device-card-title';
+ title.textContent = `💻 ${client.name || 'Dispositivo Sem Nome'}`;
+
+ const subtitle = document.createElement('div');
+ subtitle.className = 'device-card-subtitle';
+ subtitle.textContent = `SO: ${client.system || 'Windows'} | Versão: ${client.version || 'N/A'} | ID: ${client.socketId}`;
+
+ left.appendChild(title);
+ left.appendChild(subtitle);
+
+ const badge = document.createElement('span');
+ badge.className = 'device-card-badge badge-connected';
+ badge.textContent = 'ONLINE';
+
+ card.appendChild(left);
+ card.appendChild(badge);
+
+ list.appendChild(card);
+ });
+
+ loader.style.display = 'none';
+ empty.style.display = 'none';
+ list.style.display = 'flex';
+
+ } catch (e) {
+ console.error(e);
+ loader.style.display = 'none';
+ empty.style.display = 'block';
+ const p = empty.querySelector('p');
+ if (p) p.textContent = 'Erro ao carregar dispositivos: ' + e.message;
+ }
+}
+
+async function triggerSyncFromModal() {
+ const btn = document.getElementById('btnTriggerSyncModal');
+ if (!btn) return;
+
+ const originalText = btn.innerHTML;
+ btn.disabled = true;
+ btn.innerHTML = '🔄 Enviando sinal...';
+
+ try {
+ const res = await fetchWithAuth('/api/system/trigger-sync', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' }
+ });
+
+ if (!res.ok) {
+ const err = await res.json();
+ throw new Error(err.error || 'Erro ao acionar sincronização.');
+ }
+
+ const data = await res.json();
+ if (data.devicesTriggered > 0) {
+ showToast(`✅ Sinal enviado para ${data.devicesTriggered} dispositivo(s) conectado(s)!`, 'success');
+ } else {
+ showToast('⚠️ Nenhum dispositivo Windows conectado para sincronizar.', 'warning');
+ }
+ } catch (e) {
+ console.error(e);
+ showToast(e.message, 'error');
+ } finally {
+ btn.disabled = false;
+ btn.innerHTML = originalText;
+ }
+}
+
+async function refreshUploadPatients() {
+ const select = document.getElementById('uploadPatientSelect');
+ if (!select) return;
+
+ // Manter as primeiras duas opções
+ while (select.options.length > 2) {
+ select.remove(2);
+ }
+
+ try {
+ const res = await fetchWithAuth('/api/images/patients?disabled=false&search=');
+ if (!res.ok) throw new Error('Erro ao listar pacientes.');
+
+ const patients = await res.json();
+ patients.forEach(p => {
+ if (!p || !p.patient_name) return;
+ const opt = document.createElement('option');
+ opt.value = p.patient_name;
+ opt.textContent = p.patient_name;
+ select.appendChild(opt);
+ });
+ } catch (e) {
+ console.error(e);
+ showToast('Erro ao carregar lista de pacientes.', 'error');
+ }
+}
+
+function toggleNewPatientFields() {
+ const select = document.getElementById('uploadPatientSelect');
+ const fields = document.getElementById('newPatientFields');
+
+ if (!select || !fields) return;
+
+ if (select.value === 'NEW_PATIENT') {
+ fields.style.display = 'block';
+ document.getElementById('uploadNewPatientFirstName').required = true;
+ document.getElementById('uploadNewPatientLastName').required = true;
+ } else {
+ fields.style.display = 'none';
+ document.getElementById('uploadNewPatientFirstName').required = false;
+ document.getElementById('uploadNewPatientLastName').required = false;
+ }
+}
+
+function resetManualUploadForm() {
+ selectedUploadFiles = [];
+
+ const form = document.getElementById('manualUploadForm');
+ if (form) form.reset();
+
+ const previews = document.getElementById('uploadPreviewsContainer');
+ if (previews) previews.replaceChildren();
+
+ const progressContainer = document.getElementById('uploadProgressContainer');
+ if (progressContainer) progressContainer.style.display = 'none';
+
+ const fields = document.getElementById('newPatientFields');
+ if (fields) fields.style.display = 'none';
+
+ const btnSubmit = document.getElementById('btnSubmitManualUpload');
+ if (btnSubmit) btnSubmit.disabled = true;
+}
+
+// Inicializar Drag and Drop
+function initDragAndDrop() {
+ const zone = document.getElementById('uploadDragDropZone');
+ const fileInput = document.getElementById('uploadFileInput');
+
+ if (!zone || !fileInput) return;
+
+ // Evento de clique na zona abre o seletor de arquivos
+ zone.addEventListener('click', () => fileInput.click());
+
+ ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(eventName => {
+ zone.addEventListener(eventName, e => {
+ e.preventDefault();
+ e.stopPropagation();
+ }, false);
+ });
+
+ ['dragenter', 'dragover'].forEach(eventName => {
+ zone.addEventListener(eventName, () => {
+ zone.classList.add('drag-active');
+ }, false);
+ });
+
+ ['dragleave', 'drop'].forEach(eventName => {
+ zone.addEventListener(eventName, () => {
+ zone.classList.remove('drag-active');
+ }, false);
+ });
+
+ zone.addEventListener('drop', e => {
+ const dt = e.dataTransfer;
+ if (dt) handleUploadFiles(dt.files);
+ });
+
+ fileInput.addEventListener('change', e => {
+ if (e.target && e.target.files) handleUploadFiles(e.target.files);
+ });
+}
+
+function handleUploadFiles(files) {
+ if (!files || files.length === 0) return;
+
+ for (let i = 0; i < files.length; i++) {
+ const file = files[i];
+
+ if (!file.type.match('image.*')) {
+ showToast(`O arquivo "${file.name}" não é uma imagem válida!`, 'warning');
+ continue;
+ }
+
+ if (file.size > 10 * 1024 * 1024) {
+ showToast(`A imagem "${file.name}" excede o limite de tamanho de 10MB!`, 'warning');
+ continue;
+ }
+
+ if (selectedUploadFiles.some(f => f.name === file.name && f.size === file.size)) {
+ continue;
+ }
+
+ selectedUploadFiles.push(file);
+ }
+
+ renderUploadPreviews();
+}
+
+function renderUploadPreviews() {
+ const container = document.getElementById('uploadPreviewsContainer');
+ const btnSubmit = document.getElementById('btnSubmitManualUpload');
+ if (!container) return;
+
+ container.replaceChildren();
+
+ selectedUploadFiles.forEach((file, index) => {
+ const item = document.createElement('div');
+ item.className = 'preview-item';
+
+ const img = document.createElement('img');
+ img.alt = file.name;
+
+ const reader = new FileReader();
+ reader.onload = e => {
+ if (e.target && e.target.result) img.src = e.target.result;
+ };
+ reader.readAsDataURL(file);
+
+ const btnRemove = document.createElement('button');
+ btnRemove.type = 'button';
+ btnRemove.className = 'preview-remove';
+ btnRemove.innerHTML = '×';
+ btnRemove.title = 'Remover Imagem';
+ btnRemove.onclick = (e) => {
+ e.stopPropagation();
+ removeUploadPreview(index);
+ };
+
+ item.appendChild(img);
+ item.appendChild(btnRemove);
+ container.appendChild(item);
+ });
+
+ if (btnSubmit) {
+ btnSubmit.disabled = selectedUploadFiles.length === 0;
+ }
+}
+
+function removeUploadPreview(index) {
+ selectedUploadFiles.splice(index, 1);
+ renderUploadPreviews();
+}
+
+function readFileAsBase64(file) {
+ return new Promise((resolve, reject) => {
+ const reader = new FileReader();
+ reader.onload = () => resolve(reader.result);
+ reader.onerror = error => reject(error);
+ reader.readAsDataURL(file);
+ });
+}
+
+async function handleManualUploadSubmit(event) {
+ event.preventDefault();
+
+ if (selectedUploadFiles.length === 0) {
+ showToast('Selecione pelo menos uma imagem para enviar.', 'warning');
+ return;
+ }
+
+ const select = document.getElementById('uploadPatientSelect');
+ const remarkInput = document.getElementById('uploadRemark');
+ const btnSubmit = document.getElementById('btnSubmitManualUpload');
+
+ if (!select || !btnSubmit) return;
+
+ let patientName = '';
+ let doctor = '';
+
+ if (select.value === 'NEW_PATIENT') {
+ const firstName = document.getElementById('uploadNewPatientFirstName').value.trim();
+ const lastName = document.getElementById('uploadNewPatientLastName').value.trim();
+ doctor = document.getElementById('uploadNewPatientDoctor').value.trim();
+
+ if (!firstName || !lastName) {
+ showToast('Nome e sobrenome são obrigatórios para novo paciente.', 'warning');
+ return;
+ }
+
+ patientName = `${firstName} ${lastName}`;
+ } else {
+ patientName = select.value;
+ }
+
+ const remark = remarkInput ? remarkInput.value.trim() : '';
+
+ const progressContainer = document.getElementById('uploadProgressContainer');
+ const progressText = document.getElementById('uploadProgressText');
+ const progressBarFill = document.getElementById('uploadProgressBarFill');
+ const progressPercent = document.getElementById('uploadProgressPercent');
+
+ if (progressContainer) progressContainer.style.display = 'block';
+ btnSubmit.disabled = true;
+
+ const totalFiles = selectedUploadFiles.length;
+ let successCount = 0;
+
+ for (let i = 0; i < totalFiles; i++) {
+ const file = selectedUploadFiles[i];
+
+ if (progressText) progressText.textContent = `Enviando imagem ${i + 1} de ${totalFiles}...`;
+ if (progressBarFill) {
+ const pct = Math.round((i / totalFiles) * 100);
+ progressBarFill.style.width = `${pct}%`;
+ if (progressPercent) progressPercent.textContent = `${pct}%`;
+ }
+
+ try {
+ const base64 = await readFileAsBase64(file);
+
+ const response = await fetchWithAuth('/api/images/upload', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({
+ imageBase64: base64,
+ filename: file.name,
+ patientName: patientName,
+ doctor: doctor || null,
+ remark: remark || null
+ })
+ });
+
+ if (!response.ok) {
+ const err = await response.json();
+ throw new Error(err.error || `Erro HTTP ${response.status}`);
+ }
+
+ successCount++;
+ } catch (e) {
+ console.error(`Erro ao enviar arquivo ${file.name}:`, e);
+ showToast(`Falha ao enviar a imagem ${file.name}: ${e.message}`, 'error');
+ }
+ }
+
+ if (progressBarFill) {
+ progressBarFill.style.width = '100%';
+ if (progressPercent) progressPercent.textContent = '100%';
+ }
+ if (progressText) progressText.textContent = `Finalizado! ${successCount} de ${totalFiles} imagens enviadas.`;
+
+ setTimeout(async () => {
+ closeSyncModal();
+ showToast(`✅ ${successCount} imagem(ns) enviada(s) com sucesso!`, 'success');
+
+ await loadPatients();
+ if (window.loadClientsList) {
+ await window.loadClientsList();
+ }
+ }, 1000);
+}
+
+// Vinculando ao window
+window.openSyncModal = openSyncModal;
+window.closeSyncModal = closeSyncModal;
+window.switchSyncTab = switchSyncTab;
+window.triggerSyncFromModal = triggerSyncFromModal;
+window.refreshUploadPatients = refreshUploadPatients;
+window.toggleNewPatientFields = toggleNewPatientFields;
+window.handleManualUploadSubmit = handleManualUploadSubmit;
+window.initDragAndDrop = initDragAndDrop;
+window.deletePatientImages = deletePatientImages;
+window.adjustFineTune = adjustFineTune;
+window.resetFineTune = resetFineTune;
// A aplicação é inicializada no evento DOMContentLoaded acima
diff --git a/dental-server/public/index.html b/dental-server/public/index.html
index 4279aca..8d28c55 100644
--- a/dental-server/public/index.html
+++ b/dental-server/public/index.html
@@ -28,6 +28,12 @@
⚙️ Configurações
+
+ 🔌 Plugins / Wasabi
+
+
+ 🔄 Sincronização
+
⚠️ Zerar Sistema
@@ -122,7 +128,7 @@
+ 
+
${escapeHtml(t.name)}
-
@@ -270,6 +286,169 @@
+
+
+
+
+
+
+
+
+
+
diff --git a/dental-server/public/style.css b/dental-server/public/style.css
index 633a52d..f95d708 100644
--- a/dental-server/public/style.css
+++ b/dental-server/public/style.css
@@ -754,10 +754,9 @@ body {
grid-column: auto !important;
grid-row: auto !important;
}
-.selection-mode .transform-option img {
- height: 35vh !important;
- max-height: 400px;
- object-fit: contain;
+.selection-mode .transform-image-wrapper {
+ height: 45vh !important;
+ max-height: 500px;
}
/* -90°: col 4, linha 2 (empilhado sob +90°) */
.transform-grid.grid-portrait .transform-option:nth-child(5) { grid-column: 4; grid-row: 2; }
@@ -786,6 +785,7 @@ body {
align-items: center;
min-height: 0;
overflow: hidden;
+ position: relative; /* Para posicionar o ajuste fino absoluto */
}
.transform-option:hover {
@@ -798,13 +798,28 @@ body {
background: rgba(81, 207, 102, 0.08);
}
-.transform-option img {
+/* Novo Wrapper para a Imagem */
+.transform-image-wrapper {
+ position: relative;
+ width: 100%;
+ height: 15vh;
+ min-height: 120px;
+ max-height: 250px;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ overflow: hidden;
+ border-radius: 4px;
+ background: rgba(0,0,0,0.02);
+ margin-bottom: 10px;
+}
+
+.transform-image-wrapper img {
max-width: 100%;
- flex: 1;
- min-height: 0;
+ max-height: 100%;
object-fit: contain;
border-radius: 4px;
- margin-bottom: 10px;
+ transition: transform 0.15s ease-out; /* Transição para ajuste fino suave */
}
.transform-name {
@@ -814,6 +829,64 @@ body {
flex-shrink: 0;
}
+/* Estilo do Ajuste Fino Sobreposto como Marca d'Água */
+#fineTuneContainer {
+ position: absolute;
+ bottom: 45px; /* Logo acima do transform-name */
+ left: 50%;
+ transform: translateX(-50%);
+ background: rgba(255, 255, 255, 0.96);
+ backdrop-filter: blur(8px);
+ -webkit-backdrop-filter: blur(8px);
+ border: 1px solid rgba(0, 0, 0, 0.15);
+ border-radius: 30px;
+ padding: 6px 12px;
+ box-shadow: 0 4px 15px rgba(0, 0, 0, 0.18);
+ z-index: 100;
+ display: flex;
+ align-items: center;
+ gap: 8px;
+ width: max-content;
+ animation: fadeIn 0.2s ease-out;
+}
+
+@keyframes fadeIn {
+ from { opacity: 0; transform: translateX(-50%) translateY(5px); }
+ to { opacity: 1; transform: translateX(-50%) translateY(0); }
+}
+
+#fineTuneContainer button {
+ background: #f1f3f5;
+ border: 1px solid #ced4da;
+ border-radius: 50%;
+ width: 32px;
+ height: 32px;
+ padding: 0;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ font-size: 0.8rem;
+ font-weight: 700;
+ color: #495057;
+ cursor: pointer;
+ transition: all 0.15s ease;
+}
+
+#fineTuneContainer button:hover {
+ background: #e9ecef;
+ border-color: #adb5bd;
+ color: #212529;
+}
+
+#fineTuneContainer .fine-tune-val-display {
+ min-width: 48px;
+ text-align: center;
+ font-family: monospace;
+ font-weight: 700;
+ font-size: 1rem;
+ color: var(--primary-color);
+}
+
/* ================================================================
@@ -1072,3 +1145,240 @@ body {
#toggleDisabledBtn { font-size: 0; padding: 10px; }
#toggleDisabledBtn::before { content: '👁'; font-size: 1.1rem; }
}
+
+/* ================================================================
+ SYNC & UPLOAD MODAL STYLES
+ ================================================================ */
+
+.sync-tabs {
+ display: flex;
+ border-bottom: 2px solid var(--border-color);
+ margin-bottom: 20px;
+ gap: 10px;
+}
+
+.sync-tab-btn {
+ padding: 12px 20px;
+ background: none;
+ border: none;
+ border-bottom: 3px solid transparent;
+ font-size: 1rem;
+ font-weight: 600;
+ color: var(--text-secondary);
+ cursor: pointer;
+ transition: all 0.25s ease;
+}
+
+.sync-tab-btn:hover {
+ color: var(--primary-color);
+}
+
+.sync-tab-btn.active {
+ color: var(--primary-color);
+ border-bottom-color: var(--primary-color);
+}
+
+.sync-tab-content {
+ display: none;
+ animation: slideDown 0.25s ease;
+}
+
+.sync-tab-content.active {
+ display: block;
+}
+
+/* Área de Drag & Drop */
+.drag-drop-zone {
+ border: 3px dashed var(--border-color);
+ border-radius: var(--radius);
+ padding: 40px 20px;
+ text-align: center;
+ background: #fdfdfd;
+ cursor: pointer;
+ transition: all 0.2s ease;
+ margin-bottom: 20px;
+}
+
+.drag-drop-zone:hover,
+.drag-drop-zone.drag-active {
+ border-color: var(--primary-color);
+ background: rgba(102, 126, 234, 0.04);
+}
+
+.drag-drop-icon {
+ font-size: 3rem;
+ margin-bottom: 12px;
+}
+
+.drag-drop-text {
+ font-size: 1rem;
+ color: var(--text-color);
+ font-weight: 500;
+ margin-bottom: 6px;
+}
+
+.drag-drop-subtext {
+ font-size: 0.82rem;
+ color: var(--text-secondary);
+}
+
+/* Preview de arquivos selecionados */
+.upload-previews {
+ display: grid;
+ grid-template-columns: repeat(auto-fill, minmax(80px, 1fr));
+ gap: 10px;
+ margin-bottom: 20px;
+}
+
+.preview-item {
+ position: relative;
+ aspect-ratio: 1;
+ border-radius: 6px;
+ overflow: hidden;
+ border: 1px solid var(--border-color);
+}
+
+.preview-item img {
+ width: 100%;
+ height: 100%;
+ object-fit: cover;
+}
+
+.preview-remove {
+ position: absolute;
+ top: 4px;
+ right: 4px;
+ background: rgba(220, 53, 69, 0.85);
+ color: white;
+ border: none;
+ border-radius: 50%;
+ width: 18px;
+ height: 18px;
+ font-size: 10px;
+ cursor: pointer;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ line-height: 1;
+}
+
+.preview-remove:hover {
+ background: #dc3545;
+}
+
+/* Barra de Progresso */
+.upload-progress-container {
+ background: #f8f9fa;
+ border-radius: 8px;
+ padding: 15px;
+ margin-bottom: 20px;
+ border: 1px solid var(--border-color);
+}
+
+.progress-bar-label {
+ display: flex;
+ justify-content: space-between;
+ font-size: 0.85rem;
+ font-weight: 600;
+ margin-bottom: 8px;
+ color: var(--dark-color);
+}
+
+.progress-bar-track {
+ background: #e2e8f0;
+ border-radius: 10px;
+ height: 8px;
+ overflow: hidden;
+}
+
+.progress-bar-fill {
+ background: linear-gradient(90deg, var(--primary-color) 0%, #764ba2 100%);
+ height: 100%;
+ width: 0%;
+ transition: width 0.2s ease;
+}
+
+/* Lista de dispositivos online */
+.sync-device-list {
+ display: flex;
+ flex-direction: column;
+ gap: 12px;
+ margin: 20px 0;
+}
+
+.sync-device-card {
+ background: #f8f9fa;
+ border: 1px solid var(--border-color);
+ border-radius: var(--radius-sm);
+ padding: 15px;
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+ transition: all 0.2s ease;
+}
+
+.sync-device-card:hover {
+ border-color: var(--primary-color);
+ background: #fff;
+ box-shadow: 0 4px 12px rgba(0,0,0,0.03);
+}
+
+.device-card-left {
+ display: flex;
+ flex-direction: column;
+ gap: 4px;
+}
+
+.device-card-title {
+ font-weight: 700;
+ font-size: 0.95rem;
+ color: var(--dark-color);
+}
+
+.device-card-subtitle {
+ font-size: 0.78rem;
+ color: var(--text-secondary);
+}
+
+.device-card-badge {
+ padding: 5px 12px;
+ border-radius: 20px;
+ font-size: 0.72rem;
+ font-weight: 700;
+}
+
+.badge-connected {
+ background: rgba(81, 207, 102, 0.15);
+ color: var(--success-color);
+}
+
+.badge-disconnected {
+ background: rgba(220, 53, 69, 0.1);
+ color: var(--danger-color);
+}
+
+/* Botão de Excluir Paciente nos cards iniciais */
+.delete-patient-btn {
+ position: absolute;
+ top: 10px;
+ right: 10px;
+ background: rgba(220, 53, 69, 0.85);
+ color: white;
+ border: none;
+ border-radius: 50%;
+ width: 34px;
+ height: 34px;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ cursor: pointer;
+ z-index: 5;
+ transition: all 0.2s ease;
+ font-size: 1.05rem;
+ box-shadow: 0 2px 6px rgba(0,0,0,0.25);
+}
+
+.delete-patient-btn:hover {
+ background: #dc3545;
+ transform: scale(1.1);
+}
diff --git a/dental-server/routes/images.js b/dental-server/routes/images.js
index b35aca6..51ed393 100644
--- a/dental-server/routes/images.js
+++ b/dental-server/routes/images.js
@@ -4,6 +4,8 @@ const db = require('../database');
const imageProcessor = require('../image-processor');
const path = require('path');
const fs = require('fs').promises;
+const storage = require('../storage');
+const sharp = require('sharp');
// ================================================================
// GET /api/images - Listar imagens
@@ -64,12 +66,12 @@ router.get('/patients', async (req, res) => {
const rows = await db.all(
`SELECT
patient_name,
- doctor,
- remark,
- client_name,
+ MAX(doctor) AS doctor,
+ MAX(remark) AS remark,
+ MAX(client_name) AS client_name,
COUNT(*) AS image_count,
MAX(created_at) AS last_date,
- (SELECT filename FROM images i2
+ (SELECT COALESCE(thumb_filename, filename) FROM images i2
WHERE i2.patient_name = images.patient_name AND i2.enabled = ${enabledVal}
ORDER BY i2.created_at DESC LIMIT 1) AS thumb_filename
FROM images
@@ -114,6 +116,107 @@ router.get('/by-patient', async (req, res) => {
}
});
+// ================================================================
+// POST /api/images/upload - Fazer upload manual de imagem
+// ================================================================
+router.post('/upload', async (req, res) => {
+ try {
+ const { imageBase64, filename, patientName, doctor, remark } = req.body;
+
+ if (!imageBase64) {
+ return res.status(400).json({ error: 'imageBase64 é obrigatório' });
+ }
+
+ // Decodificar imagem base64
+ let base64Data = imageBase64;
+ if (base64Data.includes(';base64,')) {
+ base64Data = base64Data.split(';base64,')[1];
+ }
+ const imageBuffer = Buffer.from(base64Data, 'base64');
+
+ // TODO(security): Adicionado limite de 10MB para prevenir Buffer Overflow/DoS
+ if (imageBuffer.length > 10 * 1024 * 1024) {
+ return res.status(400).json({ error: 'A imagem excede o limite de tamanho permitido de 10MB.' });
+ }
+
+ // Validar imagem (garante integridade do arquivo através do sharp)
+ await imageProcessor.validateImage(imageBuffer);
+
+ // Salvar imagem
+ const imageGuid = 'web_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
+
+ // Detectar formato
+ const imgMetadata = await sharp(imageBuffer).metadata();
+ const format = imgMetadata.format || 'png';
+ const ext = format === 'jpeg' ? 'jpg' : format;
+ const savedFilename = `${Date.now()}_${imageGuid}.${ext}`;
+
+ const clientName = 'Upload Web';
+ const patientVal = patientName ? patientName.trim() : 'Paciente não identificado';
+
+ await storage.saveImage(savedFilename, imageBuffer, clientName, patientVal, false);
+
+ // Gerar thumbnail WebP
+ let thumbFilename = null;
+ try {
+ const thumbBuffer = await sharp(imageBuffer)
+ .resize({ width: 400, height: 400, fit: 'inside', withoutEnlargement: true })
+ .webp({ quality: 80, effort: 4 })
+ .toBuffer();
+
+ thumbFilename = `thumb_${Date.now()}_${imageGuid}.webp`;
+ await storage.saveImage(thumbFilename, thumbBuffer, clientName, patientVal, false);
+ console.log(`✅ Thumbnail gerado e salvo para upload manual: ${thumbFilename}`);
+ } catch (thumbErr) {
+ console.error('⚠️ Falha ao gerar thumbnail para upload manual:', thumbErr.message);
+ }
+
+ // Inserir no banco de dados
+ const formatLocalDateTime = (date) => {
+ const pad = (num) => String(num).padStart(2, '0');
+ return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+ };
+ const createdAt = formatLocalDateTime(new Date());
+
+ const result = await db.run(
+ `INSERT INTO images (
+ image_guid,
+ patient_name,
+ client_name,
+ original_filename,
+ filename,
+ enabled,
+ doctor,
+ remark,
+ thumb_filename,
+ created_at
+ ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+ [
+ imageGuid,
+ patientVal,
+ clientName,
+ filename || 'upload_manual.png',
+ savedFilename,
+ 1,
+ doctor || null,
+ remark || null,
+ thumbFilename,
+ createdAt
+ ]
+ );
+
+ res.json({
+ success: true,
+ imageId: result.lastID,
+ filename: savedFilename,
+ message: 'Imagem enviada com sucesso!'
+ });
+ } catch (error) {
+ console.error('Erro no upload de imagem manual:', error);
+ res.status(500).json({ error: error.message });
+ }
+});
+
// ================================================================
// GET /api/images/:id - Buscar imagem por ID
// ================================================================
@@ -164,19 +267,13 @@ router.get('/:id/transformations', async (req, res) => {
const originalId = image.original_image_id || image.id;
const originalImage = await db.get('SELECT * FROM images WHERE id = ?', [originalId]);
- const originalPath = path.join(__dirname, '../uploads', originalImage.filename);
- let originalBuffer;
+ let originalBuffer = await storage.getImageBuffer(originalImage.filename, false);
+ if (!originalBuffer) {
+ originalBuffer = await storage.getImageBuffer(originalImage.filename, true);
+ }
- try {
- originalBuffer = await fs.readFile(originalPath);
- } catch (e) {
- if (e.code === 'ENOENT') {
- // Fallback for images corrupted by previous bug
- const fallbackPath = path.join(__dirname, '../processed', originalImage.filename);
- originalBuffer = await fs.readFile(fallbackPath);
- } else {
- throw e;
- }
+ if (!originalBuffer) {
+ return res.status(404).json({ error: 'Arquivo de imagem original não encontrado' });
}
const transformations = [
@@ -228,17 +325,13 @@ router.post('/:id/transform', async (req, res) => {
const realOriginal = await db.get('SELECT * FROM images WHERE id = ?', [realOriginalId]);
// Processar a imagem
- const originalPath = path.join(__dirname, '../uploads', realOriginal.filename);
- let originalBuffer;
- try {
- originalBuffer = await fs.readFile(originalPath);
- } catch (e) {
- if (e.code === 'ENOENT') {
- const fallbackPath = path.join(__dirname, '../processed', realOriginal.filename);
- originalBuffer = await fs.readFile(fallbackPath);
- } else {
- throw e;
- }
+ let originalBuffer = await storage.getImageBuffer(realOriginal.filename, false);
+ if (!originalBuffer) {
+ originalBuffer = await storage.getImageBuffer(realOriginal.filename, true);
+ }
+
+ if (!originalBuffer) {
+ return res.status(404).json({ error: 'Arquivo de imagem original não encontrado' });
}
let processed = await imageProcessor.rotate(originalBuffer, rotation);
@@ -247,8 +340,7 @@ router.post('/:id/transform', async (req, res) => {
// Salvar nova versão em processed
const timestamp = Date.now();
const processedFilename = `${realOriginal.image_guid}_${timestamp}.png`;
- const processedPath = path.join(__dirname, '../processed', processedFilename);
- await fs.writeFile(processedPath, processed);
+ await storage.saveImage(processedFilename, processed, realOriginal.client_name, realOriginal.patient_name, true);
// Desabilitar a imagem atual para que não fique duplicada na interface
await db.run('UPDATE images SET enabled = 0 WHERE id = ?', [req.params.id]);
@@ -339,6 +431,37 @@ router.get('/:id/download', async (req, res) => {
}
});
+// ================================================================
+// DELETE /api/images/by-patient - Apagar todas as imagens de um paciente
+// ================================================================
+router.delete('/by-patient', async (req, res) => {
+ try {
+ const patientName = req.query.name || '';
+ if (!patientName) {
+ return res.status(400).json({ error: 'Nome do paciente é obrigatório' });
+ }
+
+ // Buscar todas as imagens do paciente no banco de dados
+ const images = await db.all('SELECT filename, client_name, patient_name FROM images WHERE patient_name = ?', [patientName]);
+
+ // Apagar cada imagem do storage (Wasabi S3 + Local)
+ for (const img of images) {
+ await storage.deleteImage(img.filename, img.client_name, img.patient_name);
+ }
+
+ // Apagar os registros do banco de dados
+ await db.run('DELETE FROM images WHERE patient_name = ?', [patientName]);
+
+ res.json({
+ success: true,
+ message: `Todas as imagens do paciente "${patientName}" foram excluídas com sucesso do servidor e do Wasabi.`
+ });
+ } catch (error) {
+ console.error('Erro ao excluir imagens do paciente em lote:', error);
+ res.status(500).json({ error: error.message });
+ }
+});
+
// ================================================================
// DELETE /api/images/:id - Apagar versão da imagem
// ================================================================
@@ -357,13 +480,8 @@ router.delete('/:id', async (req, res) => {
});
}
- // Apagar arquivo
- const filePath = path.join(__dirname, '../processed', image.filename);
- try {
- await fs.unlink(filePath);
- } catch (e) {
- console.warn('Arquivo não encontrado para deletar:', filePath);
- }
+ // Apagar arquivo do storage (Wasabi S3 + Local)
+ await storage.deleteImage(image.filename, image.client_name, image.patient_name);
// Apagar do banco
await db.run('DELETE FROM images WHERE id = ?', [req.params.id]);
diff --git a/dental-server/routes/system.js b/dental-server/routes/system.js
index 5ad145c..61e728a 100644
--- a/dental-server/routes/system.js
+++ b/dental-server/routes/system.js
@@ -68,4 +68,29 @@ router.delete('/factory-reset', async (req, res) => {
}
});
+// ================================================================
+// GET /api/system/storage-config - Obter configurações de storage
+// ================================================================
+router.get('/storage-config', (req, res) => {
+ try {
+ const storage = require('../storage');
+ res.json(storage.getSafeConfig());
+ } catch (error) {
+ res.status(500).json({ error: error.message });
+ }
+});
+
+// ================================================================
+// POST /api/system/storage-config - Atualizar configurações de storage
+// ================================================================
+router.post('/storage-config', async (req, res) => {
+ try {
+ const storage = require('../storage');
+ const result = await storage.updateConfig(req.body);
+ res.json(result);
+ } catch (error) {
+ res.status(500).json({ error: error.message });
+ }
+});
+
module.exports = router;
diff --git a/dental-server/server.js b/dental-server/server.js
index c9adb94..b370ded 100644
--- a/dental-server/server.js
+++ b/dental-server/server.js
@@ -5,6 +5,7 @@ const fs = require('fs').promises;
const path = require('path');
const cors = require('cors');
const cookieParser = require('cookie-parser');
+const sharp = require('sharp');
require('dotenv').config();
// Importar módulos
@@ -12,6 +13,7 @@ const imageProcessor = require('./image-processor');
const { authenticateToken, hashPassword, JWT_SECRET } = require('./auth');
const jwt = require('jsonwebtoken');
const db = require('./database');
+const storage = require('./storage');
const authRoutes = require('./routes/auth');
const imageRoutes = require('./routes/images');
const patientsRouter = require('./routes/patients');
@@ -401,8 +403,44 @@ app.use('/login', express.static('auth'));
// Serve static files
app.use(express.static('public'));
-app.use('/uploads', express.static(UPLOAD_DIR));
-app.use('/uploads', express.static(PROCESSED_DIR));
+
+app.get('/uploads/:filename', async (req, res) => {
+ const filename = req.params.filename;
+
+ // Enviar ETag e Cache-Control imutável
+ res.setHeader('ETag', `"${filename}"`);
+ res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
+
+ const clientEtag = req.headers['if-none-match'];
+ if (clientEtag === `"${filename}"` || clientEtag === filename || clientEtag === `W/"${filename}"`) {
+ return res.status(304).end();
+ }
+
+ // Tentar primeiro obter da pasta de uploads (imagens originais)
+ let buffer = await storage.getImageBuffer(filename, false);
+
+ // Se não encontrar, tentar da pasta de processed (imagens rotacionadas/transformadas)
+ if (!buffer) {
+ buffer = await storage.getImageBuffer(filename, true);
+ }
+
+ if (!buffer) {
+ return res.status(404).send('Imagem não encontrada');
+ }
+
+ const ext = path.extname(filename).toLowerCase();
+ let contentType = 'image/png';
+ if (ext === '.jpg' || ext === '.jpeg') {
+ contentType = 'image/jpeg';
+ } else if (ext === '.webp') {
+ contentType = 'image/webp';
+ } else if (ext === '.svg') {
+ contentType = 'image/svg+xml';
+ }
+
+ res.setHeader('Content-Type', contentType);
+ res.send(buffer);
+});
// ================================================================
// MIDDLEWARE DE VERIFICAÇÃO DE INSTALAÇÃO (APENAS PARA APIs)
@@ -456,10 +494,29 @@ app.use('/api/images', imageRoutes);
app.use('/api/gtos', authenticateToken);
app.use('/api/gtos', gtosRouter);
-// APIs do Sistema - requerem autenticação
app.use('/api/system', authenticateToken);
app.use('/api/system', systemRoutes);
+// Endpoint para solicitar a sincronização aos dispositivos conectados
+app.post('/api/system/trigger-sync', authenticateToken, (req, res) => {
+ try {
+ const windowsClients = connectedClients.filter(c => c.type === 'windows');
+
+ // Envia o evento 'sync-request' com timestamp para todos os dispositivos clientes identificados
+ io.emit('sync-request', { timestamp: Date.now() });
+ console.log(`🔄 [Sync] Sinal de sincronização enviado para ${windowsClients.length} dispositivo(s) Windows.`);
+
+ res.json({
+ success: true,
+ devicesTriggered: windowsClients.length,
+ message: `Sinal de sincronização enviado com sucesso para ${windowsClients.length} dispositivo(s) Windows.`
+ });
+ } catch (error) {
+ console.error('Erro ao solicitar sincronização:', error);
+ res.status(500).json({ error: error.message });
+ }
+});
+
// ================================================================
// SOCKET.IO - CONEXÕES EM TEMPO REAL
// ================================================================
@@ -613,16 +670,37 @@ io.on('connection', (socket) => {
// Validar imagem
await imageProcessor.validateImage(imageBuffer);
+ // Detectar formato da imagem e gerar extensão adequada
+ const imgMetadata = await sharp(imageBuffer).metadata();
+ const format = imgMetadata.format || 'png';
+ const ext = format === 'jpeg' ? 'jpg' : format;
+
// Salvar imagem original
const timestamp = Date.now();
- const filename = `${timestamp}_${data.metadata.guid}.png`;
+ const filename = `${timestamp}_${data.metadata.guid}.${ext}`;
const filePath = path.join(UPLOAD_DIR, filename);
- await fs.writeFile(filePath, imageBuffer);
-
// Buscar nome do cliente se identificado
const clientInfo = connectedClients.find(c => c.socketId === socket.id);
const clientName = clientInfo ? clientInfo.name : 'Cliente não identificado';
+ const patientName = data.patientData.name || 'Paciente não identificado';
+
+ await storage.saveImage(filename, imageBuffer, clientName, patientName, false);
+
+ // Gerar e salvar thumbnail WebP
+ let thumbFilename = null;
+ try {
+ const thumbBuffer = await sharp(imageBuffer)
+ .resize({ width: 400, height: 400, fit: 'inside', withoutEnlargement: true })
+ .webp({ quality: 80, effort: 4 })
+ .toBuffer();
+
+ thumbFilename = `thumb_${timestamp}_${data.metadata.guid}.webp`;
+ await storage.saveImage(thumbFilename, thumbBuffer, clientName, patientName, false);
+ console.log(`✅ Thumbnail gerado e salvo no Wasabi: ${thumbFilename}`);
+ } catch (thumbErr) {
+ console.error('⚠️ Falha ao gerar thumbnail, prosseguindo sem ele:', thumbErr.message);
+ }
// Determinar data de criação
const formatLocalDateTime = (date) => {
@@ -643,8 +721,9 @@ io.on('connection', (socket) => {
enabled,
doctor,
remark,
+ thumb_filename,
created_at
- ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+ ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
[
data.metadata.guid,
data.patientData.name || 'Paciente não identificado',
@@ -654,6 +733,7 @@ io.on('connection', (socket) => {
1,
data.patientData.doctor || null,
data.patientData.remark || null,
+ thumbFilename,
createdAt
]
);
@@ -685,6 +765,7 @@ io.on('connection', (socket) => {
doctor: data.patientData.doctor || null,
remark: data.patientData.remark || null,
filename: filename,
+ thumb_filename: thumbFilename,
created_at: createdAt
});
}
@@ -812,26 +893,35 @@ async function initDirectories() {
}
async function start() {
+ const fsSync = require('fs');
try {
// Inicializar diretórios
await initDirectories();
- // Tentar inicializar banco apenas se .env já existe
- const envPath = path.join(__dirname, '.env');
- const fsSync = require('fs');
-
- if (fsSync.existsSync(envPath)) {
+ // Inicializar banco se as variáveis já existirem no ambiente
+ if (process.env.DB_TYPE === 'sqlite' || (process.env.DB_HOST && process.env.DB_NAME)) {
try {
- // Recarregar .env se foi atualizado
- require('dotenv').config();
-
- // Inicializar banco de dados apenas se configurações existem
- if (process.env.DB_TYPE === 'sqlite' || (process.env.DB_HOST && process.env.DB_NAME)) {
- await db.initDatabase();
- console.log('✅ Banco de dados inicializado');
- }
+ await db.initDatabase();
+ console.log('✅ Banco de dados inicializado a partir do ambiente');
+ await storage.loadConfigFromDb();
} catch (error) {
- console.log('⚠️ Banco de dados não configurado. Execute a instalação em /install');
+ console.log('❌ Falha ao inicializar o banco de dados:', error.message);
+ }
+ } else {
+ // Fallback para arquivo .env físico
+ const envPath = path.join(__dirname, '.env');
+ const fsSync = require('fs');
+ if (fsSync.existsSync(envPath)) {
+ try {
+ require('dotenv').config();
+ if (process.env.DB_TYPE === 'sqlite' || (process.env.DB_HOST && process.env.DB_NAME)) {
+ await db.initDatabase();
+ console.log('✅ Banco de dados inicializado a partir do .env');
+ await storage.loadConfigFromDb();
+ }
+ } catch (error) {
+ console.log('⚠️ Banco de dados não configurado. Execute a instalação em /install');
+ }
}
}
diff --git a/dental-server/storage.js b/dental-server/storage.js
new file mode 100644
index 0000000..50e93a1
--- /dev/null
+++ b/dental-server/storage.js
@@ -0,0 +1,338 @@
+const { S3Client } = require('@aws-sdk/client-s3');
+const { Upload } = require('@aws-sdk/lib-storage');
+const fs = require('fs').promises;
+const fsSync = require('fs');
+const path = require('path');
+
+// Configurações das pastas (resolvendo caminhos corretos)
+const UPLOAD_DIR = process.env.UPLOAD_DIR || path.join(__dirname, 'uploads');
+const PROCESSED_DIR = process.env.PROCESSED_DIR || path.join(__dirname, 'processed');
+const CONFIG_FILE = path.join(UPLOAD_DIR, 'wasabi_config.json');
+
+let s3 = null;
+let currentBucket = null;
+let currentConfig = {};
+
+// Função para inicializar/reconfigurar o S3 Client
+function initS3(cfg = {}) {
+ const accessKey = cfg.wasabiAccessKey || process.env.WASABI_ACCESS_KEY;
+ const secretKey = cfg.wasabiSecretKey || process.env.WASABI_SECRET_KEY;
+ const region = cfg.wasabiRegion || process.env.WASABI_REGION || 'us-east-1';
+ const bucket = cfg.wasabiBucket || process.env.WASABI_BUCKET;
+ const rawEndpoint = cfg.wasabiEndpoint || process.env.WASABI_ENDPOINT || 's3.wasabisys.com';
+ const endpoint = rawEndpoint.startsWith('http') ? rawEndpoint : `https://${rawEndpoint}`;
+
+ currentConfig = {
+ wasabiAccessKey: accessKey || '',
+ wasabiSecretKey: secretKey || '',
+ wasabiBucket: bucket || '',
+ wasabiRegion: region || 'us-east-1',
+ wasabiEndpoint: rawEndpoint || 's3.wasabisys.com'
+ };
+
+ if (accessKey && secretKey && bucket) {
+ s3 = new S3Client({
+ region,
+ endpoint,
+ credentials: { accessKeyId: accessKey, secretAccessKey: secretKey },
+ forcePathStyle: true,
+ });
+ currentBucket = bucket;
+ console.log(`✅ [Wasabi] Inicializado com sucesso — Bucket: ${bucket}, Endpoint: ${endpoint}`);
+ } else {
+ s3 = null;
+ currentBucket = null;
+ console.log('⚠️ [Wasabi] Chaves WASABI_ACCESS_KEY, WASABI_SECRET_KEY ou WASABI_BUCKET não definidas no JSON/Banco/Ambiente. Wasabi desativado.');
+ }
+}
+
+// Inicializa a partir do arquivo JSON (se houver) ou das variáveis de ambiente (como fallback inicial síncrono)
+function loadConfigSync() {
+ try {
+ if (fsSync.existsSync(CONFIG_FILE)) {
+ const data = fsSync.readFileSync(CONFIG_FILE, 'utf8');
+ const cfg = JSON.parse(data);
+ console.log('📖 [Wasabi] Configuração dinâmica lida de wasabi_config.json');
+ initS3(cfg);
+ } else {
+ initS3({});
+ }
+ } catch (error) {
+ console.error('❌ [Wasabi] Erro ao carregar arquivo de config:', error.message);
+ initS3({});
+ }
+}
+
+// Inicializa a partir do Banco de Dados (Chamado de forma assíncrona após db.initDatabase)
+async function loadConfigFromDb() {
+ try {
+ const db = require('./database');
+ const keys = [
+ 'wasabi_access_key',
+ 'wasabi_secret_key',
+ 'wasabi_bucket',
+ 'wasabi_region',
+ 'wasabi_endpoint'
+ ];
+
+ const cfg = {};
+ let hasSettings = false;
+
+ for (const k of keys) {
+ const row = await db.get('SELECT value FROM settings WHERE key = ?', [k]);
+ if (row) {
+ // Mapear de snake_case do banco para camelCase do config
+ const camelKey = k.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
+ cfg[camelKey] = row.value;
+ hasSettings = true;
+ }
+ }
+
+ if (hasSettings) {
+ console.log('📖 [Wasabi] Configuração carregada com sucesso do Banco de Dados.');
+ initS3(cfg);
+ } else {
+ // Se não há settings no banco, tenta carregar do fallback JSON
+ loadConfigSync();
+ }
+ } catch (error) {
+ console.error('❌ [Wasabi] Erro ao carregar do banco, usando fallback:', error.message);
+ loadConfigSync();
+ }
+}
+
+// Inicialização imediata de fallback (síncrona)
+loadConfigSync();
+
+// Retorna a configuração atual de forma segura (mascarando a senha/secret key)
+function getSafeConfig() {
+ return {
+ wasabiAccessKey: currentConfig.wasabiAccessKey,
+ wasabiSecretKey: currentConfig.wasabiSecretKey ? '********' : '',
+ wasabiBucket: currentConfig.wasabiBucket,
+ wasabiRegion: currentConfig.wasabiRegion,
+ wasabiEndpoint: currentConfig.wasabiEndpoint,
+ enabled: !!(s3 && currentBucket)
+ };
+}
+
+// Salva e atualiza a configuração (no banco de dados e no arquivo de redundância local)
+async function updateConfig(newConfig) {
+ try {
+ const db = require('./database');
+
+ // Se a secretKey vier como asteriscos, mantém a antiga
+ const finalSecretKey = newConfig.wasabiSecretKey === '********'
+ ? currentConfig.wasabiSecretKey
+ : newConfig.wasabiSecretKey;
+
+ const configToSave = {
+ wasabiAccessKey: newConfig.wasabiAccessKey || '',
+ wasabiSecretKey: finalSecretKey || '',
+ wasabiBucket: newConfig.wasabiBucket || '',
+ wasabiRegion: newConfig.wasabiRegion || 'us-east-1',
+ wasabiEndpoint: newConfig.wasabiEndpoint || 's3.wasabisys.com'
+ };
+
+ // 1. Salva no banco de dados (com suporte a ON CONFLICT UPSERT do PostgreSQL e SQLite)
+ const settingsMap = {
+ 'wasabi_access_key': configToSave.wasabiAccessKey,
+ 'wasabi_secret_key': configToSave.wasabiSecretKey,
+ 'wasabi_bucket': configToSave.wasabiBucket,
+ 'wasabi_region': configToSave.wasabiRegion,
+ 'wasabi_endpoint': configToSave.wasabiEndpoint
+ };
+
+ for (const [key, val] of Object.entries(settingsMap)) {
+ await db.run(
+ `INSERT INTO settings (key, value)
+ VALUES (?, ?)
+ ON CONFLICT (key)
+ DO UPDATE SET value = EXCLUDED.value`,
+ [key, val]
+ );
+ }
+ console.log('💾 [Wasabi] Configurações persistidas no Banco de Dados.');
+
+ // 2. Salva localmente no arquivo de redundância JSON
+ try {
+ await fs.mkdir(path.dirname(CONFIG_FILE), { recursive: true });
+ await fs.writeFile(CONFIG_FILE, JSON.stringify(configToSave, null, 2), 'utf8');
+ console.log('💾 [Wasabi] Cópia de segurança salva em wasabi_config.json');
+ } catch (fsErr) {
+ console.warn('⚠️ [Wasabi] Falha ao gravar cópia em arquivo de config:', fsErr.message);
+ }
+
+ initS3(configToSave);
+ return { success: true };
+ } catch (error) {
+ console.error('❌ [Wasabi] Erro ao salvar configurações:', error.message);
+ throw error;
+ }
+}
+
+// Higieniza nomes para caminhos do S3
+function sanitizePathSegment(segment) {
+ if (!segment) return 'desconhecido';
+ return segment.trim().replace(/[\/\\?#%*:"<>|]/g, '_');
+}
+
+// Salva uma imagem (original ou processada) no disco local e envia para o Wasabi
+async function saveImage(filename, buffer, clientName, patientName, isProcessed = false) {
+ const targetDir = isProcessed ? PROCESSED_DIR : UPLOAD_DIR;
+ const destPath = path.join(targetDir, filename);
+
+ // 1. Salva localmente de forma temporária
+ await fs.mkdir(path.dirname(destPath), { recursive: true });
+ await fs.writeFile(destPath, buffer);
+ console.log(`💾 [Storage] Imagem salva localmente de forma temporária: ${destPath}`);
+
+ // 2. Envia para o Wasabi se ativo
+ if (s3 && currentBucket) {
+ try {
+ const cleanClient = sanitizePathSegment(clientName);
+ const cleanPatient = sanitizePathSegment(patientName);
+ const key = `${cleanClient}/${cleanPatient}/${filename}`;
+
+ const ext = path.extname(filename).toLowerCase();
+ let contentType = 'image/png';
+ if (ext === '.jpg' || ext === '.jpeg') {
+ contentType = 'image/jpeg';
+ } else if (ext === '.webp') {
+ contentType = 'image/webp';
+ } else if (ext === '.svg') {
+ contentType = 'image/svg+xml';
+ }
+
+ const upload = new Upload({
+ client: s3,
+ params: {
+ Bucket: currentBucket,
+ Key: key,
+ Body: buffer,
+ ContentType: contentType,
+ },
+ });
+ await upload.done();
+ console.log(`☁️ [Wasabi] Upload concluído na pasta do cliente/paciente: ${key}`);
+
+ // Se o upload foi bem-sucedido e o Wasabi está ativo, removemos o arquivo local imediatamente
+ try {
+ await fs.unlink(destPath);
+ console.log(`🗑️ [Storage] Arquivo local temporário removido após upload no Wasabi: ${destPath}`);
+ } catch (unlinkErr) {
+ console.warn(`⚠️ [Storage] Falha ao remover arquivo local temporário: ${unlinkErr.message}`);
+ }
+ } catch (error) {
+ console.error(`❌ [Wasabi] Falha no upload de ${filename}:`, error.message);
+ // Mantemos o arquivo local se o Wasabi falhar como fallback resiliente
+ }
+ }
+}
+
+// Obtém o buffer da imagem (lê localmente, e se não existir, tenta baixar do Wasabi)
+async function getImageBuffer(filename, clientName = null, patientName = null, isProcessed = false) {
+ const targetDir = isProcessed ? PROCESSED_DIR : UPLOAD_DIR;
+ const localPath = path.join(targetDir, filename);
+
+ // 1. Tenta ler local primeiro (para compatibilidade caso o Wasabi não estivesse ativo no salvamento inicial)
+ if (fsSync.existsSync(localPath)) {
+ return await fs.readFile(localPath);
+ }
+
+ // 2. Se não existir localmente, tenta obter do Wasabi
+ if (s3 && currentBucket) {
+ try {
+ let cName = clientName;
+ let pName = patientName;
+
+ // Se não foram passados, busca metadados no banco
+ if (!cName || !pName) {
+ try {
+ const db = require('./database');
+ const row = await db.get('SELECT client_name, patient_name FROM images WHERE filename = ? OR thumb_filename = ? LIMIT 1', [filename, filename]);
+ if (row) {
+ cName = row.client_name;
+ pName = row.patient_name;
+ }
+ } catch (dbErr) {
+ console.error('⚠️ [Storage] Erro ao buscar metadados do banco:', dbErr.message);
+ }
+ }
+
+ const cleanClient = sanitizePathSegment(cName);
+ const cleanPatient = sanitizePathSegment(pName);
+ const key = `${cleanClient}/${cleanPatient}/${filename}`;
+
+ console.log(`☁️ [Wasabi] Baixando do S3: ${key}`);
+ const { GetObjectCommand } = require('@aws-sdk/client-s3');
+ const response = await s3.send(new GetObjectCommand({
+ Bucket: currentBucket,
+ Key: key
+ }));
+
+ if (response.Body) {
+ const bytes = await response.Body.transformToByteArray();
+ const buffer = Buffer.from(bytes);
+
+ // TODO(security): Não salvamos no disco rígido local da VPS em cache para preservar privacidade e espaço.
+ // Apenas retornamos o buffer lido na memória diretamente para o servidor.
+ console.log(`☁️ [Wasabi] Servindo imagem diretamente do S3 sem gravar em cache local`);
+ return buffer;
+ }
+ } catch (error) {
+ console.error(`❌ [Wasabi] Falha ao recuperar do S3 para ${filename}:`, error.message);
+ }
+ }
+
+ return null;
+}
+
+// Exclui uma imagem (do disco local e do Wasabi S3)
+async function deleteImage(filename, clientName, patientName) {
+ // 1. Excluir localmente da pasta de uploads (imagens originais) e processed (imagens rotacionadas)
+ const localPaths = [
+ path.join(UPLOAD_DIR, filename),
+ path.join(PROCESSED_DIR, filename)
+ ];
+
+ for (const localPath of localPaths) {
+ try {
+ // Usando fsSync.existsSync para checagem síncrona segura
+ if (fsSync.existsSync(localPath)) {
+ await fs.unlink(localPath);
+ console.log(`🗑️ [Storage] Arquivo local excluído: ${localPath}`);
+ }
+ } catch (err) {
+ console.warn(`⚠️ [Storage] Falha ao excluir arquivo local ${localPath}:`, err.message);
+ }
+ }
+
+ // 2. Excluir do Wasabi S3 se ativo
+ if (s3 && currentBucket) {
+ try {
+ const cleanClient = sanitizePathSegment(clientName);
+ const cleanPatient = sanitizePathSegment(patientName);
+ const key = `${cleanClient}/${cleanPatient}/${filename}`;
+
+ const { DeleteObjectCommand } = require('@aws-sdk/client-s3');
+ await s3.send(new DeleteObjectCommand({
+ Bucket: currentBucket,
+ Key: key
+ }));
+ console.log(`🗑️ [Wasabi] Objeto excluído do S3: ${key}`);
+ } catch (err) {
+ console.error(`❌ [Wasabi] Falha ao excluir objeto ${filename} do S3:`, err.message);
+ }
+ }
+}
+
+module.exports = {
+ saveImage,
+ getImageBuffer,
+ deleteImage,
+ getSafeConfig,
+ updateConfig,
+ loadConfigFromDb,
+ isWasabiEnabled: () => !!(s3 && currentBucket)
+};
diff --git a/dental-server/test-db-query.js b/dental-server/test-db-query.js
new file mode 100644
index 0000000..8ac6055
--- /dev/null
+++ b/dental-server/test-db-query.js
@@ -0,0 +1,6 @@
+const db = require('./database');
+db.initDatabase().then(async () => {
+ const row = await db.get('SELECT id, filename, thumb_filename, client_name, patient_name FROM images WHERE id = 533');
+ console.log('Result:', row);
+ process.exit(0);
+});
diff --git a/docker-compose.yml b/docker-compose.yml
index bd55d4c..df943c2 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -8,15 +8,15 @@ services:
container_name: rx_scoreodonto_app
restart: unless-stopped
ports:
- - "80:3000"
+ - "8083:3000"
environment:
- NODE_ENV=production
- PORT=3000
- DB_TYPE=postgres
- DB_HOST=10.99.0.3
- DB_PORT=5432
- - DB_USER=postgres
- - DB_PASSWORD=sua_senha_segura # Altere no .env ou arquivo local se necessário
+ - DB_USER=clube67
+ - DB_PASSWORD=clube67_db_pass_9903
- DB_NAME=dental_images
- UPLOAD_DIR=/app/uploads
- PROCESSED_DIR=/app/processed