c8b7517209
serviceCenter = DI-Container (Resolver, Registry, Context) fuer Service-Instanziierung serviceHub = Consumer-facing Aggregation (DB-Interfaces, Runtime-State, lazy Service-Resolution via serviceCenter) - modules/serviceHub/ erstellt: ServiceHub, PublicService, getInterface() - 22 Consumer-Dateien migriert (routes, features, tests): imports von modules.services auf serviceHub bzw. serviceCenter umgestellt - resolver.py: legacy fallback auf altes services/ entfernt - modules/services/ komplett geloescht (83 Dateien inkl. dead code mainAiChat.py) - pre-extraction: progress callback durch chunk-pipeline propagiert, operationType DATA_EXTRACT->DATA_ANALYSE fuer guenstigeres Modell
722 lines
30 KiB
Python
722 lines
30 KiB
Python
# Copyright (c) 2025 Patrick Motsch
|
|
# All rights reserved.
|
|
"""
|
|
Chat Playground Feature Routes.
|
|
Implements the endpoints for chat playground workflow management as a feature.
|
|
"""
|
|
|
|
import json
|
|
import logging
|
|
from typing import Optional, Dict, Any
|
|
from fastapi import APIRouter, HTTPException, Depends, Body, Path, Query, Request, status
|
|
|
|
# Import auth modules
|
|
from modules.auth import limiter, getRequestContext, RequestContext
|
|
|
|
# Import interfaces
|
|
from modules.interfaces import interfaceDbChat
|
|
from modules.interfaces.interfaceDbBilling import getInterface as _getBillingInterface
|
|
|
|
# Import models
|
|
from modules.datamodels.datamodelChat import (
|
|
ChatWorkflow,
|
|
ChatMessage,
|
|
ChatLog,
|
|
UserInputRequest,
|
|
WorkflowModeEnum,
|
|
)
|
|
from modules.datamodels.datamodelPagination import (
|
|
PaginationParams,
|
|
PaginatedResponse,
|
|
PaginationMetadata,
|
|
normalize_pagination_dict,
|
|
)
|
|
|
|
# Import workflow control functions
|
|
from modules.workflows.automation import chatStart, chatStop
|
|
from modules.features.chatplayground.mainChatplayground import getChatplaygroundServices
|
|
from modules.shared.attributeUtils import getModelAttributeDefinitions
|
|
|
|
# Configure logger
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# Model attributes for ChatWorkflow (workflow attributes endpoint)
|
|
workflowAttributes = getModelAttributeDefinitions(ChatWorkflow)
|
|
|
|
# Create router for chat playground feature endpoints
|
|
router = APIRouter(
|
|
prefix="/api/chatplayground",
|
|
tags=["Chat Playground Feature"],
|
|
responses={404: {"description": "Not found"}}
|
|
)
|
|
|
|
|
|
def _getServiceChat(context: RequestContext, featureInstanceId: str = None):
|
|
"""Get chat interface with feature instance context."""
|
|
return interfaceDbChat.getInterface(
|
|
context.user,
|
|
mandateId=str(context.mandateId) if context.mandateId else None,
|
|
featureInstanceId=featureInstanceId
|
|
)
|
|
|
|
|
|
def _validateInstanceAccess(instanceId: str, context: RequestContext) -> str:
|
|
"""
|
|
Validate that user has access to the feature instance.
|
|
|
|
Args:
|
|
instanceId: Feature instance ID
|
|
context: Request context
|
|
|
|
Returns:
|
|
mandateId for the instance
|
|
|
|
Raises:
|
|
HTTPException if access is denied
|
|
"""
|
|
from modules.interfaces.interfaceDbApp import getRootInterface
|
|
|
|
rootInterface = getRootInterface()
|
|
|
|
# Get feature instance (Pydantic model)
|
|
instance = rootInterface.getFeatureInstance(instanceId)
|
|
if not instance:
|
|
raise HTTPException(status_code=404, detail=f"Feature instance {instanceId} not found")
|
|
|
|
# Check user has access to this instance using interface method
|
|
featureAccess = rootInterface.getFeatureAccess(str(context.user.id), instanceId)
|
|
|
|
if not featureAccess or not featureAccess.enabled:
|
|
raise HTTPException(status_code=403, detail="Access denied to this feature instance")
|
|
|
|
return str(instance.mandateId) if instance.mandateId else None
|
|
|
|
|
|
# Workflow start endpoint
|
|
@router.post("/{instanceId}/start", response_model=ChatWorkflow)
|
|
@limiter.limit("120/minute")
|
|
async def start_workflow(
|
|
request: Request,
|
|
instanceId: str = Path(..., description="Feature instance ID"),
|
|
workflowId: Optional[str] = Query(None, description="Optional ID of the workflow to continue"),
|
|
workflowMode: WorkflowModeEnum = Query(..., description="Workflow mode: 'Dynamic' or 'Automation' (mandatory)"),
|
|
userInput: UserInputRequest = Body(...),
|
|
context: RequestContext = Depends(getRequestContext)
|
|
) -> ChatWorkflow:
|
|
"""
|
|
Starts a new workflow or continues an existing one.
|
|
|
|
Args:
|
|
instanceId: Feature instance ID
|
|
workflowMode: "Dynamic" for iterative dynamic-style processing, "Automation" for automated workflow execution
|
|
"""
|
|
try:
|
|
# Validate access and get mandate ID
|
|
mandateId = _validateInstanceAccess(instanceId, context)
|
|
|
|
# Get chatplayground services from service center (not automation)
|
|
services = getChatplaygroundServices(
|
|
context.user,
|
|
mandateId=mandateId,
|
|
featureInstanceId=instanceId,
|
|
)
|
|
services.featureCode = 'chatplayground'
|
|
if hasattr(userInput, 'allowedProviders') and userInput.allowedProviders:
|
|
services.allowedProviders = userInput.allowedProviders
|
|
|
|
# Start or continue workflow
|
|
workflow = await chatStart(
|
|
context.user,
|
|
userInput,
|
|
workflowMode,
|
|
workflowId,
|
|
mandateId=mandateId,
|
|
featureInstanceId=instanceId,
|
|
featureCode='chatplayground',
|
|
services=services,
|
|
)
|
|
|
|
return workflow
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error in start_workflow: {str(e)}")
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail=str(e)
|
|
)
|
|
|
|
|
|
# Stop workflow endpoint (under /workflows/{workflowId}/ for consistency)
|
|
@router.post("/{instanceId}/workflows/{workflowId}/stop", response_model=ChatWorkflow)
|
|
@limiter.limit("120/minute")
|
|
async def stop_workflow(
|
|
request: Request,
|
|
instanceId: str = Path(..., description="Feature instance ID"),
|
|
workflowId: str = Path(..., description="ID of the workflow to stop"),
|
|
context: RequestContext = Depends(getRequestContext)
|
|
) -> ChatWorkflow:
|
|
"""Stops a running workflow."""
|
|
try:
|
|
# Validate access and get mandate ID
|
|
mandateId = _validateInstanceAccess(instanceId, context)
|
|
|
|
# Get chatplayground services from service center (not automation)
|
|
services = getChatplaygroundServices(
|
|
context.user,
|
|
mandateId=mandateId,
|
|
featureInstanceId=instanceId,
|
|
)
|
|
services.featureCode = 'chatplayground'
|
|
|
|
# Stop workflow (pass featureInstanceId for proper RBAC filtering)
|
|
workflow = await chatStop(
|
|
context.user,
|
|
workflowId,
|
|
mandateId=mandateId,
|
|
featureInstanceId=instanceId,
|
|
featureCode='chatplayground',
|
|
services=services,
|
|
)
|
|
|
|
return workflow
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error in stop_workflow: {str(e)}")
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail=str(e)
|
|
)
|
|
|
|
|
|
# Unified Chat Data Endpoint for Polling (under /workflows/{workflowId}/ for consistency)
|
|
@router.get("/{instanceId}/workflows/{workflowId}/chatData")
|
|
@limiter.limit("120/minute")
|
|
def get_workflow_chat_data(
|
|
request: Request,
|
|
instanceId: str = Path(..., description="Feature instance ID"),
|
|
workflowId: str = Path(..., description="ID of the workflow"),
|
|
afterTimestamp: Optional[float] = Query(None, description="Unix timestamp to get data after"),
|
|
context: RequestContext = Depends(getRequestContext)
|
|
) -> Dict[str, Any]:
|
|
"""
|
|
Get unified chat data (messages, logs, stats) for a workflow with timestamp-based selective data transfer.
|
|
Returns all data types in chronological order based on _createdAt timestamp.
|
|
"""
|
|
try:
|
|
# Validate access
|
|
_validateInstanceAccess(instanceId, context)
|
|
|
|
# Get service with feature instance context
|
|
chatInterface = _getServiceChat(context, featureInstanceId=instanceId)
|
|
|
|
# Verify workflow exists
|
|
workflow = chatInterface.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(
|
|
status_code=404,
|
|
detail=f"Workflow with ID {workflowId} not found"
|
|
)
|
|
|
|
# Get workflow cost from billing transactions (single source of truth)
|
|
billingInterface = _getBillingInterface(context.user, context.mandateId)
|
|
workflowCost = billingInterface.getWorkflowCost(workflowId)
|
|
|
|
chatData = chatInterface.getUnifiedChatData(workflowId, afterTimestamp, workflowCost=workflowCost)
|
|
return chatData
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting unified chat data: {str(e)}", exc_info=True)
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail=f"Error getting unified chat data: {str(e)}"
|
|
)
|
|
|
|
|
|
# Get workflow attributes (ChatWorkflow model)
|
|
@router.get("/{instanceId}/workflows/attributes", response_model=Dict[str, Any])
|
|
@limiter.limit("120/minute")
|
|
def get_workflow_attributes(
|
|
request: Request,
|
|
instanceId: str = Path(..., description="Feature instance ID"),
|
|
context: RequestContext = Depends(getRequestContext)
|
|
) -> Dict[str, Any]:
|
|
"""Get attribute definitions for ChatWorkflow model."""
|
|
_validateInstanceAccess(instanceId, context)
|
|
return {"attributes": workflowAttributes}
|
|
|
|
|
|
# Get workflows for this instance
|
|
@router.get("/{instanceId}/workflows", response_model=PaginatedResponse[ChatWorkflow])
|
|
@limiter.limit("120/minute")
|
|
def get_workflows(
|
|
request: Request,
|
|
instanceId: str = Path(..., description="Feature instance ID"),
|
|
pagination: Optional[str] = Query(None, description="JSON-encoded PaginationParams object"),
|
|
page: int = Query(1, ge=1, description="Page number (legacy)"),
|
|
pageSize: int = Query(20, ge=1, le=100, description="Items per page (legacy)"),
|
|
context: RequestContext = Depends(getRequestContext)
|
|
) -> PaginatedResponse[ChatWorkflow]:
|
|
"""
|
|
Get all workflows for this feature instance with optional pagination.
|
|
"""
|
|
try:
|
|
# Validate access
|
|
_validateInstanceAccess(instanceId, context)
|
|
|
|
# Get service with feature instance context
|
|
chatInterface = _getServiceChat(context, featureInstanceId=instanceId)
|
|
|
|
# Parse pagination parameter
|
|
paginationParams = None
|
|
if pagination:
|
|
try:
|
|
paginationDict = json.loads(pagination)
|
|
if paginationDict:
|
|
paginationDict = normalize_pagination_dict(paginationDict)
|
|
paginationParams = PaginationParams(**paginationDict)
|
|
except (json.JSONDecodeError, ValueError) as e:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=f"Invalid pagination parameter: {str(e)}"
|
|
)
|
|
else:
|
|
paginationParams = PaginationParams(page=page, pageSize=pageSize)
|
|
|
|
result = chatInterface.getWorkflows(pagination=paginationParams)
|
|
|
|
if paginationParams:
|
|
return PaginatedResponse(
|
|
items=result.items,
|
|
pagination=PaginationMetadata(
|
|
currentPage=paginationParams.page,
|
|
pageSize=paginationParams.pageSize,
|
|
totalItems=result.totalItems,
|
|
totalPages=result.totalPages,
|
|
sort=paginationParams.sort,
|
|
filters=paginationParams.filters
|
|
)
|
|
)
|
|
else:
|
|
return PaginatedResponse(items=result, pagination=None)
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting workflows: {str(e)}", exc_info=True)
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail=f"Error getting workflows: {str(e)}"
|
|
)
|
|
|
|
|
|
# Action Discovery Endpoints (must be before /{workflowId} to avoid path conflict)
|
|
@router.get("/{instanceId}/workflows/actions", response_model=Dict[str, Any])
|
|
@limiter.limit("120/minute")
|
|
def get_all_workflow_actions(
|
|
request: Request,
|
|
instanceId: str = Path(..., description="Feature instance ID"),
|
|
context: RequestContext = Depends(getRequestContext)
|
|
) -> Dict[str, Any]:
|
|
"""Get all available workflow actions for the current user (filtered by RBAC)."""
|
|
try:
|
|
mandateId = _validateInstanceAccess(instanceId, context)
|
|
services = getChatplaygroundServices(
|
|
context.user,
|
|
mandateId=mandateId,
|
|
featureInstanceId=instanceId,
|
|
)
|
|
from modules.workflows.processing.shared.methodDiscovery import discoverMethods, methods
|
|
discoverMethods(services)
|
|
allActions = []
|
|
for methodName, methodInfo in methods.items():
|
|
if methodName.startswith('Method'):
|
|
continue
|
|
methodInstance = methodInfo['instance']
|
|
methodActions = methodInstance.actions
|
|
for actionName, actionInfo in methodActions.items():
|
|
actionResponse = {
|
|
"module": methodInstance.name,
|
|
"actionId": f"{methodInstance.name}.{actionName}",
|
|
"name": actionName,
|
|
"description": actionInfo.get('description', ''),
|
|
"parameters": actionInfo.get('parameters', {})
|
|
}
|
|
allActions.append(actionResponse)
|
|
return {"actions": allActions}
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting all actions: {str(e)}", exc_info=True)
|
|
raise HTTPException(status_code=500, detail=f"Failed to get actions: {str(e)}")
|
|
|
|
|
|
@router.get("/{instanceId}/workflows/actions/{method}", response_model=Dict[str, Any])
|
|
@limiter.limit("120/minute")
|
|
def get_method_workflow_actions(
|
|
request: Request,
|
|
instanceId: str = Path(..., description="Feature instance ID"),
|
|
method: str = Path(..., description="Method name (e.g., 'outlook', 'sharepoint')"),
|
|
context: RequestContext = Depends(getRequestContext)
|
|
) -> Dict[str, Any]:
|
|
"""Get all available actions for a specific method."""
|
|
try:
|
|
mandateId = _validateInstanceAccess(instanceId, context)
|
|
services = getChatplaygroundServices(
|
|
context.user,
|
|
mandateId=mandateId,
|
|
featureInstanceId=instanceId,
|
|
)
|
|
from modules.workflows.processing.shared.methodDiscovery import discoverMethods, methods
|
|
discoverMethods(services)
|
|
methodInstance = None
|
|
for methodName, methodInfo in methods.items():
|
|
if methodInfo['instance'].name == method:
|
|
methodInstance = methodInfo['instance']
|
|
break
|
|
if not methodInstance:
|
|
raise HTTPException(status_code=404, detail=f"Method '{method}' not found")
|
|
actions = []
|
|
for actionName, actionInfo in methodInstance.actions.items():
|
|
actionResponse = {
|
|
"actionId": f"{methodInstance.name}.{actionName}",
|
|
"name": actionName,
|
|
"description": actionInfo.get('description', ''),
|
|
"parameters": actionInfo.get('parameters', {})
|
|
}
|
|
actions.append(actionResponse)
|
|
return {"module": methodInstance.name, "description": methodInstance.description, "actions": actions}
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting actions for method {method}: {str(e)}", exc_info=True)
|
|
raise HTTPException(status_code=500, detail=f"Failed to get actions for method {method}: {str(e)}")
|
|
|
|
|
|
@router.get("/{instanceId}/workflows/actions/{method}/{action}", response_model=Dict[str, Any])
|
|
@limiter.limit("120/minute")
|
|
def get_action_schema(
|
|
request: Request,
|
|
instanceId: str = Path(..., description="Feature instance ID"),
|
|
method: str = Path(..., description="Method name (e.g., 'outlook', 'sharepoint')"),
|
|
action: str = Path(..., description="Action name (e.g., 'readEmails', 'uploadDocument')"),
|
|
context: RequestContext = Depends(getRequestContext)
|
|
) -> Dict[str, Any]:
|
|
"""Get action schema with parameter definitions for a specific action."""
|
|
try:
|
|
mandateId = _validateInstanceAccess(instanceId, context)
|
|
services = getChatplaygroundServices(
|
|
context.user,
|
|
mandateId=mandateId,
|
|
featureInstanceId=instanceId,
|
|
)
|
|
from modules.workflows.processing.shared.methodDiscovery import discoverMethods, methods
|
|
discoverMethods(services)
|
|
methodInstance = None
|
|
for methodName, methodInfo in methods.items():
|
|
if methodInfo['instance'].name == method:
|
|
methodInstance = methodInfo['instance']
|
|
break
|
|
if not methodInstance:
|
|
raise HTTPException(status_code=404, detail=f"Method '{method}' not found")
|
|
methodActions = methodInstance.actions
|
|
if action not in methodActions:
|
|
raise HTTPException(status_code=404, detail=f"Action '{action}' not found in method '{method}'")
|
|
actionInfo = methodActions[action]
|
|
return {
|
|
"method": methodInstance.name,
|
|
"action": action,
|
|
"actionId": f"{methodInstance.name}.{action}",
|
|
"description": actionInfo.get('description', ''),
|
|
"parameters": actionInfo.get('parameters', {})
|
|
}
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting action schema for {method}.{action}: {str(e)}", exc_info=True)
|
|
raise HTTPException(status_code=500, detail=f"Failed to get action schema: {str(e)}")
|
|
|
|
|
|
# Get single workflow by ID
|
|
@router.get("/{instanceId}/workflows/{workflowId}", response_model=ChatWorkflow)
|
|
@limiter.limit("120/minute")
|
|
def get_workflow(
|
|
request: Request,
|
|
instanceId: str = Path(..., description="Feature instance ID"),
|
|
workflowId: str = Path(..., description="ID of the workflow"),
|
|
context: RequestContext = Depends(getRequestContext)
|
|
) -> ChatWorkflow:
|
|
"""Get workflow by ID."""
|
|
try:
|
|
_validateInstanceAccess(instanceId, context)
|
|
chatInterface = _getServiceChat(context, featureInstanceId=instanceId)
|
|
workflow = chatInterface.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(status_code=404, detail="Workflow not found")
|
|
return workflow
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting workflow: {str(e)}")
|
|
raise HTTPException(status_code=500, detail=f"Failed to get workflow: {str(e)}")
|
|
|
|
|
|
# Update workflow
|
|
@router.put("/{instanceId}/workflows/{workflowId}", response_model=ChatWorkflow)
|
|
@limiter.limit("120/minute")
|
|
def update_workflow(
|
|
request: Request,
|
|
instanceId: str = Path(..., description="Feature instance ID"),
|
|
workflowId: str = Path(..., description="ID of the workflow to update"),
|
|
workflowData: Dict[str, Any] = Body(...),
|
|
context: RequestContext = Depends(getRequestContext)
|
|
) -> ChatWorkflow:
|
|
"""Update workflow by ID."""
|
|
try:
|
|
_validateInstanceAccess(instanceId, context)
|
|
chatInterface = _getServiceChat(context, featureInstanceId=instanceId)
|
|
workflow = chatInterface.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(status_code=404, detail="Workflow not found")
|
|
if not chatInterface.checkRbacPermission(ChatWorkflow, "update", workflowId):
|
|
raise HTTPException(status_code=403, detail="You don't have permission to update this workflow")
|
|
updatedWorkflow = chatInterface.updateWorkflow(workflowId, workflowData)
|
|
if not updatedWorkflow:
|
|
raise HTTPException(status_code=500, detail="Failed to update workflow")
|
|
return updatedWorkflow
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error updating workflow: {str(e)}")
|
|
raise HTTPException(status_code=500, detail=f"Failed to update workflow: {str(e)}")
|
|
|
|
|
|
# Delete workflow
|
|
@router.delete("/{instanceId}/workflows/{workflowId}")
|
|
@limiter.limit("120/minute")
|
|
def delete_workflow(
|
|
request: Request,
|
|
instanceId: str = Path(..., description="Feature instance ID"),
|
|
workflowId: str = Path(..., description="ID of the workflow to delete"),
|
|
context: RequestContext = Depends(getRequestContext)
|
|
) -> Dict[str, Any]:
|
|
"""Deletes a workflow and its associated data."""
|
|
try:
|
|
_validateInstanceAccess(instanceId, context)
|
|
chatInterface = _getServiceChat(context, featureInstanceId=instanceId)
|
|
workflow = chatInterface.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(status_code=404, detail=f"Workflow with ID {workflowId} not found")
|
|
if not chatInterface.checkRbacPermission(ChatWorkflow, "delete", workflowId):
|
|
raise HTTPException(status_code=403, detail="You don't have permission to delete this workflow")
|
|
success = chatInterface.deleteWorkflow(workflowId)
|
|
if not success:
|
|
raise HTTPException(status_code=500, detail="Failed to delete workflow")
|
|
return {"id": workflowId, "message": "Workflow and associated data deleted successfully"}
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error deleting workflow: {str(e)}", exc_info=True)
|
|
raise HTTPException(status_code=500, detail=f"Error deleting workflow: {str(e)}")
|
|
|
|
|
|
# Get workflow status
|
|
@router.get("/{instanceId}/workflows/{workflowId}/status", response_model=ChatWorkflow)
|
|
@limiter.limit("120/minute")
|
|
def get_workflow_status(
|
|
request: Request,
|
|
instanceId: str = Path(..., description="Feature instance ID"),
|
|
workflowId: str = Path(..., description="ID of the workflow"),
|
|
context: RequestContext = Depends(getRequestContext)
|
|
) -> ChatWorkflow:
|
|
"""Get the current status of a workflow."""
|
|
try:
|
|
_validateInstanceAccess(instanceId, context)
|
|
chatInterface = _getServiceChat(context, featureInstanceId=instanceId)
|
|
workflow = chatInterface.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(status_code=404, detail=f"Workflow with ID {workflowId} not found")
|
|
return workflow
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting workflow status: {str(e)}", exc_info=True)
|
|
raise HTTPException(status_code=500, detail=f"Error getting workflow status: {str(e)}")
|
|
|
|
|
|
# Get workflow logs
|
|
@router.get("/{instanceId}/workflows/{workflowId}/logs", response_model=PaginatedResponse[ChatLog])
|
|
@limiter.limit("120/minute")
|
|
def get_workflow_logs(
|
|
request: Request,
|
|
instanceId: str = Path(..., description="Feature instance ID"),
|
|
workflowId: str = Path(..., description="ID of the workflow"),
|
|
logId: Optional[str] = Query(None, description="Optional log ID for selective data transfer"),
|
|
pagination: Optional[str] = Query(None, description="JSON-encoded PaginationParams object"),
|
|
context: RequestContext = Depends(getRequestContext)
|
|
) -> PaginatedResponse[ChatLog]:
|
|
"""Get logs for a workflow with optional pagination."""
|
|
try:
|
|
_validateInstanceAccess(instanceId, context)
|
|
chatInterface = _getServiceChat(context, featureInstanceId=instanceId)
|
|
workflow = chatInterface.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(status_code=404, detail=f"Workflow with ID {workflowId} not found")
|
|
|
|
paginationParams = None
|
|
if pagination:
|
|
try:
|
|
paginationDict = json.loads(pagination)
|
|
if paginationDict:
|
|
paginationDict = normalize_pagination_dict(paginationDict)
|
|
paginationParams = PaginationParams(**paginationDict)
|
|
except (json.JSONDecodeError, ValueError) as e:
|
|
raise HTTPException(status_code=400, detail=f"Invalid pagination parameter: {str(e)}")
|
|
|
|
result = chatInterface.getLogs(workflowId, pagination=paginationParams)
|
|
|
|
if logId:
|
|
allLogs = result.items if paginationParams else result
|
|
logIndex = next((i for i, log in enumerate(allLogs) if log.id == logId), -1)
|
|
if logIndex >= 0:
|
|
filteredLogs = allLogs[logIndex + 1:]
|
|
return PaginatedResponse(items=filteredLogs, pagination=None)
|
|
|
|
if paginationParams:
|
|
return PaginatedResponse(
|
|
items=result.items,
|
|
pagination=PaginationMetadata(
|
|
currentPage=paginationParams.page,
|
|
pageSize=paginationParams.pageSize,
|
|
totalItems=result.totalItems,
|
|
totalPages=result.totalPages,
|
|
sort=paginationParams.sort,
|
|
filters=paginationParams.filters
|
|
)
|
|
)
|
|
return PaginatedResponse(items=result, pagination=None)
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting workflow logs: {str(e)}", exc_info=True)
|
|
raise HTTPException(status_code=500, detail=f"Error getting workflow logs: {str(e)}")
|
|
|
|
|
|
# Get workflow messages
|
|
@router.get("/{instanceId}/workflows/{workflowId}/messages", response_model=PaginatedResponse[ChatMessage])
|
|
@limiter.limit("120/minute")
|
|
def get_workflow_messages(
|
|
request: Request,
|
|
instanceId: str = Path(..., description="Feature instance ID"),
|
|
workflowId: str = Path(..., description="ID of the workflow"),
|
|
messageId: Optional[str] = Query(None, description="Optional message ID for selective data transfer"),
|
|
pagination: Optional[str] = Query(None, description="JSON-encoded PaginationParams object"),
|
|
context: RequestContext = Depends(getRequestContext)
|
|
) -> PaginatedResponse[ChatMessage]:
|
|
"""Get messages for a workflow with optional pagination."""
|
|
try:
|
|
_validateInstanceAccess(instanceId, context)
|
|
chatInterface = _getServiceChat(context, featureInstanceId=instanceId)
|
|
workflow = chatInterface.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(status_code=404, detail=f"Workflow with ID {workflowId} not found")
|
|
|
|
paginationParams = None
|
|
if pagination:
|
|
try:
|
|
paginationDict = json.loads(pagination)
|
|
if paginationDict:
|
|
paginationDict = normalize_pagination_dict(paginationDict)
|
|
paginationParams = PaginationParams(**paginationDict)
|
|
except (json.JSONDecodeError, ValueError) as e:
|
|
raise HTTPException(status_code=400, detail=f"Invalid pagination parameter: {str(e)}")
|
|
|
|
result = chatInterface.getMessages(workflowId, pagination=paginationParams)
|
|
|
|
if messageId:
|
|
allMessages = result.items if paginationParams else result
|
|
messageIndex = next((i for i, msg in enumerate(allMessages) if msg.id == messageId), -1)
|
|
if messageIndex >= 0:
|
|
filteredMessages = allMessages[messageIndex + 1:]
|
|
return PaginatedResponse(items=filteredMessages, pagination=None)
|
|
|
|
if paginationParams:
|
|
return PaginatedResponse(
|
|
items=result.items,
|
|
pagination=PaginationMetadata(
|
|
currentPage=paginationParams.page,
|
|
pageSize=paginationParams.pageSize,
|
|
totalItems=result.totalItems,
|
|
totalPages=result.totalPages,
|
|
sort=paginationParams.sort,
|
|
filters=paginationParams.filters
|
|
)
|
|
)
|
|
return PaginatedResponse(items=result, pagination=None)
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting workflow messages: {str(e)}", exc_info=True)
|
|
raise HTTPException(status_code=500, detail=f"Error getting workflow messages: {str(e)}")
|
|
|
|
|
|
# Delete message from workflow
|
|
@router.delete("/{instanceId}/workflows/{workflowId}/messages/{messageId}")
|
|
@limiter.limit("120/minute")
|
|
def delete_workflow_message(
|
|
request: Request,
|
|
instanceId: str = Path(..., description="Feature instance ID"),
|
|
workflowId: str = Path(..., description="ID of the workflow"),
|
|
messageId: str = Path(..., description="ID of the message to delete"),
|
|
context: RequestContext = Depends(getRequestContext)
|
|
) -> Dict[str, Any]:
|
|
"""Delete a message from a workflow."""
|
|
try:
|
|
_validateInstanceAccess(instanceId, context)
|
|
chatInterface = _getServiceChat(context, featureInstanceId=instanceId)
|
|
workflow = chatInterface.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(status_code=404, detail=f"Workflow with ID {workflowId} not found")
|
|
success = chatInterface.deleteMessage(workflowId, messageId)
|
|
if not success:
|
|
raise HTTPException(status_code=404, detail=f"Message with ID {messageId} not found in workflow {workflowId}")
|
|
return {"workflowId": workflowId, "messageId": messageId, "message": "Message deleted successfully"}
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error deleting message: {str(e)}", exc_info=True)
|
|
raise HTTPException(status_code=500, detail=f"Error deleting message: {str(e)}")
|
|
|
|
|
|
# Delete file from message
|
|
@router.delete("/{instanceId}/workflows/{workflowId}/messages/{messageId}/files/{fileId}")
|
|
@limiter.limit("120/minute")
|
|
def delete_file_from_message(
|
|
request: Request,
|
|
instanceId: str = Path(..., description="Feature instance ID"),
|
|
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"),
|
|
context: RequestContext = Depends(getRequestContext)
|
|
) -> Dict[str, Any]:
|
|
"""Delete a file reference from a message in a workflow."""
|
|
try:
|
|
_validateInstanceAccess(instanceId, context)
|
|
chatInterface = _getServiceChat(context, featureInstanceId=instanceId)
|
|
workflow = chatInterface.getWorkflow(workflowId)
|
|
if not workflow:
|
|
raise HTTPException(status_code=404, detail=f"Workflow with ID {workflowId} not found")
|
|
success = chatInterface.deleteFileFromMessage(workflowId, messageId, fileId)
|
|
if not success:
|
|
raise HTTPException(status_code=404, 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:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error deleting file reference: {str(e)}", exc_info=True)
|
|
raise HTTPException(status_code=500, detail=f"Error deleting file reference: {str(e)}")
|