Delete documents from Paperless when removed locally

- Add delete_from_paperless function to paperless_service.py
- Search by document ID or title to find and delete
- Update attachment delete route to remove from Paperless
- Update plan year document delete route to remove from Paperless
- Gracefully handle cases where document not found in Paperless

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: JavaDogWebDesign

app/routes/attachments.py

@@ -170,23 +170,55 @@ def add_attachments(expense_id):
 def delete_attachment(attachment_id):
     """API endpoint to delete an attachment"""
     user_id = session['user_id']
+    paperless_info = None
 
     with db_connection() as conn:
-        # Get attachment file path and verify ownership
+        # Get attachment file path, Paperless info, and verify ownership
         attachment = conn.execute('''
-            SELECT a.file_path FROM attachments a
+            SELECT a.file_path, a.paperless_doc_id, a.paperless_sync_status,
+                   e.date_of_service, e.category, p.name as provider_name
+            FROM attachments a
             INNER JOIN expenses e ON a.expense_id = e.id
+            LEFT JOIN providers p ON e.provider_id = p.id
             WHERE a.id = ? AND e.user_id = ?
         ''', (attachment_id, user_id)).fetchone()
 
         if not attachment:
             return jsonify({'error': 'Attachment not found or access denied'}), 404
 
+        # Store Paperless info before deletion
+        if attachment['paperless_sync_status'] == 'synced':
+            paperless_info = {
+                'doc_id': attachment['paperless_doc_id'],
+                'date': attachment['date_of_service'],
+                'category': attachment['category'],
+                'provider': attachment['provider_name'] or ''
+            }
+
         # Delete file from filesystem
         resolved_path = resolve_attachment_path(attachment['file_path'])
         delete_file_safely(resolved_path)
 
         # Delete from database
         conn.execute('DELETE FROM attachments WHERE id = ?', (attachment_id,))
 
+    # Delete from Paperless (after DB transaction commits)
+    if paperless_info:
+        try:
+            from services.paperless_service import delete_from_paperless
+            # Build title to search for if no doc_id
+            title = f"HSA-{paperless_info['date']}"
+            if paperless_info['provider']:
+                title += f"-{paperless_info['provider']}"
+            title += f"-{paperless_info['category']}"
+
+            delete_from_paperless(
+                user_id=user_id,
+                paperless_doc_id=paperless_info['doc_id'],
+                title=title
+            )
+        except Exception as e:
+            import logging
+            logging.getLogger(__name__).warning(f"Paperless delete failed: {e}")
+
     return jsonify({'success': True})

app/routes/plan_year_documents.py

@@ -160,22 +160,48 @@ def add_documents(plan_year_id):
 def delete_document(document_id):
     """API endpoint to delete a policy document"""
     user_id = session['user_id']
+    paperless_info = None
 
     with db_connection() as conn:
-        # Get document file path and verify ownership
+        # Get document file path, Paperless info, and verify ownership
         document = conn.execute('''
-            SELECT d.file_path FROM plan_year_documents d
+            SELECT d.file_path, d.paperless_doc_id, d.paperless_sync_status,
+                   p.plan_year_start
+            FROM plan_year_documents d
             INNER JOIN plan_years p ON d.plan_year_id = p.id
             WHERE d.id = ? AND p.user_id = ?
         ''', (document_id, user_id)).fetchone()
 
         if not document:
             return jsonify({'error': 'Document not found or access denied'}), 404
 
+        # Store Paperless info before deletion
+        if document['paperless_sync_status'] == 'synced':
+            paperless_info = {
+                'doc_id': document['paperless_doc_id'],
+                'date': document['plan_year_start']
+            }
+
         # Delete file from filesystem
         delete_file_safely(document['file_path'])
 
         # Delete from database
         conn.execute('DELETE FROM plan_year_documents WHERE id = ?', (document_id,))
 
+    # Delete from Paperless (after DB transaction commits)
+    if paperless_info:
+        try:
+            from services.paperless_service import delete_from_paperless
+            # Build title to search for if no doc_id
+            title = f"HSA-Policy-{paperless_info['date']}"
+
+            delete_from_paperless(
+                user_id=user_id,
+                paperless_doc_id=paperless_info['doc_id'],
+                title=title
+            )
+        except Exception as e:
+            import logging
+            logging.getLogger(__name__).warning(f"Paperless delete failed: {e}")
+
     return jsonify({'success': True})

app/services/paperless_service.py

@@ -199,6 +199,113 @@ def get_or_create_correspondent(url: str, token: str, name: str) -> Optional[int
     return None
 
 
+def find_document_by_title(url: str, token: str, title: str) -> Optional[int]:
+    """Find a document by its title.
+
+    Args:
+        url: Paperless base URL
+        token: API token
+        title: Document title to search for
+
+    Returns:
+        Document ID if found, None otherwise
+    """
+    headers = {'Authorization': f'Token {token}'}
+
+    try:
+        response = requests.get(
+            f"{url}/api/documents/",
+            headers=headers,
+            params={'query': f'title:"{title}"'},
+            timeout=PAPERLESS_TIMEOUT
+        )
+
+        if response.status_code == 200:
+            data = response.json()
+            results = data.get('results', [])
+            # Find exact match
+            for doc in results:
+                if doc.get('title') == title:
+                    return doc.get('id')
+            # Fallback to first result if close match
+            if results:
+                return results[0].get('id')
+
+    except Exception as e:
+        logger.error(f"Error searching for document '{title}': {e}")
+
+    return None
+
+
+def delete_document(url: str, token: str, doc_id: int) -> tuple[bool, str]:
+    """Delete a document from Paperless-ngx.
+
+    Args:
+        url: Paperless base URL
+        token: API token
+        doc_id: Document ID to delete
+
+    Returns:
+        Tuple of (success, message)
+    """
+    headers = {'Authorization': f'Token {token}'}
+
+    try:
+        response = requests.delete(
+            f"{url}/api/documents/{doc_id}/",
+            headers=headers,
+            timeout=PAPERLESS_TIMEOUT
+        )
+
+        if response.status_code == 204:
+            return True, "Document deleted"
+        elif response.status_code == 404:
+            return True, "Document not found (may have been deleted)"
+        else:
+            return False, f"Delete failed: {response.status_code}"
+
+    except requests.exceptions.Timeout:
+        return False, "Request timed out"
+    except requests.exceptions.ConnectionError:
+        return False, "Could not connect to server"
+    except Exception as e:
+        logger.error(f"Paperless delete error: {e}")
+        return False, f"Error: {str(e)}"
+
+
+def delete_from_paperless(
+    user_id: int,
+    paperless_doc_id: Optional[int] = None,
+    title: Optional[str] = None
+) -> tuple[bool, str]:
+    """Delete a document from Paperless-ngx.
+
+    Args:
+        user_id: User ID
+        paperless_doc_id: Known Paperless document ID (preferred)
+        title: Document title to search for (fallback)
+
+    Returns:
+        Tuple of (success, message)
+    """
+    config = get_user_paperless_config(user_id)
+    if not config:
+        return True, "Paperless not configured"  # Not an error
+
+    # If we have a document ID, use it directly
+    if paperless_doc_id:
+        return delete_document(config['url'], config['token'], paperless_doc_id)
+
+    # Otherwise, try to find by title
+    if title:
+        doc_id = find_document_by_title(config['url'], config['token'], title)
+        if doc_id:
+            return delete_document(config['url'], config['token'], doc_id)
+        return True, "Document not found in Paperless"  # Not necessarily an error
+
+    return True, "No document ID or title provided"
+
+
 def sync_document(
     url: str,
     token: str,