778 lines
No EOL
27 KiB
Python
778 lines
No EOL
27 KiB
Python
"""
|
|
Workflow routes for the backend API.
|
|
Implements the endpoints for workflow management according to the state machine.
|
|
"""
|
|
|
|
import os
|
|
import json
|
|
import logging
|
|
from typing import List, Dict, Any, Optional
|
|
from fastapi import APIRouter, HTTPException, Depends, Body, Path, Query, Response, status
|
|
from dataclasses import dataclass
|
|
from datetime import datetime
|
|
|
|
# Import interfaces
|
|
from modules.interfaces.lucydomInterface import getLucydomInterface
|
|
from modules.security.auth import getCurrentActiveUser, getUserContext
|
|
from modules.workflow.workflowManager import getWorkflowManager
|
|
|
|
# Import models
|
|
from modules.interfaces.lucydomModel import UserInputRequest
|
|
|
|
# Configure logger
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# Create router for workflow endpoints
|
|
router = APIRouter(
|
|
prefix="/api/workflows",
|
|
tags=["Workflow"],
|
|
responses={404: {"description": "Not found"}}
|
|
)
|
|
|
|
class AppContext:
|
|
def __init__(self, mandateId: int, userId: int):
|
|
self._mandateId = mandateId
|
|
self._userId = userId
|
|
self.interfaceData = getLucydomInterface(mandateId, userId)
|
|
|
|
async def getContext(currentUser: Dict[str, Any]) -> AppContext:
|
|
mandateId, userId = await getUserContext(currentUser)
|
|
return AppContext(mandateId, userId)
|
|
|
|
# State 1: Workflow Initialization endpoint
|
|
@router.post("/start", response_model=Dict[str, Any])
|
|
async def startWorkflow(
|
|
workflowId: Optional[str] = Query(None, description="Optional ID of the workflow to continue"),
|
|
userInput: UserInputRequest = Body(...),
|
|
currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)
|
|
):
|
|
"""
|
|
Starts a new workflow or continues an existing one.
|
|
Corresponds to State 1 in the state machine documentation.
|
|
|
|
Args:
|
|
workflowId: Optional ID of an existing workflow to continue
|
|
userInput: User input with prompt and optional file list
|
|
currentUser: Authenticated user
|
|
|
|
Returns:
|
|
Dictionary with workflow ID and status
|
|
"""
|
|
context = await getContext(currentUser)
|
|
|
|
try:
|
|
# Convert the user input to a dictionary
|
|
userInputDict = {
|
|
"prompt": userInput.prompt,
|
|
"listFileId": userInput.listFileId
|
|
}
|
|
|
|
# Start or continue workflow using the workflow manager
|
|
workflow = await getWorkflowManager(context._mandateId, context._userId).workflowStart(userInputDict, workflowId)
|
|
logger.info("User Input received. Answer:",workflow)
|
|
|
|
return {
|
|
"id": workflow.get("id"),
|
|
"status": workflow.get("status", "running"),
|
|
"message": "Workflow initialized and processing started"
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error starting workflow: {str(e)}", exc_info=True)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Error starting workflow: {str(e)}"
|
|
)
|
|
|
|
# State 8: Workflow Stopped endpoint
|
|
@router.post("/{workflowId}/stop", response_model=Dict[str, Any])
|
|
async def stopWorkflow(
|
|
workflowId: str = Path(..., description="ID of the workflow to stop"),
|
|
currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)
|
|
):
|
|
"""
|
|
Stops a running workflow.
|
|
Corresponds to State 8 in the state machine documentation.
|
|
|
|
Args:
|
|
workflowId: ID of the workflow to stop
|
|
currentUser: Authenticated user
|
|
|
|
Returns:
|
|
Dictionary with status information
|
|
"""
|
|
context = await getContext(currentUser)
|
|
|
|
try:
|
|
# Verify workflow exists and belongs to user
|
|
workflow = context.interfaceData.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail=f"Workflow with ID {workflowId} not found"
|
|
)
|
|
|
|
if workflow.get("_userId") != context._userId:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_403_FORBIDDEN,
|
|
detail="You don't have permission to stop this workflow"
|
|
)
|
|
|
|
# Stop the workflow
|
|
stoppedWorkflow = getWorkflowManager(context._mandateId, context._userId).workflowStop(workflowId)
|
|
|
|
return {
|
|
"id": workflowId,
|
|
"status": stoppedWorkflow.get("status", "stopped"),
|
|
"message": "Workflow has been stopped"
|
|
}
|
|
except HTTPException:
|
|
# Re-raise HTTP exceptions
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error stopping workflow: {str(e)}", exc_info=True)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Error stopping workflow: {str(e)}"
|
|
)
|
|
|
|
# State 11: Workflow Reset/Deletion endpoint
|
|
@router.delete("/{workflowId}", response_model=Dict[str, Any])
|
|
async def deleteWorkflow(
|
|
workflowId: str = Path(..., description="ID of the workflow to delete"),
|
|
currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)
|
|
):
|
|
"""
|
|
Deletes a workflow and its associated data.
|
|
Corresponds to State 11 in the state machine documentation.
|
|
|
|
Args:
|
|
workflowId: ID of the workflow to delete
|
|
currentUser: Authenticated user
|
|
|
|
Returns:
|
|
Dictionary with status information
|
|
"""
|
|
context = await getContext(currentUser)
|
|
|
|
try:
|
|
# Verify workflow exists
|
|
workflow = context.interfaceData.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail=f"Workflow with ID {workflowId} not found"
|
|
)
|
|
|
|
# Check if user has permission to delete
|
|
if workflow.get("_userId") != context._userId:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_403_FORBIDDEN,
|
|
detail="You don't have permission to delete this workflow"
|
|
)
|
|
|
|
# Delete workflow
|
|
success = context.interfaceData.deleteWorkflow(workflowId)
|
|
|
|
if not success:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail="Failed to delete workflow"
|
|
)
|
|
|
|
return {
|
|
"id": workflowId,
|
|
"message": "Workflow and associated data deleted successfully"
|
|
}
|
|
except HTTPException:
|
|
# Re-raise HTTP exceptions
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error deleting workflow: {str(e)}", exc_info=True)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Error deleting workflow: {str(e)}"
|
|
)
|
|
|
|
# API Endpoint for getting all workflows
|
|
@router.get("", response_model=List[Dict[str, Any]])
|
|
async def listWorkflows(
|
|
currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)
|
|
):
|
|
"""
|
|
List all workflows for the current user.
|
|
|
|
Args:
|
|
currentUser: Authenticated user
|
|
|
|
Returns:
|
|
List of workflow objects
|
|
"""
|
|
context = await getContext(currentUser)
|
|
|
|
try:
|
|
# Retrieve workflows for the user
|
|
workflows = context.interfaceData.getWorkflowsByUser(context._userId)
|
|
return workflows
|
|
except Exception as e:
|
|
logger.error(f"Error listing workflows: {str(e)}", exc_info=True)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Error listing workflows: {str(e)}"
|
|
)
|
|
|
|
# API Endpoint for workflow status
|
|
@router.get("/{workflowId}/status", response_model=Dict[str, Any])
|
|
async def getWorkflowStatus(
|
|
workflowId: str = Path(..., description="ID of the workflow"),
|
|
currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)
|
|
):
|
|
"""
|
|
Get the current status of a workflow.
|
|
|
|
Args:
|
|
workflowId: ID of the workflow
|
|
currentUser: Authenticated user
|
|
|
|
Returns:
|
|
Dictionary with workflow status information
|
|
"""
|
|
context = await getContext(currentUser)
|
|
|
|
try:
|
|
# Retrieve workflow
|
|
workflow = context.interfaceData.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail=f"Workflow with ID {workflowId} not found"
|
|
)
|
|
|
|
# Create status response
|
|
statusInfo = {
|
|
"id": workflow.get("id"),
|
|
"name": workflow.get("name"),
|
|
"status": workflow.get("status"),
|
|
"startedAt": workflow.get("startedAt"),
|
|
"lastActivity": workflow.get("lastActivity"),
|
|
"currentRound": workflow.get("currentRound", 1),
|
|
"dataStats": workflow.get("dataStats", {})
|
|
}
|
|
|
|
return statusInfo
|
|
except HTTPException:
|
|
# Re-raise HTTP exceptions
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting workflow status: {str(e)}", exc_info=True)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Error getting workflow status: {str(e)}"
|
|
)
|
|
|
|
# API Endpoint for workflow logs with selective data transfer
|
|
@router.get("/{workflowId}/logs", response_model=List[Dict[str, Any]])
|
|
async def getWorkflowLogs(
|
|
workflowId: str = Path(..., description="ID of the workflow"),
|
|
logId: Optional[str] = Query(None, description="Optional log ID to get only newer logs"),
|
|
currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)
|
|
):
|
|
"""
|
|
Get logs for a workflow with support for selective data transfer.
|
|
If logId is provided, returns only logs with IDs equal to or newer than the specified ID.
|
|
|
|
Args:
|
|
workflowId: ID of the workflow
|
|
logId: Optional ID to get only newer logs
|
|
currentUser: Authenticated user
|
|
|
|
Returns:
|
|
List of log entries
|
|
"""
|
|
context = await getContext(currentUser)
|
|
|
|
try:
|
|
# Verify workflow exists
|
|
workflow = context.interfaceData.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail=f"Workflow with ID {workflowId} not found"
|
|
)
|
|
|
|
# Get all logs
|
|
allLogs = context.interfaceData.getWorkflowLogs(workflowId)
|
|
|
|
# Apply selective data transfer if logId is provided
|
|
if logId:
|
|
# Find the index of the specified log
|
|
logIndex = next((i for i, log in enumerate(allLogs) if log.get("id") == logId), None)
|
|
|
|
if logIndex is not None:
|
|
# Return logs from this index onwards
|
|
return allLogs[logIndex:]
|
|
|
|
return allLogs
|
|
except HTTPException:
|
|
# Re-raise HTTP exceptions
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting workflow logs: {str(e)}", exc_info=True)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Error getting workflow logs: {str(e)}"
|
|
)
|
|
|
|
# API Endpoint for workflow messages with selective data transfer
|
|
@router.get("/{workflowId}/messages", response_model=List[Dict[str, Any]])
|
|
async def getWorkflowMessages(
|
|
workflowId: str = Path(..., description="ID of the workflow"),
|
|
messageId: Optional[str] = Query(None, description="Optional message ID to get only newer messages"),
|
|
currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)
|
|
):
|
|
"""
|
|
Get messages for a workflow with support for selective data transfer.
|
|
If messageId is provided, returns only messages with IDs equal to or newer than the specified ID.
|
|
|
|
Args:
|
|
workflowId: ID of the workflow
|
|
messageId: Optional ID to get only newer messages
|
|
currentUser: Authenticated user
|
|
|
|
Returns:
|
|
List of message objects
|
|
"""
|
|
context = await getContext(currentUser)
|
|
|
|
try:
|
|
# Verify workflow exists
|
|
workflow = context.interfaceData.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail=f"Workflow with ID {workflowId} not found"
|
|
)
|
|
|
|
# Get all messages
|
|
allMessages = context.interfaceData.getWorkflowMessages(workflowId)
|
|
|
|
# Apply selective data transfer if messageId is provided
|
|
if messageId:
|
|
# Find the index of the specified message based on messageIds array
|
|
messageIds = workflow.get("messageIds", [])
|
|
if messageId in messageIds:
|
|
messageIndex = messageIds.index(messageId)
|
|
# Return messages from this index onwards based on the messageIds order
|
|
filteredMessages = []
|
|
for msgId in messageIds[messageIndex:]:
|
|
message = next((msg for msg in allMessages if msg.get("id") == msgId), None)
|
|
if message:
|
|
filteredMessages.append(message)
|
|
return filteredMessages
|
|
|
|
# Sort messages by sequenceNo
|
|
allMessages.sort(key=lambda x: x.get("sequenceNo", 0))
|
|
return allMessages
|
|
except HTTPException:
|
|
# Re-raise HTTP exceptions
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting workflow messages: {str(e)}", exc_info=True)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Error getting workflow messages: {str(e)}"
|
|
)
|
|
|
|
# Document Management Endpoints
|
|
|
|
@router.delete("/{workflowId}/messages/{messageId}", response_model=Dict[str, Any])
|
|
async def deleteWorkflowMessage(
|
|
workflowId: str = Path(..., description="ID of the workflow"),
|
|
messageId: str = Path(..., description="ID of the message to delete"),
|
|
currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)
|
|
):
|
|
"""
|
|
Delete a message from a workflow.
|
|
|
|
Args:
|
|
workflowId: ID of the workflow
|
|
messageId: ID of the message to delete
|
|
currentUser: Authenticated user
|
|
|
|
Returns:
|
|
Dictionary with status information
|
|
"""
|
|
context = await getContext(currentUser)
|
|
|
|
try:
|
|
# Verify workflow exists and belongs to user
|
|
workflow = context.interfaceData.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail=f"Workflow with ID {workflowId} not found"
|
|
)
|
|
|
|
if workflow.get("_userId") != context._userId:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_403_FORBIDDEN,
|
|
detail="You don't have permission to modify this workflow"
|
|
)
|
|
|
|
# Delete the message
|
|
success = context.interfaceData.deleteWorkflowMessage(workflowId, messageId)
|
|
|
|
if not success:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail=f"Message with ID {messageId} not found in workflow {workflowId}"
|
|
)
|
|
|
|
# Update workflow's messageIds
|
|
messageIds = workflow.get("messageIds", [])
|
|
if messageId in messageIds:
|
|
messageIds.remove(messageId)
|
|
context.interfaceData.updateWorkflow(workflowId, {"messageIds": messageIds})
|
|
|
|
return {
|
|
"workflowId": workflowId,
|
|
"messageId": messageId,
|
|
"message": "Message deleted successfully"
|
|
}
|
|
except HTTPException:
|
|
# Re-raise HTTP exceptions
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error deleting message: {str(e)}", exc_info=True)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Error deleting message: {str(e)}"
|
|
)
|
|
|
|
@router.delete("/{workflowId}/messages/{messageId}/files/{fileId}", response_model=Dict[str, Any])
|
|
async def deleteFileFromMessage(
|
|
workflowId: str = Path(..., description="ID of the workflow"),
|
|
messageId: str = Path(..., description="ID of the message"),
|
|
fileId: str = Path(..., description="ID of the file to delete"),
|
|
currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)
|
|
):
|
|
"""
|
|
Delete a file reference from a message in a workflow.
|
|
The file itself is not deleted from the database, only the reference in the message.
|
|
|
|
Args:
|
|
workflowId: ID of the workflow
|
|
messageId: ID of the message
|
|
fileId: ID of the file to delete
|
|
currentUser: Authenticated user
|
|
|
|
Returns:
|
|
Dictionary with status information
|
|
"""
|
|
context = await getContext(currentUser)
|
|
|
|
try:
|
|
# Verify workflow exists and belongs to user
|
|
workflow = context.interfaceData.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail=f"Workflow with ID {workflowId} not found"
|
|
)
|
|
|
|
if workflow.get("_userId") != context._userId:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_403_FORBIDDEN,
|
|
detail="You don't have permission to modify this workflow"
|
|
)
|
|
|
|
# Delete file reference from message
|
|
success = context.interfaceData.deleteFileFromMessage(workflowId, messageId, fileId)
|
|
|
|
if not success:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail=f"File with ID {fileId} not found in message {messageId}"
|
|
)
|
|
|
|
return {
|
|
"workflowId": workflowId,
|
|
"messageId": messageId,
|
|
"fileId": fileId,
|
|
"message": "File reference deleted successfully"
|
|
}
|
|
except HTTPException:
|
|
# Re-raise HTTP exceptions
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error deleting file reference: {str(e)}", exc_info=True)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Error deleting file reference: {str(e)}"
|
|
)
|
|
|
|
# File preview and download routes
|
|
|
|
@router.get("/files/{fileId}/preview", response_model=Dict[str, Any])
|
|
async def previewFile(
|
|
fileId: str = Path(..., description="ID of the file to preview"),
|
|
currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)
|
|
):
|
|
"""
|
|
Get file metadata and a preview of the file content.
|
|
|
|
Args:
|
|
fileId: ID of the file
|
|
currentUser: Authenticated user
|
|
|
|
Returns:
|
|
Dictionary with file metadata and preview content
|
|
"""
|
|
context = await getContext(currentUser)
|
|
|
|
try:
|
|
# Get file metadata
|
|
file = context.interfaceData.getFile(fileId)
|
|
if not file:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail=f"File with ID {fileId} not found"
|
|
)
|
|
|
|
# Check if file belongs to user or their mandate
|
|
if file.get("_mandateId") != context._mandateId and file.get("_userId") != context._userId:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_403_FORBIDDEN,
|
|
detail="You don't have permission to access this file"
|
|
)
|
|
|
|
# Get file data (limited for preview)
|
|
fileData = context.interfaceData.getFileData(fileId)
|
|
if fileData is None:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail=f"File data not found for file ID {fileId}"
|
|
)
|
|
|
|
# For text-based files, return a preview of the content
|
|
mimeType = file.get("mimeType", "application/octet-stream")
|
|
isText = mimeType.startswith("text/") or mimeType in [
|
|
"application/json",
|
|
"application/xml",
|
|
"application/javascript"
|
|
]
|
|
|
|
previewData = None
|
|
|
|
# Get base64Encoded flag from database
|
|
fileDataEntries = context.interfaceData.db.getRecordset("fileData", recordFilter={"id": fileId})
|
|
if fileDataEntries and "base64Encoded" in fileDataEntries[0]:
|
|
# Use the flag from the database
|
|
base64Encoded = fileDataEntries[0]["base64Encoded"]
|
|
else:
|
|
# Determine based on file type (fallback for older data)
|
|
base64Encoded = not isText
|
|
|
|
if isText:
|
|
# Convert to string without trim for preview
|
|
if isinstance(fileData, bytes):
|
|
try:
|
|
filePreview = fileData.decode('utf-8')
|
|
previewData = filePreview
|
|
except UnicodeDecodeError:
|
|
# Try other encodings
|
|
for encoding in ['latin-1', 'cp1252', 'iso-8859-1']:
|
|
try:
|
|
filePreview = fileData.decode(encoding)
|
|
previewData = filePreview
|
|
break
|
|
except UnicodeDecodeError:
|
|
continue
|
|
|
|
# For images, return base64 encoded data
|
|
if mimeType.startswith("image/"):
|
|
import base64
|
|
previewData = base64.b64encode(fileData).decode('utf-8')
|
|
base64Encoded = True
|
|
|
|
# Return file metadata with preview and base64Encoded flag
|
|
return {
|
|
"id": fileId,
|
|
"name": file.get("name"),
|
|
"mimeType": mimeType,
|
|
"size": file.get("size"),
|
|
"creationDate": file.get("creationDate"),
|
|
"isPreviewable": isText or mimeType.startswith("image/"),
|
|
"preview": previewData,
|
|
"base64Encoded": base64Encoded
|
|
}
|
|
except HTTPException:
|
|
# Re-raise HTTP exceptions
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error previewing file: {str(e)}", exc_info=True)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Error previewing file: {str(e)}"
|
|
)
|
|
|
|
@router.get("/files/{fileId}/download")
|
|
async def downloadFile(
|
|
fileId: str = Path(..., description="ID of the file to download"),
|
|
currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)
|
|
):
|
|
"""
|
|
Download a file.
|
|
|
|
Args:
|
|
fileId: ID of the file
|
|
currentUser: Authenticated user
|
|
|
|
Returns:
|
|
File data with appropriate headers
|
|
"""
|
|
context = await getContext(currentUser)
|
|
|
|
try:
|
|
# Get file data
|
|
fileInfo = context.interfaceData.downloadFile(fileId)
|
|
if not fileInfo:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail=f"File with ID {fileId} not found"
|
|
)
|
|
|
|
# Return file as response
|
|
return Response(
|
|
content=fileInfo["content"],
|
|
media_type=fileInfo["contentType"],
|
|
headers={
|
|
"Content-Disposition": f"attachment; filename={fileInfo['name']}"
|
|
}
|
|
)
|
|
except HTTPException:
|
|
# Re-raise HTTP exceptions
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error downloading file: {str(e)}", exc_info=True)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Error downloading file: {str(e)}"
|
|
)
|
|
|
|
@router.get("/workflows", response_model=List[Dict[str, Any]])
|
|
async def getWorkflows(currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)):
|
|
context = await getContext(currentUser)
|
|
|
|
# Get all workflows for the mandate
|
|
workflows = context.interfaceData.getWorkflowsByMandate(context._mandateId)
|
|
|
|
return workflows
|
|
|
|
@router.post("/workflows", response_model=Dict[str, Any])
|
|
async def createWorkflow(
|
|
workflow: Dict[str, Any],
|
|
currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)
|
|
):
|
|
context = await getContext(currentUser)
|
|
|
|
# Create workflow
|
|
newWorkflow = context.interfaceData.createWorkflow(workflow)
|
|
|
|
return newWorkflow
|
|
|
|
@router.get("/workflows/{workflowId}", response_model=Dict[str, Any])
|
|
async def getWorkflow(
|
|
workflowId: str = Path(..., description="ID of the workflow"),
|
|
currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)
|
|
):
|
|
context = await getContext(currentUser)
|
|
|
|
# Get workflow
|
|
workflow = context.interfaceData.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(status_code=404, detail="Workflow not found")
|
|
|
|
# Check if user has access to this workflow
|
|
if workflow.get("_userId") != context._userId:
|
|
raise HTTPException(status_code=403, detail="Not authorized to access this workflow")
|
|
|
|
return workflow
|
|
|
|
@router.put("/workflows/{workflowId}", response_model=Dict[str, Any])
|
|
async def updateWorkflow(
|
|
workflow: Dict[str, Any],
|
|
workflowId: str = Path(..., description="ID of the workflow to update"),
|
|
currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)
|
|
):
|
|
context = await getContext(currentUser)
|
|
|
|
# Get workflow
|
|
existingWorkflow = context.interfaceData.getWorkflow(workflowId)
|
|
if not existingWorkflow:
|
|
raise HTTPException(status_code=404, detail="Workflow not found")
|
|
|
|
# Check if user has access to this workflow
|
|
if existingWorkflow.get("_userId") != context._userId:
|
|
raise HTTPException(status_code=403, detail="Not authorized to update this workflow")
|
|
|
|
# Update workflow
|
|
updatedWorkflow = context.interfaceData.updateWorkflow(workflowId, workflow)
|
|
|
|
return updatedWorkflow
|
|
|
|
@router.delete("/workflows/{workflowId}")
|
|
async def deleteWorkflow(
|
|
workflowId: str = Path(..., description="ID of the workflow to delete"),
|
|
currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)
|
|
):
|
|
context = await getContext(currentUser)
|
|
|
|
# Get workflow
|
|
workflow = context.interfaceData.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(status_code=404, detail="Workflow not found")
|
|
|
|
# Check if user has access to this workflow
|
|
if workflow.get("_userId") != context._userId:
|
|
raise HTTPException(status_code=403, detail="Not authorized to delete this workflow")
|
|
|
|
# Delete workflow
|
|
success = context.interfaceData.deleteWorkflow(workflowId)
|
|
if not success:
|
|
raise HTTPException(status_code=500, detail="Failed to delete workflow")
|
|
|
|
return {"status": "success"}
|
|
|
|
@router.post("/workflows/{workflowId}/files/{fileId}")
|
|
async def addFileToWorkflow(
|
|
workflowId: str = Path(..., description="ID of the workflow"),
|
|
fileId: str = Path(..., description="ID of the file to add"),
|
|
currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)
|
|
):
|
|
"""Add a file to a workflow."""
|
|
context = await getContext(currentUser)
|
|
|
|
# Get workflow
|
|
workflow = context.interfaceData.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(status_code=404, detail="Workflow not found")
|
|
|
|
# Check access
|
|
if workflow.get("_userId") != context._userId:
|
|
raise HTTPException(status_code=403, detail="No access to this workflow")
|
|
|
|
# Get file
|
|
file = context.interfaceData.getFile(fileId)
|
|
if not file:
|
|
raise HTTPException(status_code=404, detail="File not found")
|
|
|
|
# Check file access
|
|
if file.get("_mandateId") != context._mandateId and file.get("_userId") != context._userId:
|
|
raise HTTPException(status_code=403, detail="No access to this file")
|
|
|
|
# Add file to workflow
|
|
success = context.interfaceData.addFileToWorkflow(workflowId, fileId)
|
|
if not success:
|
|
raise HTTPException(status_code=500, detail="Failed to add file to workflow")
|
|
|
|
return {"status": "success"} |