citrascope 0.6.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

citrascope/web/static/app.js

@@ -1,6 +1,6 @@
 // CitraScope Dashboard - Main Application
 import { connectWebSocket } from './websocket.js';
-import { initConfig, currentConfig, initFilterConfig, setupAutofocusButton } from './config.js';
+import { initConfig, currentConfig, initFilterConfig, setupAutofocusButton, createToast } from './config.js';
 import { getTasks, getLogs } from './api.js';
 
 function updateAppUrlLinks() {
@@ -279,26 +279,53 @@ function initNavigation() {
             }
         }
 
-        nav.addEventListener('click', function(e) {
-            const link = e.target.closest('a[data-section]');
+        function navigateToSection(section) {
+            const link = nav.querySelector(`a[data-section="${section}"]`);
             if (link) {
-                e.preventDefault();
-                const section = link.getAttribute('data-section');
                 activateNav(link);
                 showSection(section);
+                window.location.hash = section;
 
                 // Reload filter config when config section is shown
                 if (section === 'config') {
                     initFilterConfig();
                 }
             }
+        }
+
+        nav.addEventListener('click', function(e) {
+            const link = e.target.closest('a[data-section]');
+            if (link) {
+                e.preventDefault();
+                const section = link.getAttribute('data-section');
+                navigateToSection(section);
+            }
+        });
+
+        // Handle hash changes (back/forward navigation)
+        window.addEventListener('hashchange', function() {
+            const hash = window.location.hash.substring(1);
+            if (hash && sections[hash]) {
+                const link = nav.querySelector(`a[data-section="${hash}"]`);
+                if (link) {
+                    activateNav(link);
+                    showSection(hash);
+                    if (hash === 'config') {
+                        initFilterConfig();
+                    }
+                }
+            }
         });
 
-        // Default to first nav item
-        const first = nav.querySelector('a[data-section]');
-        if (first) {
-            activateNav(first);
-            showSection(first.getAttribute('data-section'));
+        // Initialize from hash or default to first nav item
+        const hash = window.location.hash.substring(1);
+        if (hash && sections[hash]) {
+            navigateToSection(hash);
+        } else {
+            const first = nav.querySelector('a[data-section]');
+            if (first) {
+                navigateToSection(first.getAttribute('data-section'));
+            }
         }
     }
 }
@@ -335,15 +362,91 @@ function updateWSStatus(connected, reconnectInfo = '') {
     }
 }
 
+// --- Camera Control ---
+window.showCameraControl = function() {
+    const modal = new bootstrap.Modal(document.getElementById('cameraControlModal'));
+
+    // Populate images directory link from config
+    const imagesDirLink = document.getElementById('imagesDirLink');
+    if (imagesDirLink && currentConfig.images_dir_path) {
+        imagesDirLink.textContent = currentConfig.images_dir_path;
+        imagesDirLink.href = `file://${currentConfig.images_dir_path}`;
+    }
+
+    // Clear previous capture result
+    document.getElementById('captureResult').style.display = 'none';
+
+    modal.show();
+};
+
+window.captureImage = async function() {
+    const captureButton = document.getElementById('captureButton');
+    const buttonText = document.getElementById('captureButtonText');
+    const spinner = document.getElementById('captureButtonSpinner');
+    const exposureDuration = parseFloat(document.getElementById('exposureDuration').value);
+
+    // Validate exposure duration
+    if (isNaN(exposureDuration) || exposureDuration <= 0) {
+        createToast('Invalid exposure duration', 'danger', false);
+        return;
+    }
+
+    // Show loading state
+    captureButton.disabled = true;
+    spinner.style.display = 'inline-block';
+    buttonText.textContent = 'Capturing...';
+
+    try {
+        const response = await fetch('/api/camera/capture', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ duration: exposureDuration })
+        });
+
+        const data = await response.json();
+
+        if (response.ok && data.success) {
+            // Show capture result
+            document.getElementById('captureFilename').textContent = data.filename;
+            document.getElementById('captureFormat').textContent = data.format || 'Unknown';
+            document.getElementById('captureResult').style.display = 'block';
+
+            createToast('Image captured successfully', 'success', true);
+        } else {
+            const errorMsg = data.error || 'Failed to capture image';
+            createToast(errorMsg, 'danger', false);
+        }
+    } catch (error) {
+        console.error('Capture error:', error);
+        createToast('Failed to capture image: ' + error.message, 'danger', false);
+    } finally {
+        // Reset button state
+        captureButton.disabled = false;
+        spinner.style.display = 'none';
+        buttonText.textContent = 'Capture';
+    }
+};
+
 // --- Status Updates ---
 function updateStatus(status) {
     document.getElementById('hardwareAdapter').textContent = status.hardware_adapter || '-';
     document.getElementById('telescopeConnected').innerHTML = status.telescope_connected
         ? '<span class="badge rounded-pill bg-success">Connected</span>'
         : '<span class="badge rounded-pill bg-danger">Disconnected</span>';
-    document.getElementById('cameraConnected').innerHTML = status.camera_connected
-        ? '<span class="badge rounded-pill bg-success">Connected</span>'
-        : '<span class="badge rounded-pill bg-danger">Disconnected</span>';
+    // Update camera status with control button when connected
+    const cameraEl = document.getElementById('cameraConnected');
+    if (status.camera_connected) {
+        cameraEl.innerHTML = `
+            <span class="badge rounded-pill bg-success">Connected</span>
+            <button class="btn btn-sm btn-outline-light" onclick="showCameraControl()">
+                <i class="bi bi-camera"></i> Control
+            </button>
+        `;
+    } else {
+        cameraEl.innerHTML = '<span class="badge rounded-pill bg-danger">Disconnected</span>';
+    }
 
     // Update current task display
     if (status.current_task && status.current_task !== 'None') {
@@ -363,11 +466,9 @@ function updateStatus(status) {
         document.getElementById('tasksPending').textContent = status.tasks_pending || '0';
     }
 
-    if (status.telescope_ra !== null) {
-        document.getElementById('telescopeRA').textContent = status.telescope_ra.toFixed(4) + '°';
-    }
-    if (status.telescope_dec !== null) {
-        document.getElementById('telescopeDEC').textContent = status.telescope_dec.toFixed(4) + '°';
+    if (status.telescope_ra !== null && status.telescope_dec !== null) {
+        document.getElementById('telescopeCoords').textContent =
+            status.telescope_ra.toFixed(3) + '° / ' + status.telescope_dec.toFixed(3) + '°';
     }
 
     // Update ground station information
@@ -393,23 +494,225 @@ function updateStatus(status) {
     if (status.processing_active !== undefined) {
         updateProcessingState(status.processing_active);
     }
+
+    // Update automated scheduling state
+    if (status.automated_scheduling !== undefined) {
+        updateAutomatedSchedulingState(status.automated_scheduling);
+    }
+
+    // Update autofocus status
+    updateAutofocusStatus(status);
+
+    // Update time sync status
+    updateTimeSyncStatus(status);
+
+    // Update missing dependencies display
+    updateMissingDependencies(status.missing_dependencies || []);
+}
+
+function updateMissingDependencies(missingDeps) {
+    const dashboardContainer = document.getElementById('missingDependenciesAlert');
+    const configContainer = document.getElementById('configMissingDependenciesAlert');
+
+    const containers = [dashboardContainer, configContainer].filter(c => c);
+
+    if (missingDeps.length === 0) {
+        containers.forEach(container => container.style.display = 'none');
+        return;
+    }
+
+    let html = '<strong><i class="bi bi-exclamation-triangle-fill me-2"></i>Missing Dependencies:</strong><ul class="mb-0 mt-2">';
+    missingDeps.forEach(dep => {
+        html += `<li><strong>${dep.device_name}</strong>: Missing ${dep.missing_packages}<br>`;
+        html += `<code class="small">${dep.install_cmd}</code></li>`;
+    });
+    html += '</ul>';
+
+    containers.forEach(container => {
+        container.innerHTML = html;
+        container.style.display = 'block';
+    });
+}
+
+function updateAutofocusStatus(status) {
+    // Update autofocus button state
+    const button = document.getElementById('runAutofocusButton');
+    const buttonText = document.getElementById('autofocusButtonText');
+
+    if (button && buttonText && status.autofocus_requested !== undefined) {
+        if (status.autofocus_requested) {
+            buttonText.textContent = 'Cancel Autofocus';
+            button.dataset.action = 'cancel';
+            button.classList.remove('btn-outline-primary');
+            button.classList.add('btn-outline-warning');
+        } else {
+            buttonText.textContent = 'Run Autofocus';
+            button.dataset.action = 'request';
+            button.classList.remove('btn-outline-warning');
+            button.classList.add('btn-outline-primary');
+        }
+    }
+
+    // Update last autofocus display
+    const lastAutofocusDisplay = document.getElementById('lastAutofocusDisplay');
+    if (lastAutofocusDisplay) {
+        if (status.last_autofocus_timestamp) {
+            const timestamp = status.last_autofocus_timestamp * 1000; // Convert to milliseconds
+            const now = Date.now();
+            const elapsed = now - timestamp;
+            lastAutofocusDisplay.textContent = formatElapsedTime(elapsed);
+        } else {
+            lastAutofocusDisplay.textContent = 'Never';
+        }
+    }
+
+    // Update next autofocus display
+    const nextAutofocusDisplay = document.getElementById('nextAutofocusDisplay');
+    const nextAutofocusTime = document.getElementById('nextAutofocusTime');
+
+    if (nextAutofocusDisplay && nextAutofocusTime) {
+        if (status.next_autofocus_minutes !== null && status.next_autofocus_minutes !== undefined) {
+            nextAutofocusDisplay.style.display = 'block';
+            if (status.next_autofocus_minutes === 0) {
+                nextAutofocusTime.textContent = 'now (overdue)';
+            } else {
+                nextAutofocusTime.textContent = formatMinutes(status.next_autofocus_minutes);
+            }
+        } else {
+            nextAutofocusDisplay.style.display = 'none';
+        }
+    }
+}
+
+function updateTimeSyncStatus(status) {
+    const statusEl = document.getElementById('timeSyncStatus');
+    const offsetEl = document.getElementById('timeOffsetDisplay');
+
+    if (!statusEl || !offsetEl) {
+        return;
+    }
+
+    const timeHealth = status.time_health;
+
+    // Handle missing health data
+    if (!timeHealth) {
+        statusEl.innerHTML = '<span class="badge rounded-pill bg-secondary" data-bs-toggle="tooltip" title="Time sync status unknown">Unknown</span>';
+        offsetEl.textContent = '-';
+        return;
+    }
+
+    // Determine badge color based on status
+    let badgeClass = 'bg-secondary';
+    let badgeText = 'Unknown';
+    let tooltipText = 'Time sync status unknown';
+
+    switch (timeHealth.status) {
+        case 'ok':
+            badgeClass = 'bg-success';
+            badgeText = 'OK';
+            tooltipText = 'Time sync within threshold';
+            break;
+        case 'critical':
+            badgeClass = 'bg-danger';
+            badgeText = 'Paused';
+            tooltipText = 'Time drift exceeded threshold - tasks paused';
+            break;
+        case 'unknown':
+        default:
+            badgeClass = 'bg-secondary';
+            badgeText = 'Unknown';
+            tooltipText = 'Unable to check time sync';
+            break;
+    }
+
+    statusEl.innerHTML = `<span class="badge rounded-pill ${badgeClass}" data-bs-toggle="tooltip" title="${tooltipText}">${badgeText}</span>`;
+
+    // Format offset display
+    if (timeHealth.offset_ms !== null && timeHealth.offset_ms !== undefined) {
+        const offset = timeHealth.offset_ms;
+        const absOffset = Math.abs(offset);
+        const sign = offset >= 0 ? '+' : '-';
+
+        if (absOffset < 1) {
+            offsetEl.textContent = `${sign}${absOffset.toFixed(2)}ms`;
+        } else if (absOffset < 1000) {
+            offsetEl.textContent = `${sign}${absOffset.toFixed(0)}ms`;
+        } else {
+            offsetEl.textContent = `${sign}${(absOffset / 1000).toFixed(2)}s`;
+        }
+
+        // Add source indicator
+        if (timeHealth.source && timeHealth.source !== 'unknown') {
+            offsetEl.textContent += ` (${timeHealth.source})`;
+        }
+    } else {
+        offsetEl.textContent = '-';
+    }
+
+    // Reinitialize tooltips
+    const tooltipTriggerList = [].slice.call(document.querySelectorAll('[data-bs-toggle="tooltip"]'));
+    tooltipTriggerList.map(function (tooltipTriggerEl) {
+        return new bootstrap.Tooltip(tooltipTriggerEl);
+    });
+}
+
+function formatElapsedTime(milliseconds) {
+    const seconds = Math.floor(milliseconds / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+
+    if (days > 0) {
+        return `${days} day${days !== 1 ? 's' : ''} ago`;
+    } else if (hours > 0) {
+        return `${hours} hour${hours !== 1 ? 's' : ''} ago`;
+    } else if (minutes > 0) {
+        return `${minutes} minute${minutes !== 1 ? 's' : ''} ago`;
+    } else {
+        return 'just now';
+    }
+}
+
+function formatMinutes(minutes) {
+    const hours = Math.floor(minutes / 60);
+    const mins = Math.floor(minutes % 60);
+
+    if (hours > 0) {
+        if (mins > 0) {
+            return `${hours}h ${mins}m`;
+        }
+        return `${hours}h`;
+    }
+    return `${mins}m`;
 }
 
 function updateProcessingState(isActive) {
     const statusEl = document.getElementById('processingStatus');
-    const button = document.getElementById('toggleProcessingButton');
-    const icon = document.getElementById('processingButtonIcon');
+    const switchEl = document.getElementById('toggleProcessingSwitch');
 
-    if (!statusEl || !button || !icon) return;
+    if (!statusEl || !switchEl) return;
 
     if (isActive) {
-        statusEl.innerHTML = '<span class="badge rounded-pill bg-success">Active</span>';
-        icon.textContent = 'Pause';
-        button.title = 'Pause task processing';
+        statusEl.innerHTML = '<span class="badge rounded-pill bg-success">Enabled</span>';
+        switchEl.checked = true;
     } else {
-        statusEl.innerHTML = '<span class="badge rounded-pill bg-warning text-dark">Paused</span>';
-        icon.textContent = 'Resume';
-        button.title = 'Resume task processing';
+        statusEl.innerHTML = '<span class="badge rounded-pill bg-secondary">Disabled</span>';
+        switchEl.checked = false;
+    }
+}
+
+function updateAutomatedSchedulingState(isEnabled) {
+    const statusEl = document.getElementById('automatedSchedulingStatus');
+    const switchEl = document.getElementById('toggleAutomatedSchedulingSwitch');
+
+    if (!statusEl || !switchEl) return;
+
+    if (isEnabled) {
+        statusEl.innerHTML = '<span class="badge rounded-pill bg-success">Enabled</span>';
+        switchEl.checked = true;
+    } else {
+        statusEl.innerHTML = '<span class="badge rounded-pill bg-secondary">Disabled</span>';
+        switchEl.checked = false;
     }
 }
 
@@ -704,16 +1007,19 @@ document.addEventListener('DOMContentLoaded', async function() {
     loadTasks();
     loadLogs();
 
-    // Add pause/resume button handler
-    const toggleButton = document.getElementById('toggleProcessingButton');
-    if (toggleButton) {
-        toggleButton.addEventListener('click', async () => {
-            const icon = document.getElementById('processingButtonIcon');
-            const currentlyPaused = icon && icon.textContent === 'Resume';
-            const endpoint = currentlyPaused ? '/api/tasks/resume' : '/api/tasks/pause';
+    // Initialize Bootstrap tooltips
+    const tooltipTriggerList = document.querySelectorAll('[data-bs-toggle="tooltip"]');
+    const tooltipList = [...tooltipTriggerList].map(tooltipTriggerEl => new bootstrap.Tooltip(tooltipTriggerEl));
+
+    // Add pause/resume switch handler
+    const toggleSwitch = document.getElementById('toggleProcessingSwitch');
+    if (toggleSwitch) {
+        toggleSwitch.addEventListener('change', async (e) => {
+            const isChecked = e.target.checked;
+            const endpoint = isChecked ? '/api/tasks/resume' : '/api/tasks/pause';
 
             try {
-                toggleButton.disabled = true;
+                toggleSwitch.disabled = true;
                 const response = await fetch(endpoint, { method: 'POST' });
                 const result = await response.json();
 
@@ -722,13 +1028,50 @@ document.addEventListener('DOMContentLoaded', async function() {
                     // Show specific error message (e.g., "Cannot resume during autofocus")
                     alert((result.error || 'Failed to toggle task processing') +
                           (response.status === 409 ? '' : ' - Unknown error'));
+                    // Revert switch state on error
+                    toggleSwitch.checked = !isChecked;
                 }
                 // State will be updated via WebSocket broadcast within 2 seconds
             } catch (error) {
                 console.error('Error toggling processing:', error);
                 alert('Error toggling task processing');
+                // Revert switch state on error
+                toggleSwitch.checked = !isChecked;
+            } finally {
+                toggleSwitch.disabled = false;
+            }
+        });
+    }
+
+    // Add automated scheduling switch handler
+    const automatedSchedulingSwitch = document.getElementById('toggleAutomatedSchedulingSwitch');
+    if (automatedSchedulingSwitch) {
+        automatedSchedulingSwitch.addEventListener('change', async (e) => {
+            const isChecked = e.target.checked;
+
+            try {
+                automatedSchedulingSwitch.disabled = true;
+                const response = await fetch('/api/telescope/automated-scheduling', {
+                    method: 'PATCH',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ enabled: isChecked })
+                });
+                const result = await response.json();
+
+                if (!response.ok) {
+                    console.error('Failed to toggle automated scheduling:', result);
+                    alert(result.error || 'Failed to toggle automated scheduling');
+                    // Revert switch state on error
+                    automatedSchedulingSwitch.checked = !isChecked;
+                }
+                // State will be updated via WebSocket broadcast
+            } catch (error) {
+                console.error('Error toggling automated scheduling:', error);
+                alert('Error toggling automated scheduling');
+                // Revert switch state on error
+                automatedSchedulingSwitch.checked = !isChecked;
             } finally {
-                toggleButton.disabled = false;
+                automatedSchedulingSwitch.disabled = false;
             }
         });
     }