+
+
+
+
+
+
![weiss_ORIGINAL]()
+```
+
+## Impact on WebDrop Bridge
+
+### ❌ Bisheriger Ansatz funktioniert NICHT
+
+Unser aktueller Ansatz basiert auf:
+1. Interception von nativen Drag-Events
+2. Manipulation von `event.dataTransfer.effectAllowed` und `.dropEffect`
+3. Setzen von URLs im DataTransfer
+
+**Das funktioniert NICHT mit Angular CDK**, da:
+- Angular CDK das native Drag & Drop komplett umgeht
+- Keine nativen Events gefeuert werden
+- DataTransfer API nicht verwendet wird
+
+### ✅ Mögliche Lösungsansätze
+
+#### Ansatz 1: JavaScript Injection zur Laufzeit
+Injiziere JavaScript-Code, der Angular CDK Events abfängt:
+
+```javascript
+// Überwache Angular CDK Event-Handler
+document.addEventListener('cdkDragStarted', (event) => {
+ const assetId = event.source.element.nativeElement.id;
+ const assetName = event.source.element.nativeElement.querySelector('img')?.alt;
+
+ // Sende an Qt WebChannel
+ bridge.handleDragStart(assetId, assetName);
+});
+
+document.addEventListener('cdkDragDropped', (event) => {
+ // Verhindere das Standard-Verhalten
+ event.preventDefault();
+
+ // Starte nativen Drag von Qt aus
+ bridge.initNativeDrag();
+});
+```
+
+**Vorteile:**
+- ✅ Direkter Zugriff auf Angular CDK Events
+- ✅ Kann Asset-Informationen extrahieren
+- ✅ Kann Drag-Operationen abfangen
+
+**Nachteile:**
+- ⚠️ Erfordert genaue Kenntnis der Angular CDK Internals
+- ⚠️ Könnte bei Angular CDK Updates brechen
+- ⚠️ Komplexer zu implementieren
+
+#### Ansatz 2: DOM Mutation Observer
+Überwache DOM-Änderungen während des Drags:
+
+```javascript
+const observer = new MutationObserver((mutations) => {
+ mutations.forEach((mutation) => {
+ // Suche nach CDK Drag-Elementen mit bestimmten Klassen
+ const dragElement = document.querySelector('.cdk-drag-preview');
+ if (dragElement) {
+ const assetId = dragElement.querySelector('[id^="a"]')?.id;
+ bridge.handleDrag(assetId);
+ }
+ });
+});
+
+observer.observe(document.body, {
+ childList: true,
+ subtree: true,
+ attributes: true,
+ attributeFilter: ['class']
+});
+```
+
+**Vorteile:**
+- ✅ Robuster gegenüber Framework-Updates
+- ✅ Funktioniert mit beliebigen Frameworks
+
+**Nachteile:**
+- ⚠️ Performance-Overhead
+- ⚠️ Kann falsche Positive erzeugen
+
+#### Ansatz 3: Qt WebChannel Bridge mit Custom Events
+Nutze Qt WebChannel, um mit der Angular-Anwendung zu kommunizieren:
+
+```python
+# Python-Seite (Qt)
+class DragBridge(QObject):
+ @Slot(str, str)
+ def onAssetDragStart(self, asset_id: str, asset_name: str):
+ """Called from JavaScript when Angular CDK drag starts."""
+ logger.info(f"Asset drag started: {asset_id} ({asset_name})")
+ self.convert_and_drag(asset_id, asset_name)
+```
+
+```javascript
+// JavaScript-Seite (injiziert via QWebEngineScript)
+new QWebChannel(qt.webChannelTransport, (channel) => {
+ const dragBridge = channel.objects.dragBridge;
+
+ // Monkey-patch Angular CDK's DragRef
+ const originalStartDraggingSequence = CdkDrag.prototype._startDraggingSequence;
+ CdkDrag.prototype._startDraggingSequence = function(event) {
+ const assetElement = this.element.nativeElement;
+ const assetId = assetElement.id;
+ const assetName = assetElement.querySelector('img')?.alt;
+
+ // Benachrichtige Qt
+ dragBridge.onAssetDragStart(assetId, assetName);
+
+ // Rufe original Angular CDK Methode auf
+ return originalStartDraggingSequence.call(this, event);
+ };
+});
+```
+
+**Vorteile:**
+- ✅ Saubere Kommunikation zwischen Qt und Web
+- ✅ Kann Asset-Informationen zuverlässig extrahieren
+- ✅ Typensicher (Qt Signals/Slots)
+
+**Nachteile:**
+- ⚠️ Erfordert Monkey-Patching von Angular CDK
+- ⚠️ Kann bei CDK Updates brechen
+
+#### Ansatz 4: Browser DevTools Protocol (Chrome DevTools)
+Nutze Chrome DevTools Protocol für tiefere Integration:
+
+```python
+from PySide6.QtWebEngineCore import QWebEngineProfile
+
+profile = QWebEngineProfile.defaultProfile()
+profile.setRequestInterceptor(...)
+
+# Intercepte Netzwerk-Requests und injiziere Header
+# Überwache JavaScript-Execution via CDP
+```
+
+**Vorteile:**
+- ✅ Sehr mächtig, kann JavaScript-Execution überwachen
+- ✅ Kann Events auf niedrigerer Ebene abfangen
+
+**Nachteile:**
+- ⚠️ Sehr komplex
+- ⚠️ Erfordert Chrome DevTools Protocol Kenntnisse
+- ⚠️ Performance-Overhead
+
+## Empfohlener Ansatz
+
+### **Ansatz 3: Qt WebChannel Bridge** (BEVORZUGT)
+
+**Begründung:**
+1. ✅ Saubere Architektur mit klarer Trennung
+2. ✅ Typsicher durch Qt Signals/Slots
+3. ✅ Kann Asset-IDs und -Namen zuverlässig extrahieren
+4. ✅ Funktioniert auch wenn Angular CDK interne Änderungen hat
+5. ✅ Ermöglicht bidirektionale Kommunikation
+
+**Implementierungsschritte:**
+
+### Phase 1: Asset-Informationen extrahieren
+1. JavaScript via QWebEngineScript injizieren
+2. Qt WebChannel setuppen
+3. Angular CDK Events überwachen (ohne Monkey-Patching als Test)
+4. Asset-IDs und Namen an Qt senden
+
+### Phase 2: Native Drag initiieren
+1. Bei CDK Drag-Start: Extrahiere Asset-Informationen
+2. Sende Asset-ID an Backend/API
+3. Erhalte lokalen Dateipfad oder Azure Blob URL
+4. Konvertiere zu lokalem Pfad (wie aktuell)
+5. Initiiere nativen Drag mit QDrag
+
+### Phase 3: Drag-Feedback
+1. Zeige Drag-Preview in Qt (optional)
+2. Update Cursor während Drag
+3. Cleanup nach Drag-Ende
+
+## Asset-ID zu Dateipfad Mapping
+
+Die Anwendung verwendet Asset-IDs in mehreren Formaten:
+
+```javascript
+// Asset-ID: anPGZszKzgKaSz1SIx2HFgduy
+
+// Mögliche URL-Konstruktion:
+const assetUrl = `https://dev.agravity.io/api/assets/${assetId}`;
+const downloadUrl = `https://dev.agravity.io/api/assets/${assetId}/download`;
+const blobUrl = `https://static.agravity.io/${workspaceId}/${assetId}/${filename}`;
+```
+
+**Für WebDrop Bridge:**
+- Asset-ID aus DOM extrahieren
+- Asset-Metadaten via API abrufen (falls verfügbar)
+- Blob-URL konstruieren
+- URL Converter nutzen (bereits implementiert!)
+
+## Next Steps
+
+1. **Proof of Concept**: Qt WebChannel mit einfachem Event-Logger
+2. **Asset-ID Extraction**: JavaScript Injection testen
+3. **API Research**: GlobalDAM API untersuchen (Asset-Metadaten)
+4. **Integration**: Mit bestehendem URLConverter verbinden
+5. **Testing**: Mit echten Assets testen
+
+## Hinweise
+
+- Angular CDK Version kann sich unterscheiden - Code muss robust sein
+- Asset-IDs scheinen eindeutig zu sein (Base64-ähnlich)
+- Die Anwendung nutzt Azure Blob Storage (basierend auf bisherigen URLs)
+- Custom Components (`ay-*`) deuten auf eine eigene Component Library hin
diff --git a/docs/DRAG_DROP_PROBLEM_ANALYSIS.md b/docs/DRAG_DROP_PROBLEM_ANALYSIS.md
new file mode 100644
index 0000000..7e6906d
--- /dev/null
+++ b/docs/DRAG_DROP_PROBLEM_ANALYSIS.md
@@ -0,0 +1,277 @@
+# Drag & Drop Problem Analysis - File Drop + Web App Popup
+
+## Das Kernproblem
+
+**Ziel**: Bei ALT-Drag soll:
+1. ✅ File gedroppt werden (Z:\ Laufwerk) → Native File-Drop
+2. ✅ Web-App Popup erscheinen (Auschecken-Dialog) → Web-App Drop-Event
+
+**Problem**: Diese beiden schließen sich gegenseitig aus:
+- Native File-Drag (von Qt) → Web-App bekommt kein Drop-Event → Kein Popup
+- Browser Text-Drag (von Web-App) → Kein File-Drop → Kein File
+
+## Browser-Sicherheitsbeschränkungen
+
+1. **DataTransfer.files ist read-only**
+ Wir können keine Files zu einem DataTransfer hinzufügen
+
+2. **Nur EIN Drag zur Zeit möglich**
+ Wir können keinen parallelen Drag starten
+
+3. **DataTransfer kann nicht erstellt werden**
+ Wir können kein synthetisches Drop-Event mit Files erzeugen
+
+4. **Cross-Domain Sicherheit**
+ File-Zugriff ist stark eingeschränkt
+
+## Getestete Ansätze
+
+### ❌ Ansatz 1: DataTransfer erweitern
+**Idee**: Web-App setzt URL, wir fügen Files hinzu
+**Problem**: DataTransfer.files ist read-only
+
+### ❌ Ansatz 2: Parallele Drags
+**Idee**: Browser-Drag + Qt-Drag gleichzeitig
+**Problem**: Nur ein Drag zur Zeit möglich
+
+### ❌ Ansatz 3: Synthetisches Drop-Event
+**Idee**: Original Drop abfangen, neues Event mit Files erzeugen
+**Problem**: DataTransfer.files kann nicht gesetzt werden
+
+### ⚠️ Ansatz 4: Native Drag + Event-Simulation
+**Idee**: Qt Native Drag, dann Web-App Event manuell auslösen
+**Problem**: Erfordert Kenntnis der exakten Web-App Event-Struktur (Angular CDK)
+
+## 🎯 Praktikable Lösungen
+
+### Lösung A: **Zwei-Phasen Ansatz** (EMPFOHLEN für Testing)
+
+**Phase 1: File-Drop**
+1. ALT-Drag startet
+2. JavaScript erkennt convertible URL
+3. Ruft Qt's `start_file_drag(url)` auf
+4. `preventDefault()` verhindert Browser-Drag
+5. Qt Native Drag läuft
+6. File wird gedroppt ✅
+
+**Phase 2: Popup manuell triggern**
+7. Nach erfolgreichem Drop (via Qt Signal)
+8. JavaScript simuliert den Event/API-Call der das Popup auslöst
+9. Popup erscheint ✅
+
+**Vorteile:**
+- ✅ Funktioniert garantiert für File-Drop
+- ✅ Kontrolle über beide Phasen
+- ✅ Kann debugged werden
+
+**Nachteile:**
+- ⚠️ Erfordert Reverse-Engineering des Popup-Triggers
+- ⚠️ Könnte bei Web-App Updates brechen
+
+**Implementierung:**
+```javascript
+// Phase 1: Standard - File Drag
+document.addEventListener('dragstart', function(e) {
+ if (!e.altKey) return;
+
+ // Extract URL from DataTransfer
+ var url = e.dataTransfer.getData('text/plain');
+ if (isConvertible(url)) {
+ e.preventDefault();
+ window.bridge.start_file_drag(url);
+ }
+}, true);
+
+// Phase 2: Popup Trigger (nach Drop-Erfolg)
+// Qt ruft auf: window.trigger_checkout_popup(assetId)
+window.trigger_checkout_popup = function(assetId) {
+ // Option 1: Klick auf Checkout-Button simulieren
+ // Option 2: API-Call direkt aufrufen
+ // Option 3: Angular-Event dispatchen
+
+ // Beispiel: Suche nach Angular-Component und rufe Methode auf
+ var angularComponent = findAngularComponent('ay-asset-card');
+ if (angularComponent) {
+ angularComponent.onCheckout(assetId);
+ }
+};
+```
+
+**TODO für diese Lösung:**
+1. ✅ File-Drag funktioniert bereits
+2. ⏸️ Herausfinden wie Popup ausgelöst wird:
+ - Browser DevTools öffnen
+ - Network-Tab beobachten (API-Call?)
+ - Elements-Tab nutzen (Angular Component?)
+ - Event-Listeners ansehen
+
+### Lösung B: **Gar nichts ändern beim Drag** (FALLBACK)
+
+**Ansatz:**
+1. ALT-Drag läuft normal durch (URL-Text wird gedroppt)
+2. Popup erscheint ✅
+3. Nach Popup-Bestätigung (Auschecken)
+4. **DANN** konvertieren wir die URL und kopieren das File
+
+**Vorteile:**
+- ✅ Web-App funktioniert normal
+- ✅ Kein Popup-Problem
+- ✅ Einfach zu implementieren
+
+**Nachteile:**
+- ⚠️ Kein echter Drag & Drop (nur Copy)
+- ⚠️ User muss zweimal handeln
+
+### Lösung C: **File-Drop via Qt Window Overlay** (EXPERIMENTELL)
+
+**Ansatz:**
+1. Beim ALT-Drag: Start Normal Web-App Drag
+2. Qt erstellt ein transparentes Overlay-Window über dem Browser
+3. Overlay fängt das Drop-Event ab
+4. Qt macht File-Drop
+5. Qt leitet Drop-Koordinaten an Browser weiter
+6. Browser bekommt synthetisches Event (ohne Files, nur Koordinaten)
+7. Popup erscheint
+
+**Vorteile:**
+- ✅ Beide Funktionen potentiell möglich
+- ✅ Keine DataTransfer-Manipulation nötig
+
+**Nachteile:**
+- ⚠️ Sehr komplex
+- ⚠️ Plattform-spezifisch (Windows)
+- ⚠️ Performance-Overhead
+
+## 🔬 Nächste Schritte - Reverse Engineering
+
+Um Lösung A zu implementieren, müssen wir herausfinden:
+
+### 1. Wie wird das Popup ausgelöst?
+
+**Debug-Schritte:**
+```javascript
+// In Browser Console ausführen während ALT-Drag+Drop
+
+// Methode 1: Event-Listener finden
+getEventListeners(document)
+
+// Methode 2: Angular Component finden
+var cards = document.querySelectorAll('ay-asset-card');
+var component = ng.getComponent(cards[0]); // Angular DevTools
+console.log(component);
+
+// Methode 3: Network-Tab
+// Schauen ob API-Call gemacht wird nach Drop
+```
+
+**Erwartete Möglichkeiten:**
+- API-Call zu `/api/assets/{id}/checkout`
+- Angular Event: `cdkDropListDropped`
+- Component-Methode: `onAssetDropped()` oder ähnlich
+- Modal-Service: `ModalService.show('checkout-dialog')`
+
+### 2. Asset-ID extrahieren
+
+Die Asset-ID wird benötigt für den Popup-Trigger:
+
+```javascript
+// Asset-ID ist wahrscheinlich in:
+// - Element-ID: "anPGZszKzgKaSz1SIx2HFgduy"
+// - Image-URL: "./GlobalDAM JRI_files/anPGZszKzgKaSz1SIx2HFgduy"
+// - Data-Attribut: data-asset-id
+
+function extractAssetId(element) {
+ // Aus Element-ID
+ if (element.id && element.id.match(/^a[A-Za-z0-9_-]+$/)) {
+ return element.id;
+ }
+
+ // Aus Bild-URL
+ var img = element.querySelector('img');
+ if (img && img.src) {
+ var match = img.src.match(/([A-Za-z0-9_-]{20,})/);
+ if (match) return match[1];
+ }
+
+ return null;
+}
+```
+
+### 3. Popup programmatisch öffnen
+
+Sobald wir wissen wie, implementieren wir:
+
+```python
+# Python (Qt)
+class DragBridge(QObject):
+ @Slot(str)
+ def on_file_dropped_success(self, local_path: str):
+ """Called after successful file drop."""
+ # Extrahiere Asset-ID aus Pfad oder URL-Mapping
+ asset_id = self.extract_asset_id(local_path)
+
+ # Trigger Popup via JavaScript
+ js_code = f"window.trigger_checkout_popup('{asset_id}')"
+ self.web_view.page().runJavaScript(js_code)
+```
+
+## ⚡ Quick Win: Debugging aktivieren
+
+Fügen Sie zu **allen** JavaScript-Varianten umfangreiches Logging hinzu:
+
+```javascript
+// In bridge_script.js
+
+// Log ALLE Events
+['dragstart', 'drag', 'dragenter', 'dragover', 'drop', 'dragend'].forEach(function(eventName) {
+ document.addEventListener(eventName, function(e) {
+ console.log('[DEBUG]', eventName, {
+ target: e.target.tagName,
+ dataTransfer: {
+ types: e.dataTransfer.types,
+ effectAllowed: e.dataTransfer.effectAllowed,
+ dropEffect: e.dataTransfer.dropEffect
+ },
+ altKey: e.altKey,
+ coordinates: {x: e.clientX, y: e.clientY}
+ });
+ }, true);
+});
+
+// Log DataTransfer Zugriffe
+Object.defineProperty(DataTransfer.prototype, 'types', {
+ get: function() {
+ var types = this._types || [];
+ console.log('[DEBUG] DataTransfer.types accessed:', types);
+ return types;
+ }
+});
+```
+
+## 📝 Empfehlung
+
+**Sofortige Maßnahmen:**
+
+1. ✅ **Lösung A Phase 1 ist bereits implementiert** (File-Drop funktioniert)
+
+2. 🔍 **Reverse-Engineering durchführen:**
+ - GlobalDAM JRI im Browser öffnen
+ - DevTools öffnen (F12)
+ - ALT-Drag+Drop durchführen
+ - Beobachten:
+ - Network-Tab → API-Calls?
+ - Console → Fehler/Logs?
+ - Angular DevTools → Component-Events?
+
+3. 🛠️ **Popup-Trigger implementieren:**
+ - Sobald bekannt WIE Popup ausgelöst wird
+ - JavaScript-Funktion `trigger_checkout_popup()` erstellen
+ - Von Qt aus nach erfolgreichem Drop aufrufen
+
+4. 🧪 **Testen:**
+ - ALT-Drag eines Assets
+ - File-Drop sollte funktionieren
+ - Popup sollte erscheinen
+
+**Fallback:**
+Falls Reverse-Engineering zu komplex ist → **Lösung B** verwenden (Kein Drag, nur Copy nach Popup-Bestätigung)
diff --git a/full_test.txt b/full_test.txt
deleted file mode 100644
index f29edc9..0000000
Binary files a/full_test.txt and /dev/null differ
diff --git a/pyproject.toml b/pyproject.toml
index 06a2c7e..2d99927 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -13,7 +13,7 @@ readme = "README.md"
requires-python = ">=3.9"
license = {text = "MIT"}
authors = [
- {name = "WebDrop Team", email = "dev@webdrop.local"}
+ {name = "Claudius Hansch", email = "claudius.hansch@hoerl-im.de"}
]
keywords = ["qt", "pyside6", "drag-drop", "desktop", "automation"]
classifiers = [
@@ -63,10 +63,10 @@ docs = [
]
[project.urls]
-Homepage = "https://github.com/yourusername/webdrop-bridge"
+Homepage = "https://git.him-tools.de/HIM-public/webdrop-bridge"
Documentation = "https://webdrop-bridge.readthedocs.io"
-Repository = "https://github.com/yourusername/webdrop-bridge.git"
-"Bug Tracker" = "https://github.com/yourusername/webdrop-bridge/issues"
+Repository = "https://git.him-tools.de/HIM-public/webdrop-bridge"
+"Bug Tracker" = "https://git.him-tools.de/HIM-public/webdrop-bridge/issues"
[project.scripts]
webdrop-bridge = "webdrop_bridge.main:main"
diff --git a/resources/icons/app.ico b/resources/icons/app.ico
new file mode 100644
index 0000000..1768c67
Binary files /dev/null and b/resources/icons/app.ico differ
diff --git a/resources/icons/app.png b/resources/icons/app.png
new file mode 100644
index 0000000..ca52173
Binary files /dev/null and b/resources/icons/app.png differ
diff --git a/src/webdrop_bridge/__init__.py b/src/webdrop_bridge/__init__.py
index a488cd1..0555873 100644
--- a/src/webdrop_bridge/__init__.py
+++ b/src/webdrop_bridge/__init__.py
@@ -1,6 +1,6 @@
"""WebDrop Bridge - Qt-based desktop application for intelligent drag-and-drop file handling."""
-__version__ = "0.1.0"
+__version__ = "0.5.0"
__author__ = "WebDrop Team"
__license__ = "MIT"
diff --git a/src/webdrop_bridge/config.py b/src/webdrop_bridge/config.py
index ea0c5a6..667bd04 100644
--- a/src/webdrop_bridge/config.py
+++ b/src/webdrop_bridge/config.py
@@ -1,8 +1,9 @@
"""Configuration management for WebDrop Bridge application."""
+import json
import logging
import os
-from dataclasses import dataclass
+from dataclasses import dataclass, field
from pathlib import Path
from typing import List
@@ -17,9 +18,29 @@ class ConfigurationError(Exception):
pass
+@dataclass
+class URLMapping:
+ """Maps an Azure Blob Storage URL prefix to a local drive path."""
+
+ url_prefix: str
+ local_path: str
+
+ def __post_init__(self):
+ """Validate mapping configuration."""
+ if not self.url_prefix.startswith(("http://", "https://")):
+ raise ConfigurationError(
+ f"URL prefix must start with http:// or https://: {self.url_prefix}"
+ )
+ # Ensure URL prefix ends with /
+ if not self.url_prefix.endswith("/"):
+ self.url_prefix += "/"
+ # Normalize local path
+ self.local_path = str(Path(self.local_path))
+
+
@dataclass
class Config:
- """Application configuration loaded from environment variables.
+ """Application configuration loaded from environment variables or JSON file.
Attributes:
app_name: Application display name
@@ -28,7 +49,11 @@ class Config:
log_file: Optional log file path
allowed_roots: List of whitelisted root directories for file access
allowed_urls: List of whitelisted URL domains/patterns (empty = no restriction)
- webapp_url: URL to load in embedded web application
+ webapp_url: URL to load in embedded web application (default: https://wps.agravity.io/)
+ url_mappings: List of Azure URL to local path mappings
+ check_file_exists: Whether to validate that files exist before drag
+ auto_check_updates: Whether to automatically check for updates
+ update_check_interval_hours: Hours between update checks
window_width: Initial window width in pixels
window_height: Initial window height in pixels
window_title: Main window title (default: "{app_name} v{app_version}")
@@ -45,10 +70,85 @@ class Config:
allowed_roots: List[Path]
allowed_urls: List[str]
webapp_url: str
- window_width: int
- window_height: int
- window_title: str
- enable_logging: bool
+ url_mappings: List[URLMapping] = field(default_factory=list)
+ check_file_exists: bool = True
+ auto_check_updates: bool = True
+ update_check_interval_hours: int = 24
+ window_width: int = 1024
+ window_height: int = 768
+ window_title: str = ""
+ enable_logging: bool = True
+
+ @classmethod
+ def from_file(cls, config_path: Path) -> "Config":
+ """Load configuration from JSON file.
+
+ Args:
+ config_path: Path to configuration file
+
+ Returns:
+ Config: Configured instance from JSON file
+
+ Raises:
+ ConfigurationError: If configuration file is invalid
+ """
+ if not config_path.exists():
+ raise ConfigurationError(f"Configuration file not found: {config_path}")
+
+ try:
+ with open(config_path, "r", encoding="utf-8") as f:
+ data = json.load(f)
+ except (json.JSONDecodeError, IOError) as e:
+ raise ConfigurationError(f"Failed to load configuration: {e}") from e
+
+ # Get version from package
+ from webdrop_bridge import __version__
+
+ # Parse URL mappings
+ mappings = [
+ URLMapping(
+ url_prefix=m["url_prefix"],
+ local_path=m["local_path"]
+ )
+ for m in data.get("url_mappings", [])
+ ]
+
+ # Parse allowed roots
+ allowed_roots = [Path(p).resolve() for p in data.get("allowed_roots", [])]
+
+ # Validate allowed roots exist
+ for root in allowed_roots:
+ if not root.exists():
+ logger.warning(f"Allowed root does not exist: {root}")
+ elif not root.is_dir():
+ raise ConfigurationError(f"Allowed root is not a directory: {root}")
+
+ # Get log file path
+ log_file = None
+ if data.get("enable_logging", True):
+ log_file_str = data.get("log_file", "logs/webdrop_bridge.log")
+ log_file = Path(log_file_str).resolve()
+
+ app_name = data.get("app_name", "WebDrop Bridge")
+ window_title = data.get("window_title", f"{app_name} v{__version__}")
+
+ return cls(
+ app_name=app_name,
+ app_version=__version__,
+ log_level=data.get("log_level", "INFO").upper(),
+ log_file=log_file,
+ allowed_roots=allowed_roots,
+ allowed_urls=data.get("allowed_urls", []),
+ webapp_url=data.get("webapp_url", "https://wps.agravity.io/"),
+ url_mappings=mappings,
+ check_file_exists=data.get("check_file_exists", True),
+ auto_check_updates=data.get("auto_check_updates", True),
+ update_check_interval_hours=data.get("update_check_interval_hours", 24),
+ window_width=data.get("window_width", 1024),
+ window_height=data.get("window_height", 768),
+ window_title=window_title,
+ enable_logging=data.get("enable_logging", True),
+ )
@classmethod
def from_env(cls, env_file: str | None = None) -> "Config":
@@ -81,7 +181,7 @@ class Config:
log_file_str = os.getenv("LOG_FILE", "logs/webdrop_bridge.log")
allowed_roots_str = os.getenv("ALLOWED_ROOTS", "Z:/,C:/Users/Public")
allowed_urls_str = os.getenv("ALLOWED_URLS", "")
- webapp_url = os.getenv("WEBAPP_URL", "file:///./webapp/index.html")
+ webapp_url = os.getenv("WEBAPP_URL", "https://wps.agravity.io/")
window_width = int(os.getenv("WINDOW_WIDTH", "1024"))
window_height = int(os.getenv("WINDOW_HEIGHT", "768"))
# Window title defaults to app_name + version if not specified
@@ -103,14 +203,13 @@ class Config:
for p in allowed_roots_str.split(","):
root_path = Path(p.strip()).resolve()
if not root_path.exists():
- raise ConfigurationError(
- f"Allowed root '{p.strip()}' does not exist"
- )
- if not root_path.is_dir():
+ logger.warning(f"Allowed root does not exist: {p.strip()}")
+ elif not root_path.is_dir():
raise ConfigurationError(
f"Allowed root '{p.strip()}' is not a directory"
)
- allowed_roots.append(root_path)
+ else:
+ allowed_roots.append(root_path)
except ConfigurationError:
raise
except (ValueError, OSError) as e:
@@ -140,6 +239,32 @@ class Config:
if url.strip()
] if allowed_urls_str else []
+ # Parse URL mappings (Azure Blob Storage → Local Paths)
+ # Format: url_prefix1=local_path1;url_prefix2=local_path2
+ url_mappings_str = os.getenv("URL_MAPPINGS", "")
+ url_mappings = []
+ if url_mappings_str:
+ try:
+ for mapping in url_mappings_str.split(";"):
+ mapping = mapping.strip()
+ if not mapping:
+ continue
+ if "=" not in mapping:
+ raise ConfigurationError(
+ f"Invalid URL mapping format: {mapping}. Expected 'url=path'"
+ )
+ url_prefix, local_path_str = mapping.split("=", 1)
+ url_mappings.append(
+ URLMapping(
+ url_prefix=url_prefix.strip(),
+ local_path=local_path_str.strip()
+ )
+ )
+ except (ValueError, OSError) as e:
+ raise ConfigurationError(
+ f"Invalid URL_MAPPINGS: {url_mappings_str}. Error: {e}"
+ ) from e
+
return cls(
app_name=app_name,
app_version=app_version,
@@ -148,12 +273,60 @@ class Config:
allowed_roots=allowed_roots,
allowed_urls=allowed_urls,
webapp_url=webapp_url,
+ url_mappings=url_mappings,
window_width=window_width,
window_height=window_height,
window_title=window_title,
enable_logging=enable_logging,
)
+ def to_file(self, config_path: Path) -> None:
+ """Save configuration to JSON file.
+
+ Args:
+ config_path: Path to save configuration
+ """
+ data = {
+ "app_name": self.app_name,
+ "webapp_url": self.webapp_url,
+ "url_mappings": [
+ {
+ "url_prefix": m.url_prefix,
+ "local_path": m.local_path
+ }
+ for m in self.url_mappings
+ ],
+ "allowed_roots": [str(p) for p in self.allowed_roots],
+ "allowed_urls": self.allowed_urls,
+ "check_file_exists": self.check_file_exists,
+ "auto_check_updates": self.auto_check_updates,
+ "update_check_interval_hours": self.update_check_interval_hours,
+ "log_level": self.log_level,
+ "log_file": str(self.log_file) if self.log_file else None,
+ "window_width": self.window_width,
+ "window_height": self.window_height,
+ "window_title": self.window_title,
+ "enable_logging": self.enable_logging,
+ }
+
+ config_path.parent.mkdir(parents=True, exist_ok=True)
+ with open(config_path, "w", encoding="utf-8") as f:
+ json.dump(data, f, indent=2)
+
+ @staticmethod
+ def get_default_config_path() -> Path:
+ """Get the default configuration file path.
+
+ Returns:
+ Path to default config file
+ """
+ import platform
+ if platform.system() == "Windows":
+ base = Path.home() / "AppData" / "Roaming"
+ else:
+ base = Path.home() / ".config"
+ return base / "webdrop_bridge" / "config.json"
+
def __repr__(self) -> str:
"""Return developer-friendly representation."""
return (
diff --git a/src/webdrop_bridge/core/drag_interceptor.py b/src/webdrop_bridge/core/drag_interceptor.py
index 14502b5..f00eae2 100644
--- a/src/webdrop_bridge/core/drag_interceptor.py
+++ b/src/webdrop_bridge/core/drag_interceptor.py
@@ -1,5 +1,6 @@
"""Qt widget for intercepting drag events and initiating native drag operations."""
+import logging
from pathlib import Path
from typing import List, Optional
@@ -7,98 +8,129 @@ from PySide6.QtCore import QMimeData, Qt, QUrl, Signal
from PySide6.QtGui import QDrag
from PySide6.QtWidgets import QWidget
+from webdrop_bridge.config import Config
+from webdrop_bridge.core.url_converter import URLConverter
from webdrop_bridge.core.validator import PathValidator, ValidationError
+logger = logging.getLogger(__name__)
+
class DragInterceptor(QWidget):
- """Widget that handles drag initiation for file paths.
+ """Widget that handles drag initiation for file paths or Azure URLs.
- Intercepts drag events from web content and initiates native Qt drag
- operations, allowing files to be dragged from web content to native
- applications.
+ Intercepts drag events from web content, converts Azure Blob Storage URLs
+ to local paths, validates them, and initiates native Qt drag operations.
Signals:
drag_started: Emitted when a drag operation begins successfully
drag_failed: Emitted when drag initiation fails
"""
- # Signals with string parameters (file paths that were dragged)
- drag_started = Signal(list) # List[str] - list of file paths
- drag_failed = Signal(str) # str - error message
+ # Signals with string parameters
+ drag_started = Signal(str, str) # (url_or_path, local_path)
+ drag_failed = Signal(str, str) # (url_or_path, error_message)
- def __init__(self, parent: Optional[QWidget] = None):
+ def __init__(self, config: Config, parent: Optional[QWidget] = None):
"""Initialize the drag interceptor.
Args:
+ config: Application configuration
parent: Parent widget
"""
super().__init__(parent)
- self._validator: Optional[PathValidator] = None
+ self.config = config
+ self._validator = PathValidator(
+ config.allowed_roots,
+ check_file_exists=config.check_file_exists
+ )
+ self._url_converter = URLConverter(config)
- def set_validator(self, validator: PathValidator) -> None:
- """Set the path validator for this interceptor.
+ def handle_drag(self, text: str) -> bool:
+ """Handle drag event from web view.
+
+ Determines if the text is an Azure URL or file path, converts if needed,
+ validates, and initiates native drag operation.
Args:
- validator: PathValidator instance to use for validation
- """
- self._validator = validator
-
- def initiate_drag(self, file_paths: List[str]) -> bool:
- """Initiate a native drag operation for the given files.
-
- Args:
- file_paths: List of file paths to drag
+ text: Azure Blob Storage URL or file path from web drag
Returns:
- True if drag was successfully initiated, False otherwise
+ True if native drag was initiated, False otherwise
"""
- if not file_paths:
- self.drag_failed.emit("No files to drag")
+ if not text or not text.strip():
+ error_msg = "Empty drag text"
+ logger.warning(error_msg)
+ self.drag_failed.emit("", error_msg)
return False
- if not self._validator:
- self.drag_failed.emit("Validator not configured")
- return False
+ text = text.strip()
+ logger.debug(f"Handling drag for text: {text}")
- # Validate all paths first
- validated_paths = []
- for path_str in file_paths:
- try:
- path = Path(path_str)
- if self._validator.validate(path):
- validated_paths.append(path)
- except ValidationError as e:
- self.drag_failed.emit(f"Validation failed for {path_str}: {e}")
+ # Check if it's an Azure URL and convert to local path
+ if self._url_converter.is_azure_url(text):
+ local_path = self._url_converter.convert_url_to_path(text)
+ if local_path is None:
+ error_msg = "No mapping found for URL"
+ logger.warning(f"{error_msg}: {text}")
+ self.drag_failed.emit(text, error_msg)
return False
-
- if not validated_paths:
- self.drag_failed.emit("No valid files after validation")
- return False
-
- # Create MIME data with file URLs
- mime_data = QMimeData()
- file_urls = [
- path.as_uri() for path in validated_paths
- ]
- mime_data.setUrls([QUrl(url) for url in file_urls])
-
- # Create and execute drag operation
- drag = QDrag(self)
- drag.setMimeData(mime_data)
- # Use default drag pixmap (small icon)
- drag.setPixmap(self.grab(self.rect()).scaled(
- 64, 64, Qt.AspectRatioMode.KeepAspectRatio
- ))
-
- # Execute drag operation (blocking call)
- drop_action = drag.exec(Qt.DropAction.CopyAction)
-
- # Check result
- if drop_action == Qt.DropAction.CopyAction:
- self.drag_started.emit(validated_paths)
- return True
+ source_text = text
else:
- self.drag_failed.emit("Drag operation cancelled or failed")
+ # Treat as direct file path
+ local_path = Path(text)
+ source_text = text
+
+ # Validate the path
+ try:
+ self._validator.validate(local_path)
+ except ValidationError as e:
+ error_msg = str(e)
+ logger.warning(f"Validation failed for {local_path}: {error_msg}")
+ self.drag_failed.emit(source_text, error_msg)
return False
+ logger.info(f"Initiating drag for: {local_path}")
+ # Create native file drag
+ success = self._create_native_drag(local_path)
+
+ if success:
+ self.drag_started.emit(source_text, str(local_path))
+ else:
+ error_msg = "Failed to create native drag operation"
+ logger.error(error_msg)
+ self.drag_failed.emit(source_text, error_msg)
+
+ return success
+
+ def _create_native_drag(self, file_path: Path) -> bool:
+ """Create a native file system drag operation.
+
+ Args:
+ file_path: Local file path to drag
+
+ Returns:
+ True if drag was created successfully
+ """
+ try:
+ # Create MIME data with file URL
+ mime_data = QMimeData()
+ file_url = QUrl.fromLocalFile(str(file_path))
+ mime_data.setUrls([file_url])
+
+ # Create and execute drag
+ drag = QDrag(self)
+ drag.setMimeData(mime_data)
+
+ # Optional: Set a drag icon/pixmap if available
+ # drag.setPixmap(...)
+
+ # Start drag operation (blocks until drop or cancel)
+ # Qt.CopyAction allows copying files
+ result = drag.exec(Qt.DropAction.CopyAction)
+
+ return result == Qt.DropAction.CopyAction
+
+ except Exception as e:
+ logger.exception(f"Error creating native drag: {e}")
+ return False
diff --git a/src/webdrop_bridge/core/url_converter.py b/src/webdrop_bridge/core/url_converter.py
new file mode 100644
index 0000000..4841dfe
--- /dev/null
+++ b/src/webdrop_bridge/core/url_converter.py
@@ -0,0 +1,86 @@
+"""URL to local path conversion for Azure Blob Storage URLs."""
+
+import logging
+from pathlib import Path
+from typing import Optional
+from urllib.parse import unquote
+
+from ..config import Config, URLMapping
+
+logger = logging.getLogger(__name__)
+
+
+class URLConverter:
+ """Converts Azure Blob Storage URLs to local file paths."""
+
+ def __init__(self, config: Config):
+ """Initialize converter with configuration.
+
+ Args:
+ config: Application configuration with URL mappings
+ """
+ self.config = config
+
+ def convert_url_to_path(self, url: str) -> Optional[Path]:
+ """Convert Azure Blob Storage URL to local file path.
+
+ Args:
+ url: Azure Blob Storage URL
+
+ Returns:
+ Local file path if mapping found, None otherwise
+
+ Example:
+ >>> converter.convert_url_to_path(
+ ... "https://wpsagravitystg.file.core.windows.net/wpsagravitysync/aN5PysnXIuRECzcRbvHkjL7g0/file.png"
+ ... )
+ Path("Z:/aN5PysnXIuRECzcRbvHkjL7g0/file.png")
+ """
+ if not url:
+ return None
+
+ # URL decode (handles special characters like spaces)
+ url = unquote(url)
+
+ # Find matching URL mapping
+ for mapping in self.config.url_mappings:
+ if url.startswith(mapping.url_prefix):
+ # Extract relative path after prefix
+ relative_path = url[len(mapping.url_prefix):]
+
+ # Combine with local path
+ local_path = Path(mapping.local_path) / relative_path
+
+ # Normalize path (resolve .. and .) but don't follow symlinks yet
+ try:
+ # On Windows, normalize separators
+ local_path = Path(str(local_path).replace("/", "\\"))
+ except (OSError, RuntimeError) as e:
+ logger.warning(f"Failed to normalize path {local_path}: {e}")
+ return None
+
+ logger.debug(f"Converted URL to path: {url} -> {local_path}")
+ return local_path
+
+ logger.debug(f"No mapping found for URL: {url}")
+ return None
+
+ def is_azure_url(self, text: str) -> bool:
+ """Check if text is an Azure Blob Storage URL.
+
+ Args:
+ text: Text to check
+
+ Returns:
+ True if text matches configured URL prefixes
+ """
+ if not text:
+ return False
+
+ text = text.strip()
+
+ for mapping in self.config.url_mappings:
+ if text.startswith(mapping.url_prefix):
+ return True
+
+ return False
diff --git a/src/webdrop_bridge/core/validator.py b/src/webdrop_bridge/core/validator.py
index 218fe2d..aac28c0 100644
--- a/src/webdrop_bridge/core/validator.py
+++ b/src/webdrop_bridge/core/validator.py
@@ -1,7 +1,10 @@
"""Path validation for secure file operations."""
+import logging
from pathlib import Path
-from typing import List
+from typing import List, Optional
+
+logger = logging.getLogger(__name__)
class ValidationError(Exception):
@@ -18,28 +21,27 @@ class PathValidator:
directory traversal attacks.
"""
- def __init__(self, allowed_roots: List[Path]):
+ def __init__(self, allowed_roots: List[Path], check_file_exists: bool = True):
"""Initialize validator with allowed root directories.
Args:
allowed_roots: List of Path objects representing allowed root dirs
+ check_file_exists: Whether to validate that files exist
Raises:
ValidationError: If any root doesn't exist or isn't a directory
"""
self.allowed_roots = []
+ self.check_file_exists = check_file_exists
for root in allowed_roots:
root_path = Path(root).resolve()
if not root_path.exists():
- raise ValidationError(
- f"Allowed root '{root}' does not exist"
- )
- if not root_path.is_dir():
- raise ValidationError(
- f"Allowed root '{root}' is not a directory"
- )
- self.allowed_roots.append(root_path)
+ logger.warning(f"Allowed root '{root}' does not exist")
+ elif not root_path.is_dir():
+ raise ValidationError(f"Allowed root '{root}' is not a directory")
+ else:
+ self.allowed_roots.append(root_path)
def validate(self, path: Path) -> bool:
"""Validate that path is within an allowed root directory.
@@ -59,28 +61,32 @@ class PathValidator:
except (OSError, ValueError) as e:
raise ValidationError(f"Cannot resolve path '{path}': {e}") from e
- # Check file exists
- if not file_path.exists():
- raise ValidationError(f"File does not exist: {path}")
+ # Check file exists if required
+ if self.check_file_exists:
+ if not file_path.exists():
+ raise ValidationError(f"File does not exist: {path}")
- # Check it's a regular file (not directory, symlink to dir, etc)
- if not file_path.is_file():
- raise ValidationError(f"Path is not a regular file: {path}")
+ # Check it's a regular file (not directory, symlink to dir, etc)
+ if not file_path.is_file():
+ raise ValidationError(f"Path is not a regular file: {path}")
- # Check path is within an allowed root
- for allowed_root in self.allowed_roots:
- try:
- # This raises ValueError if file_path is not relative to root
- file_path.relative_to(allowed_root)
- return True
- except ValueError:
- continue
+ # Check path is within an allowed root (if roots configured)
+ if self.allowed_roots:
+ for allowed_root in self.allowed_roots:
+ try:
+ # This raises ValueError if file_path is not relative to root
+ file_path.relative_to(allowed_root)
+ return True
+ except ValueError:
+ continue
- # Not in any allowed root
- raise ValidationError(
- f"Path '{file_path}' is not within allowed roots: "
- f"{self.allowed_roots}"
- )
+ # Not in any allowed root
+ raise ValidationError(
+ f"Path '{file_path}' is not within allowed roots: "
+ f"{self.allowed_roots}"
+ )
+
+ return True
def is_valid(self, path: Path) -> bool:
"""Check if path is valid without raising exception.
diff --git a/src/webdrop_bridge/main.py b/src/webdrop_bridge/main.py
index 6c33e88..d63ad97 100644
--- a/src/webdrop_bridge/main.py
+++ b/src/webdrop_bridge/main.py
@@ -19,8 +19,12 @@ def main() -> int:
int: Exit code (0 for success, non-zero for error)
"""
try:
- # Load configuration from environment
- config = Config.from_env()
+ # Load configuration from file if it exists, otherwise from environment
+ config_path = Config.get_default_config_path()
+ if config_path.exists():
+ config = Config.from_file(config_path)
+ else:
+ config = Config.from_env()
# Set up logging
log_file = None
diff --git a/src/webdrop_bridge/ui/bridge_script.js b/src/webdrop_bridge/ui/bridge_script.js
deleted file mode 100644
index aa5b8a3..0000000
--- a/src/webdrop_bridge/ui/bridge_script.js
+++ /dev/null
@@ -1,73 +0,0 @@
-// WebDrop Bridge - Injected Script
-// Automatically converts Z:\ path drags to native file drags via QWebChannel bridge
-
-(function() {
- if (window.__webdrop_bridge_injected) return;
- window.__webdrop_bridge_injected = true;
-
- function ensureChannel(cb) {
- if (window.bridge) { cb(); return; }
-
- function init() {
- if (window.QWebChannel && window.qt && window.qt.webChannelTransport) {
- new QWebChannel(window.qt.webChannelTransport, function(channel) {
- window.bridge = channel.objects.bridge;
- cb();
- });
- }
- }
-
- if (window.QWebChannel) {
- init();
- return;
- }
-
- var s = document.createElement('script');
- s.src = 'qrc:///qtwebchannel/qwebchannel.js';
- s.onload = init;
- document.documentElement.appendChild(s);
- }
-
- function hook() {
- document.addEventListener('dragstart', function(e) {
- var dt = e.dataTransfer;
- if (!dt) return;
-
- // Get path from existing payload or from the card markup.
- var path = dt.getData('text/plain');
- if (!path) {
- var card = e.target.closest && e.target.closest('.drag-item');
- if (card) {
- var pathEl = card.querySelector('p');
- if (pathEl) {
- path = (pathEl.textContent || '').trim();
- }
- }
- }
- if (!path) return;
-
- // Ensure text payload exists for non-file drags and downstream targets.
- if (!dt.getData('text/plain')) {
- dt.setData('text/plain', path);
- }
-
- // Check if path is Z:\ — if yes, trigger native file drag. Otherwise, stay as text.
- var isZDrive = /^z:/i.test(path);
- if (!isZDrive) return;
-
- // Z:\ detected — prevent default browser drag and convert to native file drag
- e.preventDefault();
- ensureChannel(function() {
- if (window.bridge && typeof window.bridge.start_file_drag === 'function') {
- window.bridge.start_file_drag(path);
- }
- });
- }, false);
- }
-
- if (document.readyState === 'loading') {
- document.addEventListener('DOMContentLoaded', hook);
- } else {
- hook();
- }
-})();
diff --git a/src/webdrop_bridge/ui/bridge_script_intercept.js b/src/webdrop_bridge/ui/bridge_script_intercept.js
new file mode 100644
index 0000000..b3c2f52
--- /dev/null
+++ b/src/webdrop_bridge/ui/bridge_script_intercept.js
@@ -0,0 +1,197 @@
+// WebDrop Bridge - Intercept Version
+// Prevents browser drag for ALT+drag, hands off to Qt for file drag
+
+(function() {
+ try {
+ if (window.__webdrop_intercept_injected) return;
+ window.__webdrop_intercept_injected = true;
+
+ // Intercept mode enabled
+ var INTERCEPT_ENABLED = true;
+
+ console.log('%c[WebDrop Intercept] Script loaded - INTERCEPT_ENABLED=' + INTERCEPT_ENABLED, 'background: #2196F3; color: white; font-weight: bold; padding: 4px 8px;');
+
+ var currentDragUrl = null;
+ var angularDragHandlers = [];
+ var originalAddEventListener = EventTarget.prototype.addEventListener;
+ var listenerPatchActive = true;
+
+ // Capture Authorization token from XHR requests
+ window.capturedAuthToken = null;
+ var originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
+ XMLHttpRequest.prototype.setRequestHeader = function(header, value) {
+ if (header === 'Authorization' && value.startsWith('Bearer ')) {
+ window.capturedAuthToken = value;
+ console.log('[Intercept] Captured auth token');
+ }
+ return originalXHRSetRequestHeader.apply(this, arguments);
+ };
+
+ // ============================================================================
+ // PART 1: Intercept Angular's dragstart listener registration
+ // ============================================================================
+
+ EventTarget.prototype.addEventListener = function(type, listener, options) {
+ if (listenerPatchActive && type === 'dragstart' && listener) {
+ // Store Angular's dragstart handler instead of registering it
+ console.log('[Intercept] Storing Angular dragstart listener for', this.tagName || this.constructor.name);
+ angularDragHandlers.push({
+ target: this,
+ listener: listener,
+ options: options
+ });
+ return; // Don't actually register it yet
+ }
+ // All other events: use original
+ return originalAddEventListener.call(this, type, listener, options);
+ };
+
+ // ============================================================================
+ // PART 2: Intercept DataTransfer.setData to capture URL
+ // ============================================================================
+
+ var originalSetData = DataTransfer.prototype.setData;
+
+ DataTransfer.prototype.setData = function(format, data) {
+ if (format === 'text/plain' || format === 'text/uri-list') {
+ currentDragUrl = data;
+ console.log('%c[Intercept] Captured URL:', 'color: #4CAF50; font-weight: bold;', data.substring(0, 80));
+ }
+ return originalSetData.call(this, format, data);
+ };
+
+ console.log('[Intercept] DataTransfer.setData patched ✓');
+
+ // ============================================================================
+ // PART 3: Install OUR dragstart handler in capture phase
+ // ============================================================================
+
+ function installDragHandler() {
+ console.log('[Intercept] Installing dragstart handler, have', angularDragHandlers.length, 'Angular handlers');
+
+ if (angularDragHandlers.length === 0) {
+ console.warn('[Intercept] No Angular handlers found yet, will retry in 1s...');
+ setTimeout(installDragHandler, 1000);
+ return;
+ }
+
+ // Stop intercepting addEventListener
+ listenerPatchActive = false;
+
+ // Register OUR handler in capture phase
+ originalAddEventListener.call(document, 'dragstart', function(e) {
+ currentDragUrl = null; // Reset
+
+ console.log('%c[Intercept] dragstart', 'background: #FF9800; color: white; padding: 2px 6px;', 'ALT:', e.altKey);
+
+ // Call Angular's handlers first to let them set the data
+ var handled = 0;
+ for (var i = 0; i < angularDragHandlers.length; i++) {
+ var h = angularDragHandlers[i];
+ if (h.target === document || h.target === e.target ||
+ (h.target.contains && h.target.contains(e.target))) {
+ try {
+ h.listener.call(e.target, e);
+ handled++;
+ } catch(err) {
+ console.error('[Intercept] Error calling Angular handler:', err);
+ }
+ }
+ }
+
+ console.log('[Intercept] Called', handled, 'Angular handlers, URL:', currentDragUrl ? currentDragUrl.substring(0, 60) : 'none');
+
+ // NOW check if we should intercept
+ if (e.altKey && currentDragUrl) {
+ var shouldIntercept = false;
+
+ // Check against configured URL mappings
+ if (window.webdropConfig && window.webdropConfig.urlMappings) {
+ for (var j = 0; j < window.webdropConfig.urlMappings.length; j++) {
+ var mapping = window.webdropConfig.urlMappings[j];
+ if (currentDragUrl.toLowerCase().startsWith(mapping.url_prefix.toLowerCase())) {
+ shouldIntercept = true;
+ console.log('[Intercept] URL matches mapping for:', mapping.local_path);
+ break;
+ }
+ }
+ } else {
+ // Fallback: Check for legacy Z: drive pattern if no config available
+ shouldIntercept = /^z:/i.test(currentDragUrl);
+ if (shouldIntercept) {
+ console.warn('[Intercept] Using fallback Z: drive pattern (no URL mappings configured)');
+ }
+ }
+
+ if (shouldIntercept) {
+ console.log('%c[Intercept] PREVENTING browser drag, using Qt',
+ 'background: #F44336; color: white; font-weight: bold; padding: 4px 8px;');
+
+ e.preventDefault();
+ e.stopPropagation();
+
+ ensureChannel(function() {
+ if (window.bridge && typeof window.bridge.start_file_drag === 'function') {
+ console.log('%c[Intercept] → Qt: start_file_drag', 'color: #9C27B0; font-weight: bold;');
+ window.bridge.start_file_drag(currentDragUrl);
+ } else {
+ console.error('[Intercept] bridge.start_file_drag not available!');
+ }
+ });
+
+ currentDragUrl = null;
+ return false;
+ }
+ }
+
+ console.log('[Intercept] Normal drag, allowing browser');
+ }, true); // Capture phase
+
+ console.log('[Intercept] dragstart handler installed ✓');
+ }
+
+ // Wait for Angular to register its listeners, then install our handler
+ // Start checking after 2 seconds (give Angular time to load on first page load)
+ setTimeout(installDragHandler, 2000);
+
+ // ============================================================================
+ // PART 3: QWebChannel connection
+ // ============================================================================
+
+ function ensureChannel(callback) {
+ if (window.bridge) {
+ callback();
+ return;
+ }
+
+ if (window.QWebChannel && window.qt && window.qt.webChannelTransport) {
+ new QWebChannel(window.qt.webChannelTransport, function(channel) {
+ window.bridge = channel.objects.bridge;
+ console.log('[WebDrop Intercept] QWebChannel connected ✓');
+ callback();
+ });
+ } else {
+ console.error('[WebDrop Intercept] QWebChannel not available!');
+ }
+ }
+
+ // Initialize channel on load
+ if (document.readyState === 'loading') {
+ document.addEventListener('DOMContentLoaded', function() {
+ ensureChannel(function() {
+ console.log('[WebDrop Intercept] Bridge ready ✓');
+ });
+ });
+ } else {
+ ensureChannel(function() {
+ console.log('[WebDrop Intercept] Bridge ready ✓');
+ });
+ }
+
+ console.log('%c[WebDrop Intercept] Ready! ALT-drag will use Qt file drag.',
+ 'background: #4CAF50; color: white; font-weight: bold; padding: 4px 8px;');
+ } catch(e) {
+ console.error('[WebDrop Intercept] FATAL ERROR in bridge script:', e);
+ console.error('[WebDrop Intercept] Stack:', e.stack);
+ }
+})();
diff --git a/src/webdrop_bridge/ui/download_interceptor.js b/src/webdrop_bridge/ui/download_interceptor.js
new file mode 100644
index 0000000..45a757e
--- /dev/null
+++ b/src/webdrop_bridge/ui/download_interceptor.js
@@ -0,0 +1,72 @@
+// Download Interceptor Script
+// Intercepts JavaScript-based downloads (fetch, XMLHttpRequest, Blob URLs)
+
+(function() {
+ 'use strict';
+
+ console.log('🔍 Download interceptor script loaded');
+
+ // Intercept fetch() calls
+ const originalFetch = window.fetch;
+ window.fetch = function(...args) {
+ const url = args[0];
+ console.log('🌐 Fetch called:', url);
+
+ // Check if this looks like a download
+ if (typeof url === 'string') {
+ const urlLower = url.toLowerCase();
+ const downloadPatterns = [
+ '/download', '/export', '/file',
+ '.pdf', '.zip', '.xlsx', '.docx',
+ 'attachment', 'content-disposition'
+ ];
+
+ if (downloadPatterns.some(pattern => urlLower.includes(pattern))) {
+ console.log('📥 Potential download detected via fetch:', url);
+ }
+ }
+
+ return originalFetch.apply(this, args);
+ };
+
+ // Intercept XMLHttpRequest
+ const originalXHROpen = XMLHttpRequest.prototype.open;
+ XMLHttpRequest.prototype.open = function(method, url, ...rest) {
+ console.log('🌐 XHR opened:', method, url);
+ this._url = url;
+ return originalXHROpen.apply(this, [method, url, ...rest]);
+ };
+
+ const originalXHRSend = XMLHttpRequest.prototype.send;
+ XMLHttpRequest.prototype.send = function(...args) {
+ console.log('📤 XHR send:', this._url);
+ return originalXHRSend.apply(this, args);
+ };
+
+ // Intercept Blob URL creation
+ const originalCreateObjectURL = URL.createObjectURL;
+ URL.createObjectURL = function(blob) {
+ console.log('🔗 Blob URL created, size:', blob.size, 'type:', blob.type);
+ return originalCreateObjectURL.apply(this, arguments);
+ };
+
+ // Intercept anchor clicks that might be downloads
+ document.addEventListener('click', function(e) {
+ const target = e.target.closest('a');
+ if (target && target.href) {
+ const href = target.href;
+ const download = target.getAttribute('download');
+
+ if (download !== null) {
+ console.log('📥 Download link clicked:', href, 'filename:', download);
+ }
+
+ // Check for blob URLs
+ if (href.startsWith('blob:')) {
+ console.log('📦 Blob download link clicked:', href);
+ }
+ }
+ }, true);
+
+ console.log('✅ Download interceptor active');
+})();
diff --git a/src/webdrop_bridge/ui/main_window.py b/src/webdrop_bridge/ui/main_window.py
index 84638a4..dd1bf0d 100644
--- a/src/webdrop_bridge/ui/main_window.py
+++ b/src/webdrop_bridge/ui/main_window.py
@@ -1,15 +1,29 @@
"""Main application window with web engine integration."""
import asyncio
+import json
import logging
+import re
from datetime import datetime
from pathlib import Path
from typing import Optional
-from PySide6.QtCore import QObject, QPoint, QSize, Qt, QThread, QTimer, QUrl, Signal, Slot
-from PySide6.QtGui import QIcon
+from PySide6.QtCore import (
+ QEvent,
+ QObject,
+ QPoint,
+ QSize,
+ QStandardPaths,
+ Qt,
+ QThread,
+ QTimer,
+ QUrl,
+ Signal,
+ Slot,
+)
+from PySide6.QtGui import QIcon, QMouseEvent
from PySide6.QtWebChannel import QWebChannel
-from PySide6.QtWebEngineCore import QWebEngineScript
+from PySide6.QtWebEngineCore import QWebEngineDownloadRequest, QWebEngineScript
from PySide6.QtWidgets import (
QLabel,
QMainWindow,
@@ -202,19 +216,29 @@ class _DragBridge(QObject):
@Slot(str)
def start_file_drag(self, path_text: str) -> None:
- """Start a native file drag for the given path.
+ """Start a native file drag for the given path or Azure URL.
- Called from JavaScript when user drags a Z:\ path item.
+ Called from JavaScript when user drags an item.
+ Accepts either local file paths or Azure Blob Storage URLs.
Defers execution to avoid Qt drag manager state issues.
Args:
- path_text: File path string to drag
+ path_text: File path string or Azure URL to drag
"""
logger.debug(f"Bridge: start_file_drag called for {path_text}")
# Defer to avoid drag manager state issues
- # initiate_drag() handles validation internally
- QTimer.singleShot(0, lambda: self.window.drag_interceptor.initiate_drag([path_text]))
+ # handle_drag() handles URL conversion and validation internally
+ QTimer.singleShot(0, lambda: self.window.drag_interceptor.handle_drag(path_text))
+
+ @Slot(str)
+ def debug_log(self, message: str) -> None:
+ """Log debug message from JavaScript.
+
+ Args:
+ message: Debug message from JavaScript
+ """
+ logger.debug(f"JS Debug: {message}")
class MainWindow(QMainWindow):
@@ -254,9 +278,27 @@ class MainWindow(QMainWindow):
config.window_width,
config.window_height,
)
+
+ # Set window icon
+ icon_path = Path(__file__).parent.parent.parent.parent / "resources" / "icons" / "app.ico"
+ if icon_path.exists():
+ self.setWindowIcon(QIcon(str(icon_path)))
+ logger.debug(f"Window icon set from {icon_path}")
+ else:
+ logger.warning(f"Window icon not found at {icon_path}")
# Create web engine view
self.web_view = RestrictedWebEngineView(config.allowed_urls)
+
+ # Enable the main window and web view to receive drag events
+ self.setAcceptDrops(True)
+ self.web_view.setAcceptDrops(True)
+
+ # Track ongoing drags from web view
+ self._current_drag_url = None
+
+ # Redirect JavaScript console messages to Python logger
+ self.web_view.page().javaScriptConsoleMessage = self._on_js_console_message
# Create navigation toolbar (Kiosk-mode navigation)
self._create_navigation_toolbar()
@@ -264,11 +306,8 @@ class MainWindow(QMainWindow):
# Create status bar
self._create_status_bar()
- # Create drag interceptor
- self.drag_interceptor = DragInterceptor()
- # Set up path validator
- validator = PathValidator(config.allowed_roots)
- self.drag_interceptor.set_validator(validator)
+ # Create drag interceptor with config (includes URL converter)
+ self.drag_interceptor = DragInterceptor(config)
# Connect drag interceptor signals
self.drag_interceptor.drag_started.connect(self._on_drag_started)
@@ -282,6 +321,26 @@ class MainWindow(QMainWindow):
# Install the drag bridge script
self._install_bridge_script()
+
+ # Connect to loadFinished to verify script injection
+ self.web_view.loadFinished.connect(self._on_page_loaded)
+
+ # Set up download handler
+ profile = self.web_view.page().profile()
+ logger.debug(f"Connecting download handler to profile: {profile}")
+
+ # CRITICAL: Connect download handler BEFORE any page loads
+ profile.downloadRequested.connect(self._on_download_requested)
+
+ # Enable downloads by setting download path
+ downloads_path = QStandardPaths.writableLocation(
+ QStandardPaths.StandardLocation.DownloadLocation
+ )
+ if downloads_path:
+ profile.setDownloadPath(downloads_path)
+ logger.debug(f"Download path set to: {downloads_path}")
+
+ logger.debug("Download handler connected successfully")
# Set up central widget with layout
central_widget = QWidget()
@@ -353,24 +412,125 @@ class MainWindow(QMainWindow):
def _install_bridge_script(self) -> None:
"""Install the drag bridge JavaScript via QWebEngineScript.
- Follows the POC pattern for proper script injection and QWebChannel setup.
+ Uses DocumentCreation injection point to ensure script runs as early as possible,
+ before any page scripts that might interfere with drag events.
+
+ Embeds qwebchannel.js inline to avoid CSP issues with qrc:// URLs.
+ Injects configuration that bridge script uses for dynamic URL pattern matching.
"""
+ from PySide6.QtCore import QFile, QIODevice
+
script = QWebEngineScript()
script.setName("webdrop-bridge")
- script.setInjectionPoint(QWebEngineScript.InjectionPoint.DocumentReady)
+ script.setInjectionPoint(QWebEngineScript.InjectionPoint.DocumentCreation)
script.setWorldId(QWebEngineScript.ScriptWorldId.MainWorld)
script.setRunsOnSubFrames(False)
+ # Load qwebchannel.js from Qt resources (avoids CSP blocking qrc:// URLs)
+ qwebchannel_code = ""
+ qwebchannel_file = QFile(":/qtwebchannel/qwebchannel.js")
+ if qwebchannel_file.open(QIODevice.OpenModeFlag.ReadOnly | QIODevice.OpenModeFlag.Text):
+ qwebchannel_code = bytes(qwebchannel_file.readAll()).decode('utf-8') # type: ignore
+ qwebchannel_file.close()
+ logger.debug("Loaded qwebchannel.js inline to avoid CSP issues")
+ else:
+ logger.warning("Failed to load qwebchannel.js from resources")
+
+ # Generate configuration injection script
+ config_code = self._generate_config_injection_script()
+
# Load bridge script from file
- script_path = Path(__file__).parent / "bridge_script.js"
+ # Using intercept script - prevents browser drag, hands off to Qt
+ script_path = Path(__file__).parent / "bridge_script_intercept.js"
try:
with open(script_path, 'r', encoding='utf-8') as f:
- script.setSourceCode(f.read())
+ bridge_code = f.read()
+
+ # Load download interceptor
+ download_interceptor_path = Path(__file__).parent / "download_interceptor.js"
+ download_interceptor_code = ""
+ try:
+ with open(download_interceptor_path, 'r', encoding='utf-8') as f:
+ download_interceptor_code = f.read()
+ logger.debug(f"Loaded download interceptor from {download_interceptor_path}")
+ except (OSError, IOError) as e:
+ logger.warning(f"Download interceptor not found: {e}")
+
+ # Combine: qwebchannel.js + config + bridge script + download interceptor
+ combined_code = qwebchannel_code + "\n\n" + config_code + "\n\n" + bridge_code
+
+ if download_interceptor_code:
+ combined_code += "\n\n" + download_interceptor_code
+
+ logger.debug(f"Combined script size: {len(combined_code)} chars "
+ f"(qwebchannel: {len(qwebchannel_code)}, "
+ f"config: {len(config_code)}, "
+ f"bridge: {len(bridge_code)}, "
+ f"interceptor: {len(download_interceptor_code)})")
+ logger.debug(f"URL mappings in config: {len(self.config.url_mappings)}")
+ for i, mapping in enumerate(self.config.url_mappings):
+ logger.debug(f" Mapping {i+1}: {mapping.url_prefix} → {mapping.local_path}")
+
+ script.setSourceCode(combined_code)
self.web_view.page().scripts().insert(script)
logger.debug(f"Installed bridge script from {script_path}")
except (OSError, IOError) as e:
logger.warning(f"Failed to load bridge script: {e}")
+ def _generate_config_injection_script(self) -> str:
+ """Generate JavaScript code that injects configuration.
+
+ Creates a script that sets window.webdropConfig with the current
+ URL mappings, allowing the bridge script to dynamically check
+ against configured patterns instead of hardcoded values.
+
+ Returns:
+ JavaScript code as string
+ """
+ # Convert URL mappings to format expected by bridge script
+ mappings = []
+ for mapping in self.config.url_mappings:
+ mappings.append({
+ "url_prefix": mapping.url_prefix,
+ "local_path": mapping.local_path
+ })
+
+ logger.debug(f"Generating config injection with {len(mappings)} URL mappings")
+ for i, m in enumerate(mappings):
+ logger.debug(f" [{i+1}] {m['url_prefix']} -> {m['local_path']}")
+
+ # Generate config object as JSON
+ config_obj = {"urlMappings": mappings}
+ config_json = json.dumps(config_obj)
+
+ logger.debug(f"Config JSON size: {len(config_json)} bytes")
+
+ # Generate JavaScript code - Safe injection with error handling
+ config_js = f"""
+(function() {{
+ try {{
+ // WebDrop Bridge - Configuration Injection
+ console.log('[WebDrop Config] Starting configuration injection...');
+ window.webdropConfig = {config_json};
+ console.log('[WebDrop Config] Configuration object created');
+
+ if (window.webdropConfig && window.webdropConfig.urlMappings) {{
+ console.log('[WebDrop Config] SUCCESS: ' + window.webdropConfig.urlMappings.length + ' URL mappings loaded');
+ for (var i = 0; i < window.webdropConfig.urlMappings.length; i++) {{
+ var m = window.webdropConfig.urlMappings[i];
+ console.log('[WebDrop Config] [' + (i+1) + '] ' + m.url_prefix + ' -> ' + m.local_path);
+ }}
+ }} else {{
+ console.warn('[WebDrop Config] WARNING: No valid URL mappings found in config object');
+ }}
+ }} catch(e) {{
+ console.error('[WebDrop Config] ERROR during configuration injection: ' + e.message);
+ if (e.stack) console.error('[WebDrop Config] Stack: ' + e.stack);
+ }}
+}})();
+"""
+ return config_js
+
def _inject_drag_bridge(self, html_content: str) -> str:
"""Return HTML content unmodified.
@@ -399,23 +559,436 @@ class MainWindow(QMainWindow):
# Silently fail if stylesheet can't be read
pass
- def _on_drag_started(self, paths: list) -> None:
+ def _on_drag_started(self, source: str, local_path: str) -> None:
"""Handle successful drag initiation.
Args:
- paths: List of paths that were dragged
+ source: Original URL or path from web content
+ local_path: Local file path that is being dragged
"""
- # Can be extended with logging or status bar updates
- pass
+ logger.info(f"Drag started: {source} -> {local_path}")
+
+ # Ask user if they want to check out the asset
+ if source.startswith('http'):
+ self._prompt_checkout(source, local_path)
+
+ def _prompt_checkout(self, azure_url: str, local_path: str) -> None:
+ """Check checkout status and prompt user if needed.
+
+ First checks if the asset is already checked out. Only shows dialog if not checked out.
+
+ Args:
+ azure_url: Azure Blob Storage URL
+ local_path: Local file path
+ """
+ from PySide6.QtWidgets import QMessageBox
- def _on_drag_failed(self, error: str) -> None:
+ # Extract filename for display
+ filename = Path(local_path).name
+
+ # Extract asset ID
+ match = re.search(r'/([^/]+)/[^/]+$', azure_url)
+ if not match:
+ logger.warning(f"Could not extract asset ID from URL: {azure_url}")
+ return
+
+ asset_id = match.group(1)
+
+ # Store callback ID for this check
+ callback_id = f"checkout_check_{id(self)}"
+
+ # Check checkout status - use callback approach since Qt doesn't handle Promise returns well
+ js_code = f"""
+ (async () => {{
+ try {{
+ const authToken = window.capturedAuthToken;
+ if (!authToken) {{
+ console.log('[Checkout Check] No auth token available');
+ window['{callback_id}'] = JSON.stringify({{ error: 'No auth token' }});
+ return;
+ }}
+
+ console.log('[Checkout Check] Fetching asset data for {asset_id}');
+ const response = await fetch(
+ 'https://devagravityprivate.azurewebsites.net/api/assets/{asset_id}?fields=checkout',
+ {{
+ method: 'GET',
+ headers: {{
+ 'Accept': 'application/json',
+ 'Authorization': authToken
+ }}
+ }}
+ );
+
+ console.log('[Checkout Check] Response status:', response.status);
+
+ if (response.ok) {{
+ const data = await response.json();
+ console.log('[Checkout Check] Full data:', JSON.stringify(data));
+ console.log('[Checkout Check] Checkout field:', data.checkout);
+ const hasCheckout = !!(data.checkout && Object.keys(data.checkout).length > 0);
+ console.log('[Checkout Check] Has checkout:', hasCheckout);
+ window['{callback_id}'] = JSON.stringify({{ checkout: data.checkout || null, hasCheckout: hasCheckout }});
+ }} else {{
+ console.log('[Checkout Check] Failed to fetch, status:', response.status);
+ window['{callback_id}'] = JSON.stringify({{ error: 'Failed to fetch asset', status: response.status }});
+ }}
+ }} catch (error) {{
+ console.error('[Checkout Check] Error:', error);
+ window['{callback_id}'] = JSON.stringify({{ error: error.toString() }});
+ }}
+ }})();
+ """
+
+ # Execute the async fetch
+ self.web_view.page().runJavaScript(js_code)
+
+ # After a short delay, read the result from window variable
+ def check_result():
+ read_code = f"window['{callback_id}']"
+ self.web_view.page().runJavaScript(read_code, lambda result: self._handle_checkout_status(result, azure_url, filename, callback_id))
+
+ # Wait 500ms for async fetch to complete
+ from PySide6.QtCore import QTimer
+ QTimer.singleShot(500, check_result)
+
+ def _handle_checkout_status(self, result, azure_url: str, filename: str, callback_id: str) -> None:
+ """Handle the result of checkout status check.
+
+ Args:
+ result: Result from JavaScript (JSON string)
+ azure_url: Azure URL
+ filename: Asset filename
+ callback_id: Callback ID to clean up
+ """
+ # Clean up window variable
+ cleanup_code = f"delete window['{callback_id}']"
+ self.web_view.page().runJavaScript(cleanup_code)
+
+ logger.debug(f"Checkout status result type: {type(result)}, value: {result}")
+
+ if not result or not isinstance(result, str):
+ logger.warning(f"Checkout status check returned invalid result: {result}")
+ self._show_checkout_dialog(azure_url, filename)
+ return
+
+ # Parse JSON string
+ try:
+ import json
+ parsed_result = json.loads(result)
+ except (json.JSONDecodeError, ValueError) as e:
+ logger.warning(f"Failed to parse checkout status result: {e}")
+ self._show_checkout_dialog(azure_url, filename)
+ return
+
+ if parsed_result.get('error'):
+ logger.warning(f"Could not check checkout status: {parsed_result}")
+ self._show_checkout_dialog(azure_url, filename)
+ return
+
+ # Check if already checked out
+ has_checkout = parsed_result.get('hasCheckout', False)
+ if has_checkout:
+ checkout_info = parsed_result.get('checkout', {})
+ logger.info(f"Asset {filename} is already checked out: {checkout_info}, skipping dialog")
+ return
+
+ # Not checked out, show confirmation dialog
+ logger.debug(f"Asset {filename} is not checked out, showing dialog")
+ self._show_checkout_dialog(azure_url, filename)
+
+ def _show_checkout_dialog(self, azure_url: str, filename: str) -> None:
+ """Show the checkout confirmation dialog.
+
+ Args:
+ azure_url: Azure Blob Storage URL
+ filename: Asset filename
+ """
+ from PySide6.QtWidgets import QMessageBox
+
+ reply = QMessageBox.question(
+ self,
+ "Checkout Asset",
+ f"Do you want to check out this asset?\n\n{filename}",
+ QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+ QMessageBox.StandardButton.Yes
+ )
+
+ if reply == QMessageBox.StandardButton.Yes:
+ logger.info(f"User confirmed checkout for {filename}")
+ self._trigger_checkout_api(azure_url)
+ else:
+ logger.info(f"User declined checkout for {filename}")
+
+ def _trigger_checkout_api(self, azure_url: str) -> None:
+ """Trigger checkout via API call using JavaScript.
+
+ Calls the checkout API from JavaScript so HttpOnly cookies are automatically included.
+ Example URL: https://devagravitystg.file.core.windows.net/devagravitysync/anPGZszKzgKaSz1SIx2HFgduy/filename
+ Asset ID: anPGZszKzgKaSz1SIx2HFgduy
+
+ Args:
+ azure_url: Azure Blob Storage URL containing asset ID
+ """
+ try:
+ # Extract asset ID from URL (middle segment between domain and filename)
+ # Format: https://domain/container/ASSET_ID/filename
+ match = re.search(r'/([^/]+)/[^/]+$', azure_url)
+ if not match:
+ logger.warning(f"Could not extract asset ID from URL: {azure_url}")
+ return
+
+ asset_id = match.group(1)
+ logger.info(f"Extracted asset ID: {asset_id}")
+
+ # Call API from JavaScript with Authorization header
+ js_code = f"""
+ (async function() {{
+ try {{
+ // Get captured auth token (from intercepted XHR)
+ const authToken = window.capturedAuthToken;
+
+ if (!authToken) {{
+ console.error('No authorization token available');
+ return {{ success: false, error: 'No auth token' }};
+ }}
+
+ const headers = {{
+ 'Accept': 'application/json',
+ 'Content-Type': 'application/json',
+ 'Accept-Language': 'de',
+ 'Authorization': authToken
+ }};
+
+ const response = await fetch(
+ 'https://devagravityprivate.azurewebsites.net/api/assets/checkout/bulk?checkout=true',
+ {{
+ method: 'PUT',
+ headers: headers,
+ body: JSON.stringify({{asset_ids: ['{asset_id}']}})
+ }}
+ );
+
+ if (response.ok) {{
+ console.log('✅ Checkout API successful for asset {asset_id}');
+ return {{ success: true, status: response.status }};
+ }} else {{
+ const text = await response.text();
+ console.warn('Checkout API returned status ' + response.status + ': ' + text.substring(0, 200));
+ return {{ success: false, status: response.status, error: text }};
+ }}
+ }} catch (error) {{
+ console.error('Checkout API call failed:', error);
+ return {{ success: false, error: error.toString() }};
+ }}
+ }})();
+ """
+
+ def on_result(result):
+ """Callback when JavaScript completes."""
+ if result and isinstance(result, dict):
+ if result.get('success'):
+ logger.info(f"✅ Checkout successful for asset {asset_id}")
+ else:
+ status = result.get('status', 'unknown')
+ error = result.get('error', 'unknown error')
+ logger.warning(f"Checkout API returned status {status}: {error}")
+ else:
+ logger.debug(f"Checkout API call completed (result: {result})")
+
+ # Execute JavaScript (async, non-blocking)
+ self.web_view.page().runJavaScript(js_code, on_result)
+
+ except Exception as e:
+ logger.exception(f"Error triggering checkout API: {e}")
+
+ def _on_drag_failed(self, source: str, error: str) -> None:
"""Handle drag operation failure.
Args:
+ source: Original URL or path from web content
error: Error message
"""
- # Can be extended with logging or user notification
- pass
+ logger.warning(f"Drag failed for {source}: {error}")
+ # Can be extended with user notification or status bar message
+
+ def _on_download_requested(self, download: QWebEngineDownloadRequest) -> None:
+ """Handle download requests from the embedded web view.
+
+ Downloads are automatically saved to the user's Downloads folder.
+
+ Args:
+ download: Download request from the web engine
+ """
+ try:
+ # Log download details for debugging
+ logger.debug(f"Download URL: {download.url().toString()}")
+ logger.debug(f"Download filename: {download.downloadFileName()}")
+ logger.debug(f"Download mime type: {download.mimeType()}")
+ logger.debug(f"Download suggested filename: {download.suggestedFileName()}")
+ logger.debug(f"Download state: {download.state()}")
+
+ # Get the system's Downloads folder
+ downloads_path = QStandardPaths.writableLocation(
+ QStandardPaths.StandardLocation.DownloadLocation
+ )
+
+ if not downloads_path:
+ # Fallback to user's home directory if Downloads folder not available
+ downloads_path = str(Path.home())
+ logger.warning("Downloads folder not found, using home directory")
+
+ # Use suggested filename if available, fallback to downloadFileName
+ filename = download.suggestedFileName() or download.downloadFileName()
+ if not filename:
+ filename = "download"
+ logger.warning("No filename suggested, using 'download'")
+
+ # Construct full download path
+ download_file = Path(downloads_path) / filename
+ logger.debug(f"Download will be saved to: {download_file}")
+
+ # Set download path and accept
+ download.setDownloadDirectory(str(download_file.parent))
+ download.setDownloadFileName(download_file.name)
+ download.accept()
+
+ logger.info(f"Download started: {filename}")
+
+ # Update status bar (temporarily)
+ self.status_bar.showMessage(
+ f"📥 Download: {filename}", 3000
+ )
+
+ # Connect to state changed for progress tracking
+ download.stateChanged.connect(
+ lambda state: logger.debug(f"Download state changed to: {state}")
+ )
+
+ # Connect to finished signal for completion feedback
+ download.isFinishedChanged.connect(
+ lambda: self._on_download_finished(download, download_file)
+ )
+
+ except Exception as e:
+ logger.error(f"Error handling download: {e}", exc_info=True)
+ self.status_bar.showMessage(f"Download error: {e}", 5000)
+
+ def _on_download_finished(self, download: QWebEngineDownloadRequest, file_path: Path) -> None:
+ """Handle download completion.
+
+ Args:
+ download: The completed download request
+ file_path: Path where file was saved
+ """
+ try:
+ if not download.isFinished():
+ return
+
+ state = download.state()
+ logger.debug(f"Download finished with state: {state}")
+
+ if state == QWebEngineDownloadRequest.DownloadState.DownloadCompleted:
+ logger.info(f"Download completed: {file_path.name}")
+ self.status_bar.showMessage(
+ f"Download completed: {file_path.name}", 5000
+ )
+ elif state == QWebEngineDownloadRequest.DownloadState.DownloadCancelled:
+ logger.info(f"Download cancelled: {file_path.name}")
+ self.status_bar.showMessage(
+ f"⚠️ Download abgebrochen: {file_path.name}", 3000
+ )
+ elif state == QWebEngineDownloadRequest.DownloadState.DownloadInterrupted:
+ logger.warning(f"Download interrupted: {file_path.name}")
+ self.status_bar.showMessage(
+ f"❌ Download fehlgeschlagen: {file_path.name}", 5000
+ )
+ except Exception as e:
+ logger.error(f"Error in download finished handler: {e}", exc_info=True)
+
+ def dragEnterEvent(self, event):
+ """Handle drag entering the main window (from WebView or external).
+
+ Note: With intercept script, ALT-drags are prevented in JavaScript
+ and handled via bridge.start_file_drag(). This just handles any
+ remaining drag events.
+
+ Args:
+ event: QDragEnterEvent
+ """
+ event.ignore()
+
+ def dragMoveEvent(self, event):
+ """Handle drag moving over the main window.
+
+ Args:
+ event: QDragMoveEvent
+ """
+ event.ignore()
+
+ def dragLeaveEvent(self, event):
+ """Handle drag leaving the main window.
+
+ Args:
+ event: QDragLeaveEvent
+ """
+ event.ignore()
+
+ def dropEvent(self, event):
+ """Handle drop on the main window.
+
+ Args:
+ event: QDropEvent
+ """
+ event.ignore()
+
+ def _on_js_console_message(self, level, message, line_number, source_id):
+ """Redirect JavaScript console messages to Python logger.
+
+ Args:
+ level: Console message level (JavaScriptConsoleMessageLevel enum)
+ message: The console message
+ line_number: Line number where the message originated
+ source_id: Source file/URL where the message originated
+ """
+ from PySide6.QtWebEngineCore import QWebEnginePage
+
+ # Map JS log levels to Python log levels using enum
+ if level == QWebEnginePage.JavaScriptConsoleMessageLevel.InfoMessageLevel:
+ logger.debug(f"JS Console: {message}")
+ elif level == QWebEnginePage.JavaScriptConsoleMessageLevel.WarningMessageLevel:
+ logger.warning(f"JS Console: {message}")
+ logger.debug(f" at {source_id}:{line_number}")
+ else: # ErrorMessageLevel
+ logger.error(f"JS Console: {message}")
+ logger.debug(f" at {source_id}:{line_number}")
+
+ def _on_page_loaded(self, success: bool) -> None:
+ """Called when a page finishes loading.
+
+ Checks if the bridge script was successfully injected.
+
+ Args:
+ success: True if page loaded successfully
+ """
+ if not success:
+ logger.warning("Page failed to load")
+ return
+
+ # Check if bridge script is loaded
+ def check_script(result):
+ if result:
+ logger.debug("WebDrop Bridge script is active")
+ logger.debug("QWebChannel bridge is ready")
+ else:
+ logger.error("WebDrop Bridge script NOT loaded!")
+ logger.error("Drag-and-drop conversion will not work")
+
+ # Execute JS to check if our script is loaded
+ self.web_view.page().runJavaScript(
+ "typeof window.__webdrop_bridge_injected !== 'undefined' && window.__webdrop_bridge_injected === true",
+ check_script
+ )
def _create_navigation_toolbar(self) -> None:
"""Create navigation toolbar with Home, Back, Forward, Refresh buttons.
@@ -488,7 +1061,7 @@ class MainWindow(QMainWindow):
Args:
status: Status text to display
- emoji: Optional emoji prefix (🔄, ✅, ⬇️, ⚠️)
+ emoji: Optional emoji prefix (rotating, checkmark, download, warning symbols)
"""
if emoji:
self.update_status_label.setText(f"{emoji} {status}")
@@ -553,30 +1126,40 @@ class MainWindow(QMainWindow):
def closeEvent(self, event) -> None:
"""Handle window close event.
+ Properly cleanup WebEnginePage before closing to avoid
+ "Release of profile requested but WebEnginePage still not deleted" warning.
+ This ensures session data (cookies, login state) is properly saved.
+
Args:
event: Close event
"""
- # Can be extended with save operations or cleanup
+ logger.debug("Closing application - cleaning up web engine resources")
+
+ # Properly delete WebEnginePage before the profile is released
+ # This ensures cookies and session data are saved correctly
+ if hasattr(self, 'web_view') and self.web_view:
+ page = self.web_view.page()
+ if page:
+ # Disconnect signals to prevent callbacks during shutdown
+ try:
+ page.loadFinished.disconnect()
+ except RuntimeError:
+ pass # Already disconnected or never connected
+
+ # Delete the page explicitly
+ page.deleteLater()
+ logger.debug("WebEnginePage scheduled for deletion")
+
+ # Clear the page from the view
+ self.web_view.setPage(None) # type: ignore
+
event.accept()
- def initiate_drag(self, file_paths: list) -> bool:
- """Initiate a drag operation for the given files.
-
- Called from web content via JavaScript bridge.
-
- Args:
- file_paths: List of file paths to drag
-
- Returns:
- True if drag was initiated successfully
- """
- return self.drag_interceptor.initiate_drag(file_paths)
-
def check_for_updates_startup(self) -> None:
"""Check for updates on application startup.
Runs asynchronously in background without blocking UI.
- Uses 24h cache so won't hammer the API.
+ Uses 24-hour cache so will not hammer the API.
"""
from webdrop_bridge.core.updater import UpdateManager
diff --git a/src/webdrop_bridge/ui/restricted_web_view.py b/src/webdrop_bridge/ui/restricted_web_view.py
index d7b28cc..bd77741 100644
--- a/src/webdrop_bridge/ui/restricted_web_view.py
+++ b/src/webdrop_bridge/ui/restricted_web_view.py
@@ -1,13 +1,106 @@
"""Restricted web view with URL whitelist enforcement for Kiosk-mode."""
import fnmatch
-from typing import List, Optional
+import logging
+from pathlib import Path
+from typing import List, Optional, Union
-from PySide6.QtCore import QUrl
+from PySide6.QtCore import QStandardPaths, QUrl
from PySide6.QtGui import QDesktopServices
-from PySide6.QtWebEngineCore import QWebEngineNavigationRequest
+from PySide6.QtWebEngineCore import QWebEngineNavigationRequest, QWebEnginePage, QWebEngineProfile
from PySide6.QtWebEngineWidgets import QWebEngineView
+logger = logging.getLogger(__name__)
+
+
+logger = logging.getLogger(__name__)
+
+
+class CustomWebEnginePage(QWebEnginePage):
+ """Custom page that handles new window requests for downloads."""
+
+ def acceptNavigationRequest(
+ self, url: Union[QUrl, str], nav_type: QWebEnginePage.NavigationType, is_main_frame: bool
+ ) -> bool:
+ """Handle navigation requests, including download links.
+
+ Args:
+ url: Target URL (QUrl or string)
+ nav_type: Type of navigation (link click, form submit, etc.)
+ is_main_frame: Whether this is the main frame
+
+ Returns:
+ True to accept navigation, False to reject
+ """
+ # Convert to string if QUrl
+ url_str = url.toString() if isinstance(url, QUrl) else url
+
+ # Log all navigation attempts for debugging
+ logger.debug(f"Navigation request: {url_str} (type={nav_type}, main_frame={is_main_frame})")
+
+ # Check if this might be a download (common file extensions)
+ download_extensions = [
+ ".pdf",
+ ".zip",
+ ".rar",
+ ".7z",
+ ".tar",
+ ".gz",
+ ".doc",
+ ".docx",
+ ".xls",
+ ".xlsx",
+ ".ppt",
+ ".pptx",
+ ".jpg",
+ ".jpeg",
+ ".png",
+ ".gif",
+ ".bmp",
+ ".svg",
+ ".mp4",
+ ".mp3",
+ ".avi",
+ ".mov",
+ ".wav",
+ ".exe",
+ ".msi",
+ ".dmg",
+ ".pkg",
+ ".csv",
+ ".txt",
+ ".json",
+ ".xml",
+ ]
+
+ if any(url_str.lower().endswith(ext) for ext in download_extensions):
+ logger.debug(f"Detected potential download URL: {url_str}")
+ # This will trigger downloadRequested if it's a download
+
+ return super().acceptNavigationRequest(url, nav_type, is_main_frame)
+
+ def createWindow(self, window_type: QWebEnginePage.WebWindowType) -> QWebEnginePage:
+ """Handle new window requests (target=_blank, window.open, etc.).
+
+ Many downloads are triggered via target="_blank" links.
+
+ Args:
+ window_type: Type of window being created
+
+ Returns:
+ New page instance for the window
+ """
+ logger.debug(f"New window requested, type: {window_type}")
+
+ # Create a temporary page to handle the download
+ # This page will never be displayed but allows downloads to work
+ download_page = QWebEnginePage(self.profile(), self)
+
+ logger.debug("Created temporary page for download/popup")
+
+ # Return the temporary page - it will trigger downloadRequested if it's a download
+ return download_page
+
class RestrictedWebEngineView(QWebEngineView):
"""Web view that enforces URL whitelist for Kiosk-mode security.
@@ -27,31 +120,82 @@ class RestrictedWebEngineView(QWebEngineView):
super().__init__()
self.allowed_urls = allowed_urls or []
+ # Create persistent profile for cookie and session storage
+ self.profile = self._create_persistent_profile()
+
+ # Use custom page for better download handling with persistent profile
+ custom_page = CustomWebEnginePage(self.profile, self)
+ self.setPage(custom_page)
+
+ logger.debug(
+ "RestrictedWebEngineView initialized with CustomWebEnginePage and persistent profile"
+ )
+
# Connect to navigation request handler
self.page().navigationRequested.connect(self._on_navigation_requested)
- def _on_navigation_requested(
- self, request: QWebEngineNavigationRequest
- ) -> None:
+ def _create_persistent_profile(self) -> QWebEngineProfile:
+ """Create and configure a persistent web engine profile.
+
+ This enables persistent cookies and cache storage, allowing
+ authentication sessions (e.g., Microsoft login) to persist
+ across application restarts.
+
+ Returns:
+ Configured QWebEngineProfile with persistent storage
+ """
+ # Get application data directory
+ app_data_dir = QStandardPaths.writableLocation(
+ QStandardPaths.StandardLocation.AppDataLocation
+ )
+
+ # Create profile directory path
+ profile_path = Path(app_data_dir) / "WebEngineProfile"
+ profile_path.mkdir(parents=True, exist_ok=True)
+
+ # Create persistent profile with custom storage location
+ # Using "WebDropBridge" as the profile name
+ # Note: No parent specified so we control the lifecycle
+ profile = QWebEngineProfile("WebDropBridge")
+ profile.setPersistentStoragePath(str(profile_path))
+
+ # Configure persistent cookies (critical for authentication)
+ profile.setPersistentCookiesPolicy(
+ QWebEngineProfile.PersistentCookiesPolicy.ForcePersistentCookies
+ )
+
+ # Enable HTTP cache for better performance
+ profile.setHttpCacheType(QWebEngineProfile.HttpCacheType.DiskHttpCache)
+
+ # Set cache size to 100 MB
+ profile.setHttpCacheMaximumSize(100 * 1024 * 1024)
+
+ logger.debug(f"Created persistent profile at: {profile_path}")
+ logger.debug("Cookies policy: ForcePersistentCookies")
+ logger.debug("HTTP cache: DiskHttpCache (100 MB)")
+
+ return profile
+
+ def _on_navigation_requested(self, request: QWebEngineNavigationRequest) -> None:
"""Handle navigation requests and enforce URL whitelist.
Args:
request: Navigation request to process
"""
- url = request.url
+ url = request.url()
# If no restrictions, allow all URLs
if not self.allowed_urls:
return
# Check if URL matches whitelist
- if self._is_url_allowed(url): # type: ignore[operator]
+ if self._is_url_allowed(url):
# Allow the navigation (default behavior)
return
# URL not whitelisted - open in system browser
request.reject()
- QDesktopServices.openUrl(url) # type: ignore[operator]
+ QDesktopServices.openUrl(url)
def _is_url_allowed(self, url: QUrl) -> bool:
"""Check if a URL matches the whitelist.
@@ -98,4 +242,3 @@ class RestrictedWebEngineView(QWebEngineView):
return True
return False
-
diff --git a/test_output.txt b/test_output.txt
deleted file mode 100644
index 8b4e01c..0000000
Binary files a/test_output.txt and /dev/null differ
diff --git a/test_results.txt b/test_results.txt
deleted file mode 100644
index 06d8d28..0000000
Binary files a/test_results.txt and /dev/null differ
diff --git a/test_timeout_handling.py b/test_timeout_handling.py
deleted file mode 100644
index 6a6d6b2..0000000
--- a/test_timeout_handling.py
+++ /dev/null
@@ -1,107 +0,0 @@
-#!/usr/bin/env python
-"""Test timeout handling in update feature."""
-
-import asyncio
-import logging
-from pathlib import Path
-from unittest.mock import AsyncMock, Mock, patch
-
-from webdrop_bridge.core.updater import UpdateManager
-from webdrop_bridge.ui.main_window import UpdateCheckWorker, UpdateDownloadWorker
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-print("\n" + "="*70)
-print("TIMEOUT HANDLING VERIFICATION")
-print("="*70 + "\n")
-
-# Test 1: UpdateCheckWorker handles timeout
-print("Test 1: UpdateCheckWorker handles network timeout gracefully")
-print("-" * 70)
-
-async def test_check_timeout():
- """Test that check_for_updates respects timeout."""
- manager = Mock(spec=UpdateManager)
-
- # Simulate a timeout
- async def slow_check():
- await asyncio.sleep(20) # Longer than 15-second timeout
- return None
-
- manager.check_for_updates = slow_check
-
- # This should timeout after 15 seconds
- try:
- result = await asyncio.wait_for(manager.check_for_updates(), timeout=15)
- print("❌ Should have timed out!")
- return False
- except asyncio.TimeoutError:
- print("✓ Correctly timed out after 15 seconds")
- print("✓ User gets 'Ready' status and app doesn't hang")
- return True
-
-result1 = asyncio.run(test_check_timeout())
-
-# Test 2: UpdateDownloadWorker handles timeout
-print("\nTest 2: UpdateDownloadWorker handles network timeout gracefully")
-print("-" * 70)
-
-async def test_download_timeout():
- """Test that download respects timeout."""
- manager = Mock(spec=UpdateManager)
-
- # Simulate a timeout
- async def slow_download(release):
- await asyncio.sleep(400) # Longer than 300-second timeout
- return None
-
- manager.download_update = slow_download
-
- # This should timeout after 300 seconds
- try:
- result = await asyncio.wait_for(manager.download_update(None), timeout=300)
- print("❌ Should have timed out!")
- return False
- except asyncio.TimeoutError:
- print("✓ Correctly timed out after 300 seconds")
- print("✓ User gets 'Operation timed out' error message")
- print("✓ App shows specific timeout error instead of hanging")
- return True
-
-result2 = asyncio.run(test_download_timeout())
-
-# Test 3: Verify error messages
-print("\nTest 3: Timeout errors show helpful messages")
-print("-" * 70)
-
-messages = [
- ("Update check timed out", "Update check timeout produces helpful message"),
- ("Download or verification timed out", "Download timeout produces helpful message"),
- ("no response from server", "Error explains what happened (no server response)"),
-]
-
-all_good = True
-for msg, description in messages:
- print(f"✓ {description}")
- print(f" → Message: '{msg}'")
-
-result3 = True
-
-# Summary
-print("\n" + "="*70)
-if result1 and result2 and result3:
- print("✅ TIMEOUT HANDLING WORKS CORRECTLY!")
- print("="*70)
- print("\nThe update feature now:")
- print(" 1. Has 15-second timeout for update checks")
- print(" 2. Has 300-second timeout for download operations")
- print(" 3. Has 30-second timeout for checksum verification")
- print(" 4. Shows helpful error messages when timeouts occur")
- print(" 5. Prevents the application from hanging indefinitely")
- print(" 6. Allows user to retry or cancel")
-else:
- print("❌ SOME TESTS FAILED")
- print("="*70)
-
-print()
diff --git a/test_update_no_hang.py b/test_update_no_hang.py
deleted file mode 100644
index b98f23a..0000000
--- a/test_update_no_hang.py
+++ /dev/null
@@ -1,198 +0,0 @@
-#!/usr/bin/env python
-"""Test script to verify the update feature no longer hangs the UI.
-
-This script demonstrates that the update download happens in a background
-thread and doesn't block the UI thread.
-"""
-
-import asyncio
-import logging
-from pathlib import Path
-from unittest.mock import MagicMock, Mock, patch
-
-from PySide6.QtCore import QCoreApplication, QThread, QTimer
-
-from webdrop_bridge.config import Config
-from webdrop_bridge.core.updater import Release, UpdateManager
-from webdrop_bridge.ui.main_window import MainWindow, UpdateDownloadWorker
-
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-
-
-def test_update_download_runs_in_background():
- """Verify that update download runs in a background thread."""
- print("\n=== Testing Update Download Background Thread ===\n")
-
- app = QCoreApplication.instance() or QCoreApplication([])
-
- # Create a mock release
- release = Release(
- tag_name="v0.0.2",
- name="Release 0.0.2",
- version="0.0.2",
- body="Test release notes",
- assets=[{"name": "installer.msi", "browser_download_url": "http://example.com/installer.msi"}],
- published_at="2026-01-30T00:00:00Z"
- )
-
- # Create a mock update manager
- manager = Mock(spec=UpdateManager)
-
- # Track if download_update was called
- download_called = False
- download_thread_id = None
-
- async def mock_download(rel):
- nonlocal download_called, download_thread_id
- download_called = True
- download_thread_id = QThread.currentThreadId()
- # Simulate network operation
- await asyncio.sleep(0.1)
- return Path("/tmp/fake_installer.msi")
-
- async def mock_verify(file_path, rel):
- nonlocal download_thread_id
- await asyncio.sleep(0.1)
- return True
-
- manager.download_update = mock_download
- manager.verify_checksum = mock_verify
-
- # Create the worker
- worker = UpdateDownloadWorker(manager, release, "0.0.1")
-
- # Track signals
- signals_emitted = []
- worker.download_complete.connect(lambda p: signals_emitted.append(("complete", p)))
- worker.download_failed.connect(lambda e: signals_emitted.append(("failed", e)))
- worker.finished.connect(lambda: signals_emitted.append(("finished",)))
-
- # Create a thread and move worker to it
- thread = QThread()
- worker.moveToThread(thread)
-
- # Track if worker runs in different thread
- main_thread_id = QThread.currentThreadId()
- worker_thread_id = None
-
- def on_worker_run_started():
- nonlocal worker_thread_id
- worker_thread_id = QThread.currentThreadId()
- logger.info(f"Worker running in thread: {worker_thread_id}")
- logger.info(f"Main thread: {main_thread_id}")
-
- thread.started.connect(on_worker_run_started)
- thread.started.connect(worker.run)
-
- # Start the thread and process events until done
- thread.start()
-
- # Wait for completion with timeout
- start_time = asyncio.get_event_loop().time() if hasattr(asyncio.get_event_loop(), 'time') else 0
- while not download_called and len(signals_emitted) < 3:
- app.processEvents()
- QTimer.singleShot(10, app.quit)
- app.exec()
- if len(signals_emitted) >= 3:
- break
-
- # Cleanup
- thread.quit()
- thread.wait()
-
- # Verify results
- print(f"\n✓ Download called: {download_called}")
- print(f"✓ Signals emitted: {len(signals_emitted)}")
-
- # Check if completion signal was emitted (shows async operations completed)
- has_complete_or_failed = any(sig[0] in ("complete", "failed") for sig in signals_emitted)
- has_finished = any(sig[0] == "finished" for sig in signals_emitted)
-
- print(f"✓ Completion/Failed signal emitted: {has_complete_or_failed}")
- print(f"✓ Finished signal emitted: {has_finished}")
-
- if has_complete_or_failed and has_finished:
- print("\n✅ SUCCESS: Update download runs asynchronously without blocking UI!")
- return True
- else:
- print("\n❌ FAILED: Signals not emitted properly")
- print(f" Signals: {signals_emitted}")
- return False
-
-
-def test_update_download_worker_exists():
- """Verify that UpdateDownloadWorker class exists and has correct signals."""
- print("\n=== Testing UpdateDownloadWorker Class ===\n")
-
- # Check class exists
- assert hasattr(UpdateDownloadWorker, '__init__'), "UpdateDownloadWorker missing __init__"
- print("✓ UpdateDownloadWorker class exists")
-
- # Check signals
- required_signals = ['download_complete', 'download_failed', 'update_status', 'finished']
- for signal_name in required_signals:
- assert hasattr(UpdateDownloadWorker, signal_name), f"Missing signal: {signal_name}"
- print(f"✓ Signal '{signal_name}' defined")
-
- # Check methods
- assert hasattr(UpdateDownloadWorker, 'run'), "UpdateDownloadWorker missing run method"
- print("✓ Method 'run' defined")
-
- print("\n✅ SUCCESS: UpdateDownloadWorker properly implemented!")
- return True
-
-
-def test_main_window_uses_async_download():
- """Verify that MainWindow uses async download instead of blocking."""
- print("\n=== Testing MainWindow Async Download Integration ===\n")
-
- # Check that _perform_update_async exists (new async version)
- assert hasattr(MainWindow, '_perform_update_async'), "MainWindow missing _perform_update_async"
- print("✓ Method '_perform_update_async' exists (new async version)")
-
- # Check that old blocking _perform_update is gone
- assert not hasattr(MainWindow, '_perform_update'), \
- "MainWindow still has old blocking _perform_update method"
- print("✓ Old blocking '_perform_update' method removed")
-
- # Check download/failed handlers exist
- assert hasattr(MainWindow, '_on_download_complete'), "MainWindow missing _on_download_complete"
- assert hasattr(MainWindow, '_on_download_failed'), "MainWindow missing _on_download_failed"
- print("✓ Download completion handlers exist")
-
- print("\n✅ SUCCESS: MainWindow properly integrated with async download!")
- return True
-
-
-if __name__ == "__main__":
- print("\n" + "="*60)
- print("UPDATE FEATURE FIX VERIFICATION")
- print("="*60)
-
- try:
- # Test 1: Worker exists
- test1 = test_update_download_worker_exists()
-
- # Test 2: MainWindow integration
- test2 = test_main_window_uses_async_download()
-
- # Test 3: Async operation
- test3 = test_update_download_runs_in_background()
-
- print("\n" + "="*60)
- if test1 and test2 and test3:
- print("✅ ALL TESTS PASSED - UPDATE FEATURE HANG FIXED!")
- print("="*60 + "\n")
- print("Summary of changes:")
- print("- Created UpdateDownloadWorker class for async downloads")
- print("- Moved blocking operations from UI thread to background thread")
- print("- Added handlers for download completion/failure")
- print("- UI now stays responsive during update download")
- else:
- print("❌ SOME TESTS FAILED")
- print("="*60 + "\n")
- except Exception as e:
- print(f"\n❌ ERROR: {e}")
- import traceback
- traceback.print_exc()
diff --git a/tests/unit/test_config.py b/tests/unit/test_config.py
index c8f569f..d20de67 100644
--- a/tests/unit/test_config.py
+++ b/tests/unit/test_config.py
@@ -98,12 +98,13 @@ class TestConfigFromEnv:
Config.from_env(str(env_file))
def test_from_env_invalid_root_path(self, tmp_path):
- """Test that non-existent root paths raise ConfigurationError."""
+ """Test that non-existent root paths are logged as warning but don't raise error."""
env_file = tmp_path / ".env"
env_file.write_text("ALLOWED_ROOTS=/nonexistent/path/that/does/not/exist\n")
- with pytest.raises(ConfigurationError, match="does not exist"):
- Config.from_env(str(env_file))
+ # Should not raise - just logs warning and returns empty allowed_roots
+ config = Config.from_env(str(env_file))
+ assert config.allowed_roots == [] # Non-existent roots are skipped
def test_from_env_empty_webapp_url(self, tmp_path):
"""Test that empty webapp URL raises ConfigurationError."""
diff --git a/tests/unit/test_drag_interceptor.py b/tests/unit/test_drag_interceptor.py
index d94fb23..eaa5ce4 100644
--- a/tests/unit/test_drag_interceptor.py
+++ b/tests/unit/test_drag_interceptor.py
@@ -3,63 +3,79 @@
from pathlib import Path
from unittest.mock import MagicMock, patch
+import pytest
+
+from webdrop_bridge.config import Config
from webdrop_bridge.core.drag_interceptor import DragInterceptor
-from webdrop_bridge.core.validator import PathValidator
+
+
+@pytest.fixture
+def test_config(tmp_path):
+ """Create test configuration."""
+ return Config(
+ app_name="Test App",
+ app_version="1.0.0",
+ log_level="INFO",
+ log_file=None,
+ allowed_roots=[tmp_path],
+ allowed_urls=[],
+ webapp_url="https://wps.agravity.io/",
+ url_mappings=[],
+ check_file_exists=True,
+ )
class TestDragInterceptorInitialization:
"""Test DragInterceptor initialization and setup."""
- def test_drag_interceptor_creation(self, qtbot):
+ def test_drag_interceptor_creation(self, qtbot, test_config):
"""Test DragInterceptor can be instantiated."""
- interceptor = DragInterceptor()
+ interceptor = DragInterceptor(test_config)
assert interceptor is not None
- assert interceptor._validator is None
+ assert interceptor._validator is not None
+ assert interceptor._url_converter is not None
- def test_drag_interceptor_has_signals(self, qtbot):
+ def test_drag_interceptor_has_signals(self, qtbot, test_config):
"""Test DragInterceptor has required signals."""
- interceptor = DragInterceptor()
+ interceptor = DragInterceptor(test_config)
assert hasattr(interceptor, "drag_started")
assert hasattr(interceptor, "drag_failed")
- def test_set_validator(self, qtbot, tmp_path):
- """Test setting validator on drag interceptor."""
- interceptor = DragInterceptor()
- validator = PathValidator([tmp_path])
-
- interceptor.set_validator(validator)
-
- assert interceptor._validator is validator
+ def test_set_validator(self, qtbot, test_config):
+ """Test validator is set during construction."""
+ interceptor = DragInterceptor(test_config)
+ assert interceptor._validator is not None
class TestDragInterceptorValidation:
"""Test path validation in drag operations."""
- def test_initiate_drag_no_files(self, qtbot):
- """Test initiating drag with no files fails."""
- interceptor = DragInterceptor()
+ def test_handle_drag_empty_text(self, qtbot, test_config):
+ """Test handling drag with empty text fails."""
+ interceptor = DragInterceptor(test_config)
with qtbot.waitSignal(interceptor.drag_failed):
- result = interceptor.initiate_drag([])
+ result = interceptor.handle_drag("")
assert result is False
- def test_initiate_drag_no_validator(self, qtbot):
- """Test initiating drag without validator fails."""
- interceptor = DragInterceptor()
- with qtbot.waitSignal(interceptor.drag_failed):
- result = interceptor.initiate_drag(["file.txt"])
-
- assert result is False
-
- def test_initiate_drag_single_valid_file(self, qtbot, tmp_path):
- """Test initiating drag with single valid file."""
+ def test_handle_drag_valid_file_path(self, qtbot, tmp_path):
+ """Test handling drag with valid file path."""
# Create a test file
test_file = tmp_path / "test.txt"
test_file.write_text("test content")
- interceptor = DragInterceptor()
- validator = PathValidator([tmp_path])
- interceptor.set_validator(validator)
+ config = Config(
+ app_name="Test",
+ app_version="1.0.0",
+ log_level="INFO",
+ log_file=None,
+ allowed_roots=[tmp_path],
+ allowed_urls=[],
+ webapp_url="https://test.com/",
+ url_mappings=[],
+ check_file_exists=True,
+ )
+ interceptor = DragInterceptor(config)
# Mock the drag operation to simulate success
with patch("webdrop_bridge.core.drag_interceptor.QDrag") as mock_drag:
@@ -69,114 +85,91 @@ class TestDragInterceptorValidation:
mock_drag_instance.exec.return_value = Qt.DropAction.CopyAction
mock_drag.return_value = mock_drag_instance
- result = interceptor.initiate_drag([str(test_file)])
+ result = interceptor.handle_drag(str(test_file))
# Should return True on successful drag
assert result is True
- def test_initiate_drag_invalid_path(self, qtbot, tmp_path):
+ def test_handle_drag_invalid_path(self, qtbot, test_config):
"""Test drag with invalid path fails."""
- interceptor = DragInterceptor()
- validator = PathValidator([tmp_path])
- interceptor.set_validator(validator)
+ interceptor = DragInterceptor(test_config)
# Path outside allowed roots
- invalid_path = Path("/etc/passwd")
+ invalid_path = "/etc/passwd"
with qtbot.waitSignal(interceptor.drag_failed):
- result = interceptor.initiate_drag([str(invalid_path)])
+ result = interceptor.handle_drag(invalid_path)
assert result is False
- def test_initiate_drag_nonexistent_file(self, qtbot, tmp_path):
+ def test_handle_drag_nonexistent_file(self, qtbot, test_config, tmp_path):
"""Test drag with nonexistent file fails."""
- interceptor = DragInterceptor()
- validator = PathValidator([tmp_path])
- interceptor.set_validator(validator)
+ interceptor = DragInterceptor(test_config)
nonexistent = tmp_path / "nonexistent.txt"
with qtbot.waitSignal(interceptor.drag_failed):
- result = interceptor.initiate_drag([str(nonexistent)])
+ result = interceptor.handle_drag(str(nonexistent))
assert result is False
-class TestDragInterceptorMultipleFiles:
- """Test drag operations with multiple files."""
+class TestDragInterceptorAzureURL:
+ """Test Azure URL to local path conversion in drag operations."""
- def test_initiate_drag_multiple_files(self, qtbot, tmp_path):
- """Test drag with multiple valid files."""
- # Create test files
- file1 = tmp_path / "file1.txt"
- file2 = tmp_path / "file2.txt"
- file1.write_text("content 1")
- file2.write_text("content 2")
+ def test_handle_drag_azure_url(self, qtbot, tmp_path):
+ """Test handling drag with Azure Blob Storage URL."""
+ from webdrop_bridge.config import URLMapping
- interceptor = DragInterceptor()
- validator = PathValidator([tmp_path])
- interceptor.set_validator(validator)
+ # Create test file that would be the result
+ test_file = tmp_path / "test.png"
+ test_file.write_text("image data")
- from PySide6.QtCore import Qt
+ config = Config(
+ app_name="Test",
+ app_version="1.0.0",
+ log_level="INFO",
+ log_file=None,
+ allowed_roots=[tmp_path],
+ allowed_urls=[],
+ webapp_url="https://test.com/",
+ url_mappings=[
+ URLMapping(
+ url_prefix="https://wpsagravitystg.file.core.windows.net/wpsagravitysync/",
+ local_path=str(tmp_path)
+ )
+ ],
+ check_file_exists=True,
+ )
+ interceptor = DragInterceptor(config)
+
+ # Azure URL
+ azure_url = "https://wpsagravitystg.file.core.windows.net/wpsagravitysync/test.png"
+
+ # Mock the drag operation
with patch("webdrop_bridge.core.drag_interceptor.QDrag") as mock_drag:
mock_drag_instance = MagicMock()
+ from PySide6.QtCore import Qt
mock_drag_instance.exec.return_value = Qt.DropAction.CopyAction
mock_drag.return_value = mock_drag_instance
- result = interceptor.initiate_drag([str(file1), str(file2)])
+ result = interceptor.handle_drag(azure_url)
assert result is True
- def test_initiate_drag_mixed_valid_invalid(self, qtbot, tmp_path):
- """Test drag with mix of valid and invalid paths fails."""
- test_file = tmp_path / "valid.txt"
- test_file.write_text("content")
+ def test_handle_drag_unmapped_url(self, qtbot, test_config):
+ """Test handling drag with unmapped URL fails."""
+ interceptor = DragInterceptor(test_config)
- interceptor = DragInterceptor()
- validator = PathValidator([tmp_path])
- interceptor.set_validator(validator)
+ # URL with no mapping
+ unmapped_url = "https://unknown.blob.core.windows.net/container/file.png"
- # Mix of valid and invalid paths
with qtbot.waitSignal(interceptor.drag_failed):
- result = interceptor.initiate_drag(
- [str(test_file), "/etc/passwd"]
- )
+ result = interceptor.handle_drag(unmapped_url)
assert result is False
-class TestDragInterceptorMimeData:
- """Test MIME data creation and file URL formatting."""
-
- def test_mime_data_creation(self, qtbot, tmp_path):
- """Test MIME data is created with proper file URLs."""
- test_file = tmp_path / "test.txt"
- test_file.write_text("test")
-
- interceptor = DragInterceptor()
- validator = PathValidator([tmp_path])
- interceptor.set_validator(validator)
-
- from PySide6.QtCore import Qt
- with patch("webdrop_bridge.core.drag_interceptor.QDrag") as mock_drag:
- mock_drag_instance = MagicMock()
- mock_drag_instance.exec.return_value = Qt.DropAction.CopyAction
- mock_drag.return_value = mock_drag_instance
-
- interceptor.initiate_drag([str(test_file)])
-
- # Check MIME data was set correctly
- call_args = mock_drag_instance.setMimeData.call_args
- mime_data = call_args[0][0]
-
- # Verify URLs were set
- urls = mime_data.urls()
- assert len(urls) == 1
- # Check that the URL contains file:// scheme (can be string repr or QUrl)
- url_str = str(urls[0]).lower()
- assert "file://" in url_str
-
-
class TestDragInterceptorSignals:
"""Test signal emission on drag operations."""
@@ -185,153 +178,60 @@ class TestDragInterceptorSignals:
test_file = tmp_path / "test.txt"
test_file.write_text("content")
- interceptor = DragInterceptor()
- validator = PathValidator([tmp_path])
- interceptor.set_validator(validator)
-
- from PySide6.QtCore import Qt
+ config = Config(
+ app_name="Test",
+ app_version="1.0.0",
+ log_level="INFO",
+ log_file=None,
+ allowed_roots=[tmp_path],
+ allowed_urls=[],
+ webapp_url="https://test.com/",
+ url_mappings=[],
+ check_file_exists=True,
+ )
+ interceptor = DragInterceptor(config)
# Connect to signal manually
signal_spy = []
- interceptor.drag_started.connect(lambda paths: signal_spy.append(paths))
+ interceptor.drag_started.connect(lambda src, path: signal_spy.append((src, path)))
+ from PySide6.QtCore import Qt
with patch("webdrop_bridge.core.drag_interceptor.QDrag") as mock_drag:
mock_drag_instance = MagicMock()
mock_drag_instance.exec.return_value = Qt.DropAction.CopyAction
mock_drag.return_value = mock_drag_instance
- result = interceptor.initiate_drag([str(test_file)])
+ result = interceptor.handle_drag(str(test_file))
# Verify result and signal emission
assert result is True
assert len(signal_spy) == 1
- def test_drag_failed_signal_on_no_files(self, qtbot):
- """Test drag_failed signal on empty file list."""
- interceptor = DragInterceptor()
+ def test_drag_failed_signal_on_empty_text(self, qtbot, test_config):
+ """Test drag_failed signal on empty text."""
+ interceptor = DragInterceptor(test_config)
# Connect to signal manually
signal_spy = []
- interceptor.drag_failed.connect(lambda msg: signal_spy.append(msg))
+ interceptor.drag_failed.connect(lambda src, msg: signal_spy.append((src, msg)))
- result = interceptor.initiate_drag([])
+ result = interceptor.handle_drag("")
# Verify result and signal emission
assert result is False
assert len(signal_spy) == 1
- assert "No files" in signal_spy[0]
+ assert "Empty" in signal_spy[0][1]
- def test_drag_failed_signal_on_validation_error(self, qtbot, tmp_path):
+ def test_drag_failed_signal_on_validation_error(self, qtbot, test_config):
"""Test drag_failed signal on validation failure."""
- interceptor = DragInterceptor()
- validator = PathValidator([tmp_path])
- interceptor.set_validator(validator)
+ interceptor = DragInterceptor(test_config)
# Connect to signal manually
signal_spy = []
- interceptor.drag_failed.connect(lambda msg: signal_spy.append(msg))
+ interceptor.drag_failed.connect(lambda src, msg: signal_spy.append((src, msg)))
- result = interceptor.initiate_drag(["/invalid/path/file.txt"])
+ result = interceptor.handle_drag("/invalid/path/file.txt")
# Verify result and signal emission
assert result is False
assert len(signal_spy) == 1
-
-
-class TestDragInterceptorDragExecution:
- """Test drag operation execution and result handling."""
-
- def test_drag_cancelled_returns_false(self, qtbot, tmp_path):
- """Test drag cancellation returns False."""
- test_file = tmp_path / "test.txt"
- test_file.write_text("content")
-
- interceptor = DragInterceptor()
- validator = PathValidator([tmp_path])
- interceptor.set_validator(validator)
-
- with patch("webdrop_bridge.core.drag_interceptor.QDrag") as mock_drag:
- mock_drag_instance = MagicMock()
- mock_drag_instance.exec.return_value = 0 # Cancelled/failed
- mock_drag.return_value = mock_drag_instance
-
- # Connect to signal manually
- signal_spy = []
- interceptor.drag_failed.connect(lambda msg: signal_spy.append(msg))
-
- result = interceptor.initiate_drag([str(test_file)])
-
- assert result is False
- assert len(signal_spy) == 1
-
- def test_pixmap_created_from_widget(self, qtbot, tmp_path):
- """Test pixmap is created from widget grab."""
- test_file = tmp_path / "test.txt"
- test_file.write_text("content")
-
- interceptor = DragInterceptor()
- validator = PathValidator([tmp_path])
- interceptor.set_validator(validator)
-
- from PySide6.QtCore import Qt
- with patch.object(interceptor, "grab") as mock_grab:
- mock_pixmap = MagicMock()
- mock_grab.return_value.scaled.return_value = mock_pixmap
-
- with patch("webdrop_bridge.core.drag_interceptor.QDrag") as mock_drag:
- mock_drag_instance = MagicMock()
- mock_drag_instance.exec.return_value = Qt.DropAction.CopyAction
- mock_drag.return_value = mock_drag_instance
-
- interceptor.initiate_drag([str(test_file)])
-
- # Verify grab was called and pixmap was set
- mock_grab.assert_called_once()
- mock_drag_instance.setPixmap.assert_called_once_with(mock_pixmap)
-
-
-class TestDragInterceptorIntegration:
- """Integration tests with PathValidator."""
-
- def test_drag_with_nested_file(self, qtbot, tmp_path):
- """Test drag with file in nested directory."""
- nested_dir = tmp_path / "nested" / "dir"
- nested_dir.mkdir(parents=True)
- test_file = nested_dir / "file.txt"
- test_file.write_text("nested content")
-
- interceptor = DragInterceptor()
- validator = PathValidator([tmp_path])
- interceptor.set_validator(validator)
-
- from PySide6.QtCore import Qt
- with patch("webdrop_bridge.core.drag_interceptor.QDrag") as mock_drag:
- mock_drag_instance = MagicMock()
- mock_drag_instance.exec.return_value = Qt.DropAction.CopyAction
- mock_drag.return_value = mock_drag_instance
-
- result = interceptor.initiate_drag([str(test_file)])
-
- assert result is True
-
- def test_drag_with_relative_path(self, qtbot, tmp_path):
- """Test drag with relative path resolution."""
- test_file = tmp_path / "relative.txt"
- test_file.write_text("content")
-
- interceptor = DragInterceptor()
- validator = PathValidator([tmp_path])
- interceptor.set_validator(validator)
-
- # This would work if run from the directory, but we'll just verify
- # the interceptor handles Path objects correctly
- from PySide6.QtCore import Qt
- with patch("webdrop_bridge.core.drag_interceptor.QDrag") as mock_drag:
- mock_drag_instance = MagicMock()
- mock_drag_instance.exec.return_value = Qt.DropAction.CopyAction
- mock_drag.return_value = mock_drag_instance
-
- # Direct absolute path for reliable test
- result = interceptor.initiate_drag([str(test_file)])
-
- assert result is True
diff --git a/tests/unit/test_main_window.py b/tests/unit/test_main_window.py
index 75216e0..72a53d3 100644
--- a/tests/unit/test_main_window.py
+++ b/tests/unit/test_main_window.py
@@ -231,10 +231,12 @@ class TestMainWindowDragIntegration:
assert window.drag_interceptor.drag_started is not None
assert window.drag_interceptor.drag_failed is not None
- def test_initiate_drag_delegates_to_interceptor(
+ def test_handle_drag_delegates_to_interceptor(
self, qtbot, sample_config, tmp_path
):
- """Test initiate_drag method delegates to interceptor."""
+ """Test drag handling delegates to interceptor."""
+ from PySide6.QtCore import QCoreApplication
+
window = MainWindow(sample_config)
qtbot.addWidget(window)
@@ -243,29 +245,32 @@ class TestMainWindowDragIntegration:
test_file.write_text("test")
with patch.object(
- window.drag_interceptor, "initiate_drag"
+ window.drag_interceptor, "handle_drag"
) as mock_drag:
mock_drag.return_value = True
- result = window.initiate_drag([str(test_file)])
+ # Call through bridge
+ window._drag_bridge.start_file_drag(str(test_file))
+
+ # Process deferred QTimer.singleShot(0, ...) call
+ QCoreApplication.processEvents()
- mock_drag.assert_called_once_with([str(test_file)])
- assert result is True
+ mock_drag.assert_called_once_with(str(test_file))
def test_on_drag_started_called(self, qtbot, sample_config):
"""Test _on_drag_started handler can be called."""
window = MainWindow(sample_config)
qtbot.addWidget(window)
- # Should not raise
- window._on_drag_started(["/some/path"])
+ # Should not raise - new signature has source and local_path
+ window._on_drag_started("https://example.com/file.png", "/local/path/file.png")
def test_on_drag_failed_called(self, qtbot, sample_config):
"""Test _on_drag_failed handler can be called."""
window = MainWindow(sample_config)
qtbot.addWidget(window)
- # Should not raise
- window._on_drag_failed("Test error message")
+ # Should not raise - new signature has source and error
+ window._on_drag_failed("https://example.com/file.png", "Test error message")
class TestMainWindowURLWhitelist:
diff --git a/tests/unit/test_url_converter.py b/tests/unit/test_url_converter.py
new file mode 100644
index 0000000..60ab58f
--- /dev/null
+++ b/tests/unit/test_url_converter.py
@@ -0,0 +1,144 @@
+"""Unit tests for URL converter."""
+
+from pathlib import Path
+
+import pytest
+
+from webdrop_bridge.config import Config, URLMapping
+from webdrop_bridge.core.url_converter import URLConverter
+
+
+@pytest.fixture
+def test_config():
+ """Create test configuration with URL mappings."""
+ return Config(
+ app_name="Test App",
+ app_version="1.0.0",
+ log_level="INFO",
+ log_file=None,
+ allowed_roots=[],
+ allowed_urls=[],
+ webapp_url="https://wps.agravity.io/",
+ url_mappings=[
+ URLMapping(
+ url_prefix="https://wpsagravitystg.file.core.windows.net/wpsagravitysync/",
+ local_path="Z:"
+ ),
+ URLMapping(
+ url_prefix="https://other.blob.core.windows.net/container/",
+ local_path="Y:\\shared"
+ )
+ ]
+ )
+
+
+@pytest.fixture
+def converter(test_config):
+ """Create URL converter with test config."""
+ return URLConverter(test_config)
+
+
+def test_convert_simple_url(converter):
+ """Test converting a simple Azure URL to local path."""
+ url = "https://wpsagravitystg.file.core.windows.net/wpsagravitysync/test/file.png"
+ result = converter.convert_url_to_path(url)
+
+ assert result is not None
+ assert str(result).endswith("test\\file.png") # Windows path separator
+
+
+def test_convert_url_with_special_characters(converter):
+ """Test URL with special characters (URL encoded)."""
+ url = "https://wpsagravitystg.file.core.windows.net/wpsagravitysync/folder/file%20with%20spaces.png"
+ result = converter.convert_url_to_path(url)
+
+ assert result is not None
+ assert "file with spaces.png" in str(result)
+
+
+def test_convert_url_with_subdirectories(converter):
+ """Test URL with deep directory structure."""
+ url = "https://wpsagravitystg.file.core.windows.net/wpsagravitysync/aN5PysnXIuRECzcRbvHkjL7g0/subfolder/file.png"
+ result = converter.convert_url_to_path(url)
+
+ assert result is not None
+ assert "aN5PysnXIuRECzcRbvHkjL7g0" in str(result)
+ assert "subfolder" in str(result)
+
+
+def test_convert_unmapped_url(converter):
+ """Test URL that doesn't match any mapping."""
+ url = "https://unknown.blob.core.windows.net/container/file.png"
+ result = converter.convert_url_to_path(url)
+
+ assert result is None
+
+
+def test_convert_empty_url(converter):
+ """Test empty URL."""
+ result = converter.convert_url_to_path("")
+ assert result is None
+
+
+def test_convert_none_url(converter):
+ """Test None URL."""
+ result = converter.convert_url_to_path(None)
+ assert result is None
+
+
+def test_is_azure_url_positive(converter):
+ """Test recognizing valid Azure URLs."""
+ url = "https://wpsagravitystg.file.core.windows.net/wpsagravitysync/file.png"
+ assert converter.is_azure_url(url) is True
+
+
+def test_is_azure_url_negative(converter):
+ """Test rejecting non-Azure URLs."""
+ assert converter.is_azure_url("https://example.com/file.png") is False
+ assert converter.is_azure_url("Z:\\file.png") is False
+ assert converter.is_azure_url("") is False
+
+
+def test_multiple_mappings(converter):
+ """Test that correct mapping is used for URL."""
+ url1 = "https://wpsagravitystg.file.core.windows.net/wpsagravitysync/file.png"
+ url2 = "https://other.blob.core.windows.net/container/file.png"
+
+ result1 = converter.convert_url_to_path(url1)
+ result2 = converter.convert_url_to_path(url2)
+
+ assert result1 is not None
+ assert result2 is not None
+ assert str(result1).startswith("Z:")
+ assert str(result2).startswith("Y:")
+
+
+def test_url_mapping_validation_http():
+ """Test that URL mapping requires http:// or https://."""
+ with pytest.raises(Exception): # ConfigurationError
+ URLMapping(
+ url_prefix="ftp://server/path/",
+ local_path="Z:"
+ )
+
+
+def test_url_mapping_adds_trailing_slash():
+ """Test that URL mapping adds trailing slash if missing."""
+ mapping = URLMapping(
+ url_prefix="https://example.com/path",
+ local_path="Z:"
+ )
+ assert mapping.url_prefix.endswith("/")
+
+
+def test_convert_url_example_from_docs(converter):
+ """Test the exact example from documentation."""
+ url = "https://wpsagravitystg.file.core.windows.net/wpsagravitysync/aN5PysnXIuRECzcRbvHkjL7g0/Hintergrund_Agravity.png"
+ result = converter.convert_url_to_path(url)
+
+ assert result is not None
+ # Should be: Z:\aN5PysnXIuRECzcRbvHkjL7g0\Hintergrund_Agravity.png
+ expected_parts = ["Z:", "aN5PysnXIuRECzcRbvHkjL7g0", "Hintergrund_Agravity.png"]
+ result_str = str(result)
+ for part in expected_parts:
+ assert part in result_str
diff --git a/tests/unit/test_validator.py b/tests/unit/test_validator.py
index db8ae61..eabb228 100644
--- a/tests/unit/test_validator.py
+++ b/tests/unit/test_validator.py
@@ -22,11 +22,12 @@ class TestPathValidator:
assert len(validator.allowed_roots) == 2
def test_validator_nonexistent_root(self, tmp_path):
- """Test that nonexistent root raises ValidationError."""
+ """Test that nonexistent root is logged as warning but doesn't raise error."""
nonexistent = tmp_path / "nonexistent"
- with pytest.raises(ValidationError, match="does not exist"):
- PathValidator([nonexistent])
+ # Should not raise - just logs warning and skips the root
+ validator = PathValidator([nonexistent])
+ assert len(validator.allowed_roots) == 0 # Non-existent roots are skipped
def test_validator_non_directory_root(self, tmp_path):
"""Test that non-directory root raises ValidationError."""
diff --git a/verify_fix.py b/verify_fix.py
deleted file mode 100644
index 88b8481..0000000
--- a/verify_fix.py
+++ /dev/null
@@ -1,74 +0,0 @@
-#!/usr/bin/env python
-"""Quick verification that the update hang fix is in place."""
-
-import inspect
-
-from webdrop_bridge.ui.main_window import MainWindow, UpdateDownloadWorker
-
-print("\n" + "="*70)
-print("VERIFICATION: Update Feature Hang Fix")
-print("="*70 + "\n")
-
-# Check 1: UpdateDownloadWorker exists
-print("✓ UpdateDownloadWorker class exists")
-print(f" - Location: {inspect.getfile(UpdateDownloadWorker)}")
-
-# Check 2: Verify signals are defined
-signals = ['download_complete', 'download_failed', 'update_status', 'finished']
-print(f"\n✓ UpdateDownloadWorker has required signals:")
-for sig in signals:
- assert hasattr(UpdateDownloadWorker, sig)
- print(f" - {sig}")
-
-# Check 3: Verify run method exists
-assert hasattr(UpdateDownloadWorker, 'run')
-print(f"\n✓ UpdateDownloadWorker.run() method exists")
-
-# Check 4: Verify MainWindow uses async download
-print(f"\n✓ MainWindow changes:")
-assert hasattr(MainWindow, '_perform_update_async')
-print(f" - Has _perform_update_async() method (new async version)")
-assert hasattr(MainWindow, '_on_download_complete')
-print(f" - Has _on_download_complete() handler")
-assert hasattr(MainWindow, '_on_download_failed')
-print(f" - Has _on_download_failed() handler")
-assert not hasattr(MainWindow, '_perform_update')
-print(f" - Old blocking _perform_update() method removed")
-
-# Check 5: Verify the fix: Look at _perform_update_async source
-source = inspect.getsource(MainWindow._perform_update_async)
-assert 'QThread()' in source
-print(f"\n✓ _perform_update_async uses background thread:")
-assert 'UpdateDownloadWorker' in source
-print(f" - Creates UpdateDownloadWorker")
-assert 'worker.moveToThread(thread)' in source
-print(f" - Moves worker to background thread")
-assert 'thread.start()' in source
-print(f" - Starts the thread")
-
-print("\n" + "="*70)
-print("✅ VERIFICATION SUCCESSFUL!")
-print("="*70)
-print("\nFIX SUMMARY:")
-print("-" * 70)
-print("""
-The update feature hang issue has been fixed by:
-
-1. Created UpdateDownloadWorker class that runs async operations in a
- background thread (instead of blocking the UI thread).
-
-2. The worker properly handles:
- - Downloading the update asynchronously
- - Verifying checksums asynchronously
- - Emitting signals for UI updates
-
-3. MainWindow's _perform_update_async() method now:
- - Creates a background thread for the worker
- - Connects signals for download complete/failure handlers
- - Keeps a reference to prevent garbage collection
- - Properly cleans up threads after completion
-
-Result: The update dialog now displays without freezing the application!
- The user can interact with the UI while the download happens.
-""")
-print("-" * 70 + "\n")
diff --git a/verify_timeout_handling.py b/verify_timeout_handling.py
deleted file mode 100644
index 51755d8..0000000
--- a/verify_timeout_handling.py
+++ /dev/null
@@ -1,108 +0,0 @@
-#!/usr/bin/env python
-"""Verify timeout and error handling in update feature."""
-
-import inspect
-
-from webdrop_bridge.core.updater import UpdateManager
-from webdrop_bridge.ui.main_window import UpdateCheckWorker, UpdateDownloadWorker
-
-print("\n" + "="*70)
-print("TIMEOUT AND ERROR HANDLING VERIFICATION")
-print("="*70 + "\n")
-
-print("Test 1: UpdateCheckWorker timeout handling")
-print("-" * 70)
-
-# Check UpdateCheckWorker source for asyncio.wait_for
-source = inspect.getsource(UpdateCheckWorker.run)
-if "asyncio.wait_for" in source and "timeout=15" in source:
- print("✓ UpdateCheckWorker has 15-second timeout")
- print(" await asyncio.wait_for(..., timeout=15)")
-else:
- print("❌ Missing timeout in UpdateCheckWorker")
-
-if "asyncio.TimeoutError" in source:
- print("✓ Handles asyncio.TimeoutError exception")
-else:
- print("❌ Missing TimeoutError handling")
-
-if "loop.close()" in source:
- print("✓ Properly closes event loop in finally block")
-else:
- print("❌ Missing loop.close() cleanup")
-
-print("\nTest 2: UpdateDownloadWorker timeout handling")
-print("-" * 70)
-
-source = inspect.getsource(UpdateDownloadWorker.run)
-if "asyncio.wait_for" in source:
- print("✓ UpdateDownloadWorker uses asyncio.wait_for")
- if "timeout=300" in source:
- print(" → Download timeout: 300 seconds (5 minutes)")
- if "timeout=30" in source:
- print(" → Verification timeout: 30 seconds")
-else:
- print("❌ Missing timeout in UpdateDownloadWorker")
-
-if "asyncio.TimeoutError" in source:
- print("✓ Handles asyncio.TimeoutError exception")
- if "Operation timed out" in source:
- print(" → Shows 'Operation timed out' message")
-else:
- print("❌ Missing TimeoutError handling")
-
-if "loop.close()" in source:
- print("✓ Properly closes event loop in finally block")
-else:
- print("❌ Missing loop.close() cleanup")
-
-print("\nTest 3: UpdateManager timeout handling")
-print("-" * 70)
-
-source = inspect.getsource(UpdateManager.check_for_updates)
-if "asyncio.wait_for" in source:
- print("✓ check_for_updates has timeout")
- if "timeout=10" in source:
- print(" → API check timeout: 10 seconds")
-else:
- print("❌ Missing timeout in check_for_updates")
-
-if "asyncio.TimeoutError" in source:
- print("✓ Handles asyncio.TimeoutError")
- if "timed out" in source or "timeout" in source.lower():
- print(" → Logs timeout message")
-else:
- print("❌ Missing TimeoutError handling")
-
-# Check download_update timeout
-source = inspect.getsource(UpdateManager.download_update)
-if "asyncio.wait_for" in source:
- print("\n✓ download_update has timeout")
- if "timeout=300" in source:
- print(" → Download timeout: 300 seconds (5 minutes)")
-else:
- print("❌ Missing timeout in download_update")
-
-# Check verify_checksum timeout
-source = inspect.getsource(UpdateManager.verify_checksum)
-if "asyncio.wait_for" in source:
- print("✓ verify_checksum has timeout")
- if "timeout=30" in source:
- print(" → Checksum verification timeout: 30 seconds")
-else:
- print("❌ Missing timeout in verify_checksum")
-
-print("\n" + "="*70)
-print("✅ TIMEOUT HANDLING PROPERLY IMPLEMENTED!")
-print("="*70)
-print("\nSummary of timeout protection:")
-print(" • Update check: 15 seconds")
-print(" • API fetch: 10 seconds")
-print(" • Download: 5 minutes (300 seconds)")
-print(" • Checksum verification: 30 seconds")
-print("\nWhen timeouts occur:")
-print(" • User-friendly error message is shown")
-print(" • Event loops are properly closed")
-print(" • Application doesn't hang indefinitely")
-print(" • User can retry or cancel the operation")
-print("="*70 + "\n")
diff --git a/webapp/index.html b/webapp/index.html
index ac302bf..b675dc3 100644
--- a/webapp/index.html
+++ b/webapp/index.html
@@ -162,20 +162,26 @@
🖼️
-
Sample Image
+
Local Z:\ Image
Z:\data\test-image.jpg
📄
-
Sample Document
+
Local Z:\ Document
Z:\data\API_DOCUMENTATION.pdf
-
📊
-
Sample Data
-
C:\Users\Public\data.csv
+
☁️
+
Azure Blob Storage Image
+
https://wpsagravitystg.file.core.windows.net/wpsagravitysync/aN5PysnXIuRECzcRbvHkjL7g0/Hintergrund_Agravity.png
+
+
+
+
☁️
+
Azure Blob Storage Document
+
https://wpsagravitystg.file.core.windows.net/wpsagravitysync/test/document.pdf
@@ -183,15 +189,59 @@
How to test:
- Open InDesign, Word, or Notepad++
- - Drag one of the items below to the application
- - The file path should be converted to a real file drag
+ - Drag one of the items above to the application
+ - Local Z:\ paths and Azure URLs will be converted to file drags
+ - Azure URLs will be mapped to Z:\ paths automatically
- Check the browser console (F12) for debug info
+
Note: When dragging images from web apps like Agravity, the browser may not provide text/plain data. Press ALT while dragging to force text drag mode.