hlsv 1.0.0 → 2.0.0

data/public/js/analysis.js

@@ -0,0 +1,201 @@
+/*
+  Copyright (c) 2026 AdClin
+  Licensed under the GNU Affero General Public License v3.0 or later.
+  See the LICENSE file for details.
+*/
+
+import { configSave } from './config.js';
+import { refreshResults } from './results.js';
+import { formatDuration } from './utils.js';
+
+export async function startAnalysis() {
+  const statusDiv = document.getElementById('analysis-status');
+  const btn = document.getElementById('btn-process');
+
+  btn.disabled = true;
+  statusDiv.innerHTML = '<div class="status processing">⏳ Processing in progress...</div>';
+
+  // Save the configuration before starting the process
+  const configSaved = await configSave();
+  
+  if (!configSaved) {
+    statusDiv.innerHTML = `
+      <div class="status error">
+        <h3>❌ Configuration Error</h3>
+        <p>The configuration could not be saved. Please correct the errors before starting the analysis.</p>
+        <p style="margin-top: 10px; color: #666; font-size: 0.9em;">
+          Check the error message in the Configuration section above.
+        </p>
+      </div>
+    `;
+    btn.disabled = false;
+    return;
+  }
+
+  try {
+    // Start timing just before the HTTP request
+    const startTime = performance.now();
+
+    const response = await fetch('/proceed', {
+      method: 'POST'
+    });
+
+    const data = await response.json();
+
+    // Calculate total HTTP request duration
+    const elapsedTime = performance.now() - startTime;
+    const formattedDuration = formatDuration(elapsedTime);
+
+    if (data.success) {
+      let successMessage = `
+        <h3>✅ Analysis completed successfully!</h3>
+        <p style="margin-top: 10px;">
+          ⏱️ Processing time: <strong>${formattedDuration}</strong>
+        </p>
+      `;
+
+      // Display completed steps
+      if (data.result.steps) {
+        successMessage += '<div style="margin: 20px 0; text-align: left;">';
+        successMessage += '<h4>📋 Completed Steps:</h4>';
+        successMessage += '<ol>';
+
+        data.result.steps.forEach(step => {
+          let icon = '✅';
+          let color = '#28a745';
+
+          if (step.status === 'in_progress') {
+            icon = '⏳';
+            color = '#ffc107';
+          } else if (step.status === 'error') {
+            icon = '❌';
+            color = '#dc3545';
+          }
+
+          successMessage += `
+            <li style="color: ${color};">
+              ${icon} <strong>${step.name}:</strong>
+              ${step.message ? `<span style="color: #666; font-size: 0.9em;">${step.message}</span>` : ''}
+            </li>
+          `;
+        });
+
+        successMessage += '</ol></div>';
+      }
+
+      // Display report generation warnings, if any (analysis itself
+      // succeeded, but one or more of html/docx/excel failed to generate)
+      if (data.result.report_warnings && data.result.report_warnings.length > 0) {
+        successMessage += '<div style="margin: 20px 0; text-align: left;">';
+        successMessage += '<div class="status" style="background: #fff3cd; color: #856404; padding: 10px; border-radius: 4px;">';
+        successMessage += '<strong>⚠️ Some reports could not be generated:</strong>';
+        successMessage += '<ul style="margin: 5px 0 0; padding-left: 20px;">';
+        data.result.report_warnings.forEach(warning => {
+          successMessage += `<li>${warning}</li>`;
+        });
+        successMessage += '</ul></div></div>';
+      }
+
+      // Display generated files
+      // Note: nothing is written to disk yet at this point (html/docx/excel
+      // are generated on demand). The report link below triggers that
+      // generation the first time it's opened.
+      if (data.result.study_name || data.result.output_directory) {
+        successMessage += '<div style="margin: 20px 0; text-align: left;">';
+        successMessage += '<h4>📄 Output Files:</h4>';
+        successMessage += '<ul style="margin: 0; padding-left: 20px;">';
+
+        if (data.result.study_name) {
+          const reportUrl = '/report/' + encodeURIComponent(data.result.study_name) + '/html';
+          successMessage += `
+           <li>
+               <strong>Report:</strong>
+               <a href="${reportUrl}" target="_blank" rel="noopener noreferrer">
+                 View HTML report
+               </a>
+             </li>
+          `;
+        }
+        if (data.result.output_directory) {
+          successMessage += `<li><strong>Output Directory:</strong> ${data.result.output_directory}</li>`;
+        }
+
+        successMessage += '</ul></div>';
+      }
+
+      // Display statistics
+      if (data.result.analyzed_dataset_count || data.result.invalid_dataset_summary) {
+        successMessage += '<div style="margin: 20px 0; text-align: left;">';
+        successMessage += '<h4>📊 Dataset Statistics:</h4>';
+        successMessage += '<ul style="margin: 0; padding-left: 20px;">';
+
+        if (data.result.analyzed_dataset_count) {
+          successMessage += `<li><strong>Analyzed:</strong> ${data.result.analyzed_dataset_count}</li>`;
+        }
+
+        const invalidDatasets = data.result.invalid_dataset_summary;
+        if (invalidDatasets) {
+          if (invalidDatasets.invalid_dataset) {
+            successMessage += `<li><strong>With at least one issue:</strong> ${invalidDatasets.invalid_dataset}</li>`;
+          }
+          if (invalidDatasets.invalid_ascii) {
+            successMessage += `<li><strong>ASCII issue:</strong> ${invalidDatasets.invalid_ascii}</li>`;
+          }
+          if (invalidDatasets.invalid_define) {
+            successMessage += `<li><strong>Invalid keys in define.xml:</strong> ${invalidDatasets.invalid_define}</li>`;
+          } else {
+            successMessage += `<li>✅ <strong>All keys in define.xml are valid.</strong></li>`;
+          }
+          if (invalidDatasets.invalid_data) {
+            successMessage += `<li><strong>Minimum keys not found:</strong> ${invalidDatasets.invalid_data}</li>`;
+          }
+        }
+
+        successMessage += '</ul></div>';
+      }
+
+      statusDiv.innerHTML = `<div class="status">${successMessage}</div>`;
+
+      // Auto-refresh results if already loaded
+      const resultsList = document.getElementById('results-list');
+      if (resultsList.style.display !== 'none') {
+        refreshResults();
+      }
+
+    } else {
+      // Display validation errors
+      let errorMessage = `<h3>❌ ${data.error}</h3>`;
+
+      if (data.details && data.details.length > 0) {
+        errorMessage += '<div style="margin: 20px 0; text-align: left;">';
+        errorMessage += '<h4>Validation Errors:</h4>';
+        errorMessage += '<ul style="margin-left: 20px; color: #721c24;">';
+        data.details.forEach(errorItem => {
+          errorMessage += `<li style="margin: 5px 0;">${errorItem}</li>`;
+        });
+        errorMessage += '</ul></div>';
+        errorMessage += '<p style="margin-top: 15px;">⚠️ Please correct these errors before restarting the analysis</p>';
+      } else {
+        errorMessage += `<p style="margin-top: 15px;">${data.error}</p>`;
+      }
+
+      statusDiv.innerHTML = `<div class="status error">${errorMessage}</div>`;
+    }
+  } catch (error) {
+    statusDiv.innerHTML = `
+      <div class="status error">
+        <h3>❌ Connection Error</h3>
+        <p>${error.message}</p>
+        <p style="margin-top: 10px; color: #666; font-size: 0.9em;">
+          Please check that the server is running correctly (ruby app.rb)
+        </p>
+      </div>
+    `;
+  } finally {
+    btn.disabled = false;
+  }
+}
+
+// Results Management
+
+// Load results for the first time

data/public/js/app.js

@@ -0,0 +1,63 @@
+/*
+  Copyright (c) 2026 AdClin
+  Licensed under the GNU Affero General Public License v3.0 or later.
+  See the LICENSE file for details.
+*/
+
+import {
+  configSave,
+  fullConfigViewer,
+  clearFields,
+  loadDefaultConfig,
+  loadExistingConfig,
+  applyExistingConfig
+} from './config.js';
+
+import { startAnalysis } from './analysis.js';
+
+import {
+  loadResults,
+  refreshResults,
+  toggleFolder,
+  download,
+  openFile,
+  viewHtmlReport,
+  downloadFolderAsZip,
+  downloadExcelStudy,
+  downloadHtmlAsWord
+} from './results.js';
+
+import {
+  openBrowser,
+  closeBrowser,
+  navigateBrowse,
+  browseUp,
+  selectBrowseFile,
+  confirmBrowseSelection
+} from './browser.js';
+
+Object.assign(window, {
+  configSave,
+  fullConfigViewer,
+  clearFields,
+  loadDefaultConfig,
+  loadExistingConfig,
+  applyExistingConfig,
+  startAnalysis,
+  loadResults,
+  refreshResults,
+  toggleFolder,
+  download,
+  openFile,
+  viewHtmlReport,
+  downloadFolderAsZip,
+  downloadExcelStudy,
+  downloadHtmlAsWord,
+  openBrowser,
+  closeBrowser,
+  navigateBrowse,
+  browseUp,
+  selectBrowseFile,
+  confirmBrowseSelection
+});
+

data/public/js/browser.js

@@ -0,0 +1,172 @@
+/*
+  Copyright (c) 2026 AdClin
+  Licensed under the GNU Affero General Public License v3.0 or later.
+  See the LICENSE file for details.
+*/
+
+import { escapeHtml } from './utils.js';
+
+let browseTargetField = null;
+let browseOnSelect = null; // callback(path) - used instead of browseTargetField when target is a function
+let browseMode = 'directory'; // 'directory' or 'file'
+let browseExtFilter = '';
+let browseCurrentPath = '';
+let browseParentPath = null;
+
+// Extract the parent directory of a path. Handles both '/' and '\'
+// since paths in this app may come from Windows.
+function dirnameOf(path) {
+  const idx = Math.max(path.lastIndexOf('/'), path.lastIndexOf('\\'));
+  return idx > 0 ? path.slice(0, idx) : '';
+}
+
+// target: either a form field id (string) - filled directly on selection -
+// or a callback function(path) for actions that aren't a simple field fill
+// (e.g. loading an existing config file).
+// mode: 'directory' or 'file'. extFilter (file mode only): e.g. '.xml'.
+
+export function openBrowser(target, mode, extFilter = '') {
+  if (typeof target === 'function') {
+    browseTargetField = null;
+    browseOnSelect = target;
+  } else {
+    browseTargetField = target;
+    browseOnSelect = null;
+  }
+  browseMode = mode;
+  browseExtFilter = extFilter;
+
+  const title = document.getElementById('browse-modal-title');
+  const selectBtn = document.getElementById('browse-select-btn');
+
+  if (mode === 'file') {
+    title.textContent = `📁 Select a ${extFilter} file`.trim();
+    selectBtn.style.display = 'none'; // clicking a file selects it immediately
+  } else {
+    title.textContent = '📁 Select a directory';
+    selectBtn.style.display = '';
+    selectBtn.textContent = 'Select this folder';
+  }
+
+  document.getElementById('browse-modal').style.display = 'flex';
+
+  // Start from the target field's current value when there is one.
+  // In 'file' mode the field holds a *file* path, but /browse only lists
+  // directories, so we must start from its parent folder instead.
+  // Otherwise (or if that parent can't be determined) the server falls
+  // back to its launch directory (Dir.pwd).
+  const currentValue = browseTargetField ? document.getElementById(browseTargetField).value.trim() : '';
+  const startPath = (currentValue && currentValue !== '-')
+    ? (mode === 'file' ? dirnameOf(currentValue) : currentValue)
+    : '';
+  loadBrowsePath(startPath);
+}
+
+export function closeBrowser() {
+  document.getElementById('browse-modal').style.display = 'none';
+}
+
+export async function loadBrowsePath(path) {
+  const list = document.getElementById('browse-list');
+  list.innerHTML = '<p class="browse-empty">⏳ Loading...</p>';
+
+  try {
+    const url = `/browse?path=${encodeURIComponent(path)}&mode=${browseMode}&ext=${encodeURIComponent(browseExtFilter)}`;
+    const response = await fetch(url);
+    const data = await response.json();
+
+    if (!response.ok) {
+      list.innerHTML = `<p class="browse-empty">❌ ${escapeHtml(data.error || 'Unable to open this directory')}</p>`;
+      return;
+    }
+
+    browseCurrentPath = data.path;
+    browseParentPath = data.parent;
+    document.getElementById('browse-current-path').value = data.path;
+    document.getElementById('browse-up').disabled = !data.parent;
+
+    renderBrowseList(data);
+  } catch (error) {
+    list.innerHTML = `<p class="browse-empty">❌ Connection error: ${escapeHtml(error.message)}</p>`;
+  }
+}
+
+export function renderBrowseList(data) {
+  const list = document.getElementById('browse-list');
+  const folders = data.folders || [];
+  const files = data.files || [];
+
+  if (folders.length === 0 && files.length === 0) {
+    list.innerHTML = '<p class="browse-empty">Empty directory</p>';
+    return;
+  }
+
+  let html = '';
+
+  folders.forEach(entry => {
+    html += renderBrowseEntry('📁', entry.name, `navigateBrowse('${escapeAttr(entry.path)}')`);
+  });
+
+  // The server now returns files in both modes. In 'file' mode, clicking
+  // a file selects that exact file. In 'directory' mode, files are shown
+  // only so the user can confirm they're in the right place; clicking one
+  // selects the directory it lives in (the currently displayed directory).
+  files.forEach(entry => {
+    const onClickCall = browseMode === 'file'
+      ? `selectBrowseFile('${escapeAttr(entry.path)}')`
+      : 'confirmBrowseSelection()';
+    html += renderBrowseEntry('📄', entry.name, onClickCall);
+  });
+
+  list.innerHTML = html;
+}
+
+export function renderBrowseEntry(icon, name, onClickCall) {
+  return `
+    <div class="browse-entry" role="option" tabindex="0"
+         onclick="${onClickCall}"
+         onkeydown="if(event.key==='Enter'){${onClickCall}}">
+      ${icon} ${escapeHtml(name)}
+    </div>
+  `;
+}
+
+export function navigateBrowse(path) {
+  loadBrowsePath(path);
+}
+
+export function browseUp() {
+  if (browseParentPath) loadBrowsePath(browseParentPath);
+}
+
+export function selectBrowseFile(fullPath) {
+  if (browseOnSelect) {
+    browseOnSelect(fullPath);
+  } else {
+    document.getElementById(browseTargetField).value = fullPath;
+  }
+  closeBrowser();
+}
+
+export function confirmBrowseSelection() {
+  if (browseOnSelect) {
+    browseOnSelect(browseCurrentPath);
+  } else {
+    document.getElementById(browseTargetField).value = browseCurrentPath;
+  }
+  closeBrowser();
+}
+
+// Escape a value for safe interpolation inside an inline onclick attribute.
+
+export function escapeAttr(text) {
+  return text.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+
+// Close the browser modal on Escape
+document.addEventListener('keydown', (e) => {
+  if (e.key === 'Escape') {
+    const modal = document.getElementById('browse-modal');
+    if (modal && modal.style.display !== 'none') closeBrowser();
+  }
+});

data/public/js/config.js

@@ -0,0 +1,214 @@
+/*
+  Copyright (c) 2026 AdClin
+  Licensed under the GNU Affero General Public License v3.0 or later.
+  See the LICENSE file for details.
+*/
+
+import { showMessage } from './utils.js';
+import { openBrowser } from './browser.js';
+
+// Configuration Management
+
+export async function configSave() {
+  // Validate required fields
+  const requiredFields = [
+    'study_name', 'output_directory', 'data_directory', 
+    'define_path', 'event_key', 'intervention_key', 'finding_key',
+    'finding_about_key', 'ds_key', 'relrec_key', 'CO_key',
+    'TA_key', 'TE_key', 'TI_key', 'TS_key', 'TV_key'
+  ];
+
+  const missingFields = [];
+  for (const field of requiredFields) {
+    const element = document.getElementById(field);
+    if (!element.value.trim()) {
+      missingFields.push(field.replace(/_/g, ' ').toUpperCase());
+      element.classList.add('error-field');
+    } else {
+      element.classList.remove('error-field');
+    }
+  }
+
+  if (missingFields.length > 0) {
+    showMessage('config-issue', 'error',
+      `⚠️ Missing required fields: ${missingFields.join(', ')}`);
+    return false;
+  }
+
+  const config = {
+    study_name: document.getElementById('study_name').value.trim(),
+    output_type: 'csv',
+    output_directory: document.getElementById('output_directory').value.trim(),
+    data_directory: document.getElementById('data_directory').value.trim(),
+    define_path: document.getElementById('define_path').value.trim(),
+    excluded_ds: document.getElementById('excluded_ds').value.trim(),
+    event_key: document.getElementById('event_key').value.trim(),
+    intervention_key: document.getElementById('intervention_key').value.trim(),
+    finding_key: document.getElementById('finding_key').value.trim(),
+    finding_about_key: document.getElementById('finding_about_key').value.trim(),
+    ds_key: document.getElementById('ds_key').value.trim(),
+    relrec_key: document.getElementById('relrec_key').value.trim(),
+    CO_key: document.getElementById('CO_key').value.trim(),
+    TA_key: document.getElementById('TA_key').value.trim(),
+    TE_key: document.getElementById('TE_key').value.trim(),
+    TI_key: document.getElementById('TI_key').value.trim(),
+    TS_key: document.getElementById('TS_key').value.trim(),
+    TV_key: document.getElementById('TV_key').value.trim()
+  };
+
+  showMessage('config-issue', 'processing', '⏳ Saving configuration...');
+
+  try {
+    const response = await fetch('/config', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(config)
+    });
+
+    const data = await response.json();
+
+    if (data.success) {
+      showMessage('config-issue', 'success', '✅ ' + data.message);
+      return true;
+    } else {
+      showMessage('config-issue', 'error', '❌ ' + data.error);
+      return false;
+    }
+  } catch (error) {
+    showMessage('config-issue', 'error', '❌ Connection error: ' + error.message);
+    return false;
+  }
+}
+
+// Display full configuration
+
+export async function fullConfigViewer() {
+  try {
+    const response = await fetch('/config');
+    const config = await response.json();
+
+    const configWindow = window.open('', 'Configuration', 'width=700,height=500');
+    configWindow.document.write(`
+      <!DOCTYPE html>
+      <html>
+      <head>
+        <title>Current Configuration</title>
+        <style>
+          body { 
+            font-family: 'Courier New', monospace; 
+            padding: 20px; 
+            background: #f5f5f5; 
+          }
+          pre { 
+            background: white; 
+            padding: 20px; 
+            border-radius: 8px; 
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            overflow: auto;
+          }
+          h1 { color: #333; }
+        </style>
+      </head>
+      <body>
+        <h1>Current Configuration</h1>
+        <pre>${JSON.stringify(config, null, 2)}</pre>
+      </body>
+      </html>
+    `);
+  } catch (error) {
+    showMessage('config-issue', 'error', '❌ Error loading configuration: ' + error.message);
+  }
+}
+
+// Clear all fields
+
+export async function clearFields() {
+  if (!confirm('⚠️ Are you sure you want to clear the current configuration (config.yaml)?')) {
+    return;
+  }
+
+  showMessage('config-issue', 'processing', '⏳ Clearing configuration...');
+
+  try {
+    const response = await fetch('/config/clear', {
+      method: 'POST'
+    });
+
+    const data = await response.json();
+
+    if (data.success) {
+      showMessage('config-issue', 'success', '✅ ' + data.message);
+      setTimeout(() => location.reload(true), 1000);
+    } else {
+      showMessage('config-issue', 'error', '❌ ' + data.error);
+    }
+  } catch (error) {
+    showMessage('config-issue', 'error', '❌ Error: ' + error.message);
+  }
+}
+
+// Load default configuration
+
+export async function loadDefaultConfig() {
+  if (!confirm('⚠️ Load default configuration? This will replace config.yaml with config.default.yaml')) {
+    return;
+  }
+
+  showMessage('config-issue', 'processing', '⏳ Loading config.default.yaml...');
+
+  try {
+    const response = await fetch('/config/reset', {
+      method: 'POST'
+    });
+
+    const data = await response.json();
+
+    if (data.success) {
+      showMessage('config-issue', 'success', '✅ ' + data.message);
+      setTimeout(() => location.reload(true), 1000);
+    } else {
+      showMessage('config-issue', 'error', '❌ ' + data.error);
+    }
+  } catch (error) {
+    showMessage('config-issue', 'error', '❌ Error: ' + error.message);
+  }
+}
+
+// Loads an arbitrary config file (picked via the file browser) into
+// config.yaml - same idea as loadDefaultConfig() above, but sourced from
+// a user-chosen .yaml file instead of config.default.yaml.
+
+export function loadExistingConfig() {
+  openBrowser((path) => applyExistingConfig(path), 'file', '.yaml');
+}
+
+export async function applyExistingConfig(path) {
+  if (!confirm(`⚠️ Load "${path}"? This will replace config.yaml with this file.`)) {
+    return;
+  }
+
+  showMessage('config-issue', 'processing', '⏳ Loading ' + path + '...');
+
+  try {
+    const response = await fetch('/config/load_existing', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ path })
+    });
+
+    const data = await response.json();
+
+    if (data.success) {
+      showMessage('config-issue', 'success', '✅ ' + data.message);
+      setTimeout(() => location.reload(true), 1000);
+    } else {
+      showMessage('config-issue', 'error', '❌ ' + data.error);
+    }
+  } catch (error) {
+    showMessage('config-issue', 'error', '❌ Error: ' + error.message);
+  }
+}
+
+// Processing
+
+// Start processing