404 lines
14 KiB
Python
404 lines
14 KiB
Python
from fastapi import APIRouter, Depends, HTTPException
|
|
from typing import Any, Dict, Optional
|
|
from datetime import datetime
|
|
import json
|
|
from enum import Enum
|
|
from loguru import logger
|
|
from pydantic import BaseModel, Field
|
|
|
|
from sqlalchemy.orm import Session
|
|
from sqlalchemy.exc import SQLAlchemyError
|
|
|
|
from middleware.auth_middleware import get_current_user
|
|
from services.database import get_db
|
|
from services.today_workflow_service import get_or_create_daily_workflow_plan, update_task_status, _today_date_str
|
|
from models.daily_workflow_models import DailyWorkflowPlan, DailyWorkflowTask
|
|
import asyncio
|
|
from services.intelligence.txtai_service import TxtaiIntelligenceService
|
|
|
|
|
|
router = APIRouter(prefix="/api/today-workflow", tags=["Today Workflow"])
|
|
|
|
|
|
def _normalize_dependencies(dependencies: Any) -> list:
|
|
if dependencies is None:
|
|
return []
|
|
if isinstance(dependencies, list):
|
|
return dependencies
|
|
if isinstance(dependencies, str):
|
|
try:
|
|
parsed = json.loads(dependencies)
|
|
return parsed if isinstance(parsed, list) else []
|
|
except json.JSONDecodeError:
|
|
return []
|
|
return []
|
|
|
|
|
|
class TaskStatusEnum(str, Enum):
|
|
pending = "pending"
|
|
in_progress = "in_progress"
|
|
completed = "completed"
|
|
skipped = "skipped"
|
|
dismissed = "dismissed"
|
|
|
|
|
|
class TaskStatusUpdateRequest(BaseModel):
|
|
status: TaskStatusEnum = Field(..., description="New task status")
|
|
completion_notes: Optional[str] = Field(
|
|
None,
|
|
max_length=4000,
|
|
description="Optional notes about task completion or outcome",
|
|
)
|
|
|
|
async def _index_tasks_to_sif(user_id: str, date: str, tasks: list[dict], label: str):
|
|
"""Index tasks to SIF in background without blocking the main API response."""
|
|
try:
|
|
svc = TxtaiIntelligenceService(user_id)
|
|
items = []
|
|
for t in tasks:
|
|
task_id = t.get("id")
|
|
pillar_id = t.get("pillarId")
|
|
status = t.get("status")
|
|
title = t.get("title")
|
|
description = t.get("description")
|
|
text = f"[{pillar_id}] {title}\n{description}\nstatus={status}"
|
|
metadata = {
|
|
"type": "daily_workflow_task",
|
|
"date": date,
|
|
"label": label,
|
|
"pillar_id": pillar_id,
|
|
"status": status,
|
|
"implemented": status == "completed",
|
|
"dismissed": status == "skipped",
|
|
"task_id": task_id,
|
|
}
|
|
items.append((f"{label}_task:{user_id}:{date}:{task_id}", text, metadata))
|
|
|
|
# Index content without blocking - service will initialize in background if needed
|
|
await svc.index_content(items)
|
|
except Exception as e:
|
|
# Log but don't raise - indexing failures shouldn't crash the API
|
|
logger.debug(f"Background indexing failed for user {user_id}: {e}")
|
|
|
|
|
|
def _build_workflow_payload(user_id: str, plan: DailyWorkflowPlan, tasks: list[DailyWorkflowTask]) -> Dict[str, Any]:
|
|
response_tasks = []
|
|
for t in tasks:
|
|
response_tasks.append(
|
|
{
|
|
"id": str(t.id),
|
|
"pillarId": t.pillar_id,
|
|
"title": t.title,
|
|
"description": t.description,
|
|
"status": "skipped" if t.status == "dismissed" else t.status,
|
|
"priority": t.priority,
|
|
"estimatedTime": t.estimated_time,
|
|
"dependencies": _normalize_dependencies(t.dependencies),
|
|
"actionUrl": t.action_url,
|
|
"actionType": t.action_type,
|
|
"metadata": t.metadata_json or {},
|
|
"enabled": bool(t.enabled),
|
|
}
|
|
)
|
|
|
|
total = len(response_tasks)
|
|
completed = len([t for t in response_tasks if t["status"] in ("completed", "skipped")])
|
|
current_index = 0
|
|
for i, task in enumerate(response_tasks):
|
|
if task["status"] not in ("completed", "skipped"):
|
|
current_index = i
|
|
break
|
|
current_index = i
|
|
|
|
workflow_status = "not_started"
|
|
if completed > 0 and completed < total:
|
|
workflow_status = "in_progress"
|
|
elif total > 0 and completed == total:
|
|
workflow_status = "completed"
|
|
|
|
total_estimated = int(sum(int(t.get("estimatedTime") or 0) for t in response_tasks))
|
|
plan_json = plan.plan_json or {}
|
|
|
|
return {
|
|
"workflow": {
|
|
"id": f"daily-{user_id}-{plan.date}",
|
|
"date": plan.date,
|
|
"userId": user_id,
|
|
"tasks": response_tasks,
|
|
"currentTaskIndex": current_index,
|
|
"completedTasks": completed,
|
|
"totalTasks": total,
|
|
"workflowStatus": workflow_status,
|
|
"totalEstimatedTime": total_estimated,
|
|
"actualTimeSpent": 0,
|
|
},
|
|
"plan": {
|
|
"id": plan.id,
|
|
"date": plan.date,
|
|
"source": plan.source,
|
|
"generation_mode": plan.generation_mode,
|
|
"committee_agent_count": plan.committee_agent_count,
|
|
"fallback_used": bool(plan.fallback_used),
|
|
"quality_status": plan_json.get("quality_status", "contextual"),
|
|
"contextuality_validation": plan_json.get("contextuality_validation"),
|
|
"provenance_summary": {
|
|
"generationMode": plan.generation_mode,
|
|
"committeeAgentCount": plan.committee_agent_count,
|
|
"fallbackUsed": bool(plan.fallback_used),
|
|
"taskSourceBreakdown": {},
|
|
},
|
|
"created_at": plan.created_at.isoformat() if plan.created_at else None,
|
|
"updated_at": plan.updated_at.isoformat() if plan.updated_at else None,
|
|
},
|
|
"schedule_status": {
|
|
"date": plan.date,
|
|
"generated": True,
|
|
"scheduled_run_completed": plan.source == "scheduled",
|
|
"source": plan.source,
|
|
"created_at": plan.created_at.isoformat() if plan.created_at else None,
|
|
},
|
|
}
|
|
|
|
|
|
@router.get("")
|
|
async def get_today_workflow(
|
|
date: Optional[str] = None,
|
|
current_user: dict = Depends(get_current_user),
|
|
db: Session = Depends(get_db),
|
|
) -> Dict[str, Any]:
|
|
"""Get existing daily workflow for the specified date.
|
|
Returns 404 if no workflow exists for the date.
|
|
Workflow should only be created via explicit user action or scheduled job.
|
|
"""
|
|
from starlette.concurrency import run_in_threadpool
|
|
user_id = str(current_user.get("id"))
|
|
date_str = date or _today_date_str()
|
|
|
|
def _get_existing():
|
|
return (
|
|
db.query(DailyWorkflowPlan)
|
|
.filter(DailyWorkflowPlan.user_id == user_id, DailyWorkflowPlan.date == date_str)
|
|
.first()
|
|
)
|
|
|
|
plan = await run_in_threadpool(_get_existing)
|
|
|
|
if not plan:
|
|
raise HTTPException(
|
|
status_code=404,
|
|
detail=f"No workflow found for date {date_str}. Workflow should be generated via explicit user action or scheduled job."
|
|
)
|
|
|
|
def _fetch_tasks():
|
|
return (
|
|
db.query(DailyWorkflowTask)
|
|
.filter(DailyWorkflowTask.plan_id == plan.id, DailyWorkflowTask.user_id == user_id)
|
|
.order_by(DailyWorkflowTask.created_at.asc())
|
|
.all()
|
|
)
|
|
|
|
tasks = await run_in_threadpool(_fetch_tasks)
|
|
|
|
return {
|
|
"success": True,
|
|
"data": _build_workflow_payload(user_id, plan, tasks),
|
|
"timestamp": datetime.utcnow().isoformat(),
|
|
"user_id": user_id,
|
|
}
|
|
|
|
|
|
@router.get("/status")
|
|
async def get_today_workflow_status(
|
|
date: Optional[str] = None,
|
|
current_user: dict = Depends(get_current_user),
|
|
db: Session = Depends(get_db),
|
|
) -> Dict[str, Any]:
|
|
from starlette.concurrency import run_in_threadpool
|
|
|
|
user_id = str(current_user.get("id"))
|
|
date_str = date or _today_date_str()
|
|
|
|
def _get_existing():
|
|
return (
|
|
db.query(DailyWorkflowPlan)
|
|
.filter(DailyWorkflowPlan.user_id == user_id, DailyWorkflowPlan.date == date_str)
|
|
.first()
|
|
)
|
|
|
|
plan = await run_in_threadpool(_get_existing)
|
|
|
|
return {
|
|
"success": True,
|
|
"data": {
|
|
"date": date_str,
|
|
"generated": plan is not None,
|
|
"scheduled_run_completed": bool(plan and plan.source == "scheduled"),
|
|
"source": plan.source if plan else None,
|
|
"created_at": plan.created_at.isoformat() if plan and plan.created_at else None,
|
|
},
|
|
"timestamp": datetime.utcnow().isoformat(),
|
|
"user_id": user_id,
|
|
}
|
|
|
|
|
|
@router.post("/generate")
|
|
async def generate_workflow(
|
|
date: Optional[str] = None,
|
|
current_user: dict = Depends(get_current_user),
|
|
db: Session = Depends(get_db),
|
|
) -> Dict[str, Any]:
|
|
"""Explicitly generate a new daily workflow for the specified date.
|
|
This should only be called when the user explicitly requests workflow generation
|
|
or via a scheduled job at night.
|
|
"""
|
|
from starlette.concurrency import run_in_threadpool
|
|
user_id = str(current_user.get("id"))
|
|
plan, created = await get_or_create_daily_workflow_plan(db, user_id, date=date, creation_source="manual")
|
|
|
|
def _fetch_tasks():
|
|
return (
|
|
db.query(DailyWorkflowTask)
|
|
.filter(DailyWorkflowTask.plan_id == plan.id, DailyWorkflowTask.user_id == user_id)
|
|
.order_by(DailyWorkflowTask.created_at.asc())
|
|
.all()
|
|
)
|
|
|
|
tasks = await run_in_threadpool(_fetch_tasks)
|
|
|
|
if created:
|
|
response_tasks = _build_workflow_payload(user_id, plan, tasks)["workflow"]["tasks"]
|
|
asyncio.create_task(_index_tasks_to_sif(user_id, plan.date, response_tasks, label="today"))
|
|
from datetime import date as date_type, timedelta
|
|
|
|
try:
|
|
parsed_plan_date = date_type.fromisoformat(plan.date)
|
|
except ValueError:
|
|
logger.warning(
|
|
"Invalid plan.date format; skipping yesterday indexing plan_id={} user_id={} plan_date={} reason={}",
|
|
plan.id,
|
|
user_id,
|
|
plan.date,
|
|
"plan.date is not in ISO format YYYY-MM-DD",
|
|
)
|
|
else:
|
|
y_str = (parsed_plan_date - timedelta(days=1)).isoformat()
|
|
|
|
def _fetch_yesterday():
|
|
y_plan = (
|
|
db.query(DailyWorkflowPlan)
|
|
.filter(DailyWorkflowPlan.user_id == user_id, DailyWorkflowPlan.date == y_str)
|
|
.first()
|
|
)
|
|
if y_plan:
|
|
y_tasks = (
|
|
db.query(DailyWorkflowTask)
|
|
.filter(DailyWorkflowTask.plan_id == y_plan.id, DailyWorkflowTask.user_id == user_id)
|
|
.order_by(DailyWorkflowTask.created_at.asc())
|
|
.all()
|
|
)
|
|
return y_tasks
|
|
return []
|
|
|
|
try:
|
|
y_tasks = await run_in_threadpool(_fetch_yesterday)
|
|
except SQLAlchemyError as db_error:
|
|
logger.warning(
|
|
"Failed to fetch yesterday tasks; skipping yesterday indexing plan_id={} user_id={} plan_date={} yesterday_date={} error_class={} error_message={}",
|
|
plan.id,
|
|
user_id,
|
|
plan.date,
|
|
y_str,
|
|
type(db_error).__name__,
|
|
str(db_error),
|
|
)
|
|
else:
|
|
if y_tasks:
|
|
y_response = []
|
|
for t in y_tasks:
|
|
y_response.append(
|
|
{
|
|
"id": str(t.id),
|
|
"pillarId": t.pillar_id,
|
|
"title": t.title,
|
|
"description": t.description,
|
|
"status": "skipped" if t.status == "dismissed" else t.status,
|
|
"dependencies": _normalize_dependencies(t.dependencies),
|
|
}
|
|
)
|
|
asyncio.create_task(_index_tasks_to_sif(user_id, y_str, y_response, label="yesterday"))
|
|
|
|
return {
|
|
"success": True,
|
|
"data": _build_workflow_payload(user_id, plan, tasks),
|
|
"timestamp": datetime.utcnow().isoformat(),
|
|
"user_id": user_id,
|
|
}
|
|
|
|
|
|
from services.task_memory_service import TaskMemoryService
|
|
|
|
@router.post("/tasks/{task_id}/status")
|
|
async def set_task_status(
|
|
task_id: int,
|
|
body: TaskStatusUpdateRequest,
|
|
current_user: dict = Depends(get_current_user),
|
|
db: Session = Depends(get_db),
|
|
) -> Dict[str, Any]:
|
|
user_id = str(current_user.get("id"))
|
|
status = body.status.value
|
|
completion_notes = body.completion_notes
|
|
|
|
task = update_task_status(db, user_id, task_id, status=status, completion_notes=completion_notes)
|
|
if not task:
|
|
raise HTTPException(status_code=404, detail="Task not found")
|
|
|
|
# Record outcome in memory for self-learning
|
|
try:
|
|
memory = TaskMemoryService(user_id, db)
|
|
normalized_status = (task.status or "").lower()
|
|
if normalized_status == "completed":
|
|
feedback_score = 1
|
|
elif normalized_status in {"skipped", "dismissed", "rejected"}:
|
|
feedback_score = -1
|
|
else:
|
|
feedback_score = 0
|
|
|
|
await memory.record_task_outcome(
|
|
task,
|
|
feedback_score=feedback_score,
|
|
feedback_text=completion_notes,
|
|
)
|
|
except Exception as e:
|
|
logger.warning(
|
|
"Task memory outcome recording failed for user_id={} task_id={} error_class={} error_message={}",
|
|
user_id,
|
|
task_id,
|
|
type(e).__name__,
|
|
str(e),
|
|
)
|
|
|
|
plan_for_date = db.query(DailyWorkflowPlan).filter(DailyWorkflowPlan.id == task.plan_id).first()
|
|
plan_date = plan_for_date.date if plan_for_date and plan_for_date.date else ""
|
|
task_payload = {
|
|
"id": str(task.id),
|
|
"pillarId": task.pillar_id,
|
|
"title": task.title,
|
|
"description": task.description,
|
|
"status": "skipped" if task.status == "dismissed" else task.status,
|
|
}
|
|
asyncio.create_task(_index_tasks_to_sif(user_id, plan_date, [task_payload], label="today"))
|
|
|
|
return {
|
|
"success": True,
|
|
"data": {
|
|
"task": {
|
|
"id": str(task.id),
|
|
"pillarId": task.pillar_id,
|
|
"status": "skipped" if task.status == "dismissed" else task.status,
|
|
"decided_at": task.decided_at.isoformat() if task.decided_at else None,
|
|
}
|
|
},
|
|
"timestamp": datetime.utcnow().isoformat(),
|
|
"user_id": user_id,
|
|
}
|