zl-q
3ac09475ad
- Add voice recording with transcribe endpoint (ASR) for multimodal input - Android: add RECORD_AUDIO and INTERNET permissions - Refactor tool naming: frontend tools use 'front.' prefix, backend tools use 'back.' - Migrate calendar tools: create_calendar_event -> back.mutate/list/delete events - Add calendar_event_list.v1 and calendar_operation.v1 UI card types - Update all Flutter and Python tests to match new tool naming conventions - Add record package dependency for voice recording
293 lines
10 KiB
Python
293 lines
10 KiB
Python
from __future__ import annotations
|
|
|
|
import json
|
|
from typing import TYPE_CHECKING, Protocol
|
|
from uuid import UUID
|
|
|
|
from fastapi import HTTPException
|
|
from sqlalchemy.exc import SQLAlchemyError
|
|
|
|
from core.auth.models import CurrentUser
|
|
from core.db.base_service import BaseService
|
|
from core.logging import get_logger
|
|
from models.inbox_messages import InboxMessage, InboxMessageType
|
|
from models.schedule_items import ScheduleItem
|
|
from v1.auth.gateway import SupabaseAuthGateway
|
|
from v1.schedule_items.repository import ScheduleItemRepository
|
|
from v1.schedule_items.schemas import (
|
|
ScheduleItemCreateRequest,
|
|
ScheduleItemListRequest,
|
|
ScheduleItemMetadata,
|
|
ScheduleItemResponse,
|
|
ScheduleItemShareRequest,
|
|
ScheduleItemShareResponse,
|
|
ScheduleItemUpdateRequest,
|
|
ScheduleItemSourceType,
|
|
ScheduleItemStatus,
|
|
)
|
|
|
|
if TYPE_CHECKING:
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from v1.auth.schemas import UserByEmailResponse
|
|
|
|
logger = get_logger("v1.schedule_items.service")
|
|
|
|
|
|
class AuthByEmailGateway(Protocol):
|
|
async def get_user_by_email(self, email: str) -> "UserByEmailResponse": ...
|
|
|
|
|
|
class ScheduleItemService(BaseService):
|
|
_repository: ScheduleItemRepository
|
|
_session: AsyncSession
|
|
_auth_gateway: AuthByEmailGateway
|
|
|
|
def __init__(
|
|
self,
|
|
repository: ScheduleItemRepository,
|
|
session: AsyncSession,
|
|
current_user: CurrentUser | None,
|
|
auth_gateway: AuthByEmailGateway | None = None,
|
|
) -> None:
|
|
super().__init__(current_user=current_user)
|
|
self._repository = repository
|
|
self._session = session
|
|
self._auth_gateway = auth_gateway or SupabaseAuthGateway()
|
|
|
|
async def create(self, request: ScheduleItemCreateRequest) -> ScheduleItemResponse:
|
|
return await self._create_with_source(
|
|
request=request,
|
|
source_type=ScheduleItemSourceType.MANUAL,
|
|
)
|
|
|
|
async def create_agent_generated(
|
|
self, request: ScheduleItemCreateRequest
|
|
) -> ScheduleItemResponse:
|
|
return await self._create_with_source(
|
|
request=request,
|
|
source_type=ScheduleItemSourceType.AGENT_GENERATED,
|
|
)
|
|
|
|
async def _create_with_source(
|
|
self,
|
|
*,
|
|
request: ScheduleItemCreateRequest,
|
|
source_type: ScheduleItemSourceType,
|
|
) -> ScheduleItemResponse:
|
|
user_id = self.require_user_id()
|
|
|
|
if request.end_at and request.end_at <= request.start_at:
|
|
raise HTTPException(status_code=400, detail="end_at must be after start_at")
|
|
|
|
data = {
|
|
"owner_id": user_id,
|
|
"title": request.title,
|
|
"description": request.description,
|
|
"start_at": request.start_at,
|
|
"end_at": request.end_at,
|
|
"timezone": request.timezone,
|
|
"metadata": request.metadata.model_dump() if request.metadata else {},
|
|
"source_type": source_type,
|
|
"status": ScheduleItemStatus.ACTIVE,
|
|
"created_by": user_id,
|
|
}
|
|
|
|
try:
|
|
item = await self._repository.create(data)
|
|
await self._session.commit()
|
|
except SQLAlchemyError:
|
|
await self._session.rollback()
|
|
logger.exception("Failed to create schedule item")
|
|
raise HTTPException(
|
|
status_code=503, detail="Schedule item store unavailable"
|
|
)
|
|
|
|
return self._to_response(item)
|
|
|
|
async def get_by_id(self, item_id: UUID) -> ScheduleItemResponse:
|
|
user_id = self.require_user_id()
|
|
|
|
try:
|
|
item = await self._repository.get_by_item_id(item_id, user_id)
|
|
except SQLAlchemyError:
|
|
logger.exception("Failed to get schedule item", item_id=str(item_id))
|
|
raise HTTPException(
|
|
status_code=503, detail="Schedule item store unavailable"
|
|
)
|
|
|
|
if item is None:
|
|
raise HTTPException(status_code=404, detail="Schedule item not found")
|
|
|
|
return self._to_response(item)
|
|
|
|
async def update(
|
|
self, item_id: UUID, request: ScheduleItemUpdateRequest
|
|
) -> ScheduleItemResponse:
|
|
user_id = self.require_user_id()
|
|
|
|
try:
|
|
existing = await self._repository.get_by_item_id(item_id, user_id)
|
|
if existing is None:
|
|
raise HTTPException(status_code=404, detail="Schedule item not found")
|
|
|
|
# Build update dict from non-null fields
|
|
update_data = request.model_dump(exclude_unset=True)
|
|
|
|
# Handle metadata separately (model_dump returns dict)
|
|
if "metadata" in update_data and update_data["metadata"] is not None:
|
|
update_data["metadata"] = update_data["metadata"].model_dump()
|
|
|
|
# Validate time range
|
|
next_start = update_data.get("start_at", existing.start_at)
|
|
next_end = update_data.get("end_at", existing.end_at)
|
|
if next_end is not None and next_end <= next_start:
|
|
raise HTTPException(
|
|
status_code=400, detail="end_at must be after start_at"
|
|
)
|
|
|
|
if not update_data:
|
|
return self._to_response(existing)
|
|
|
|
item = await self._repository.update_by_item_id(
|
|
item_id, user_id, update_data
|
|
)
|
|
await self._session.commit()
|
|
except SQLAlchemyError:
|
|
await self._session.rollback()
|
|
logger.exception("Failed to update schedule item", item_id=str(item_id))
|
|
raise HTTPException(
|
|
status_code=503, detail="Schedule item store unavailable"
|
|
)
|
|
|
|
if item is None:
|
|
raise HTTPException(status_code=404, detail="Schedule item not found")
|
|
|
|
return self._to_response(item)
|
|
|
|
async def delete(self, item_id: UUID) -> None:
|
|
user_id = self.require_user_id()
|
|
|
|
try:
|
|
existing = await self._repository.get_by_item_id(item_id, user_id)
|
|
if existing is None:
|
|
raise HTTPException(status_code=404, detail="Schedule item not found")
|
|
|
|
await self._repository.delete_by_item_id(item_id, user_id)
|
|
await self._session.commit()
|
|
except SQLAlchemyError:
|
|
await self._session.rollback()
|
|
logger.exception("Failed to delete schedule item", item_id=str(item_id))
|
|
raise HTTPException(
|
|
status_code=503, detail="Schedule item store unavailable"
|
|
)
|
|
|
|
async def list_by_date_range(
|
|
self, request: ScheduleItemListRequest
|
|
) -> list[ScheduleItemResponse]:
|
|
user_id = self.require_user_id()
|
|
|
|
if request.end_at <= request.start_at:
|
|
raise HTTPException(status_code=400, detail="end_at must be after start_at")
|
|
|
|
try:
|
|
items = await self._repository.list_by_date_range(
|
|
user_id, request.start_at, request.end_at
|
|
)
|
|
except SQLAlchemyError:
|
|
logger.exception("Failed to list schedule items")
|
|
raise HTTPException(
|
|
status_code=503, detail="Schedule item store unavailable"
|
|
)
|
|
|
|
return [self._to_response(item) for item in items]
|
|
|
|
async def list_paginated(
|
|
self,
|
|
*,
|
|
page: int,
|
|
page_size: int,
|
|
) -> tuple[list[ScheduleItemResponse], int]:
|
|
user_id = self.require_user_id()
|
|
if page < 1:
|
|
raise HTTPException(status_code=400, detail="page must be >= 1")
|
|
if page_size < 1 or page_size > 100:
|
|
raise HTTPException(status_code=400, detail="page_size must be 1..100")
|
|
try:
|
|
items, total = await self._repository.list_paginated(
|
|
user_id,
|
|
page=page,
|
|
page_size=page_size,
|
|
)
|
|
except SQLAlchemyError:
|
|
logger.exception(
|
|
"Failed to list schedule items with pagination",
|
|
page=page,
|
|
page_size=page_size,
|
|
)
|
|
raise HTTPException(
|
|
status_code=503, detail="Schedule item store unavailable"
|
|
)
|
|
return [self._to_response(item) for item in items], total
|
|
|
|
async def share(
|
|
self, item_id: UUID, request: ScheduleItemShareRequest
|
|
) -> ScheduleItemShareResponse:
|
|
user_id = self.require_user_id()
|
|
|
|
try:
|
|
item = await self._repository.get_by_id(item_id)
|
|
if item is None:
|
|
raise HTTPException(status_code=404, detail="Schedule item not found")
|
|
if item.owner_id != user_id:
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="Only owner can share this schedule item",
|
|
)
|
|
|
|
target_user = await self._auth_gateway.get_user_by_email(request.email)
|
|
recipient_id = UUID(target_user.id)
|
|
message = InboxMessage(
|
|
recipient_id=recipient_id,
|
|
sender_id=user_id,
|
|
message_type=InboxMessageType.CALENDAR,
|
|
schedule_item_id=item.id,
|
|
content=json.dumps({"permission": request._permission_value()}),
|
|
created_by=user_id,
|
|
)
|
|
self._session.add(message)
|
|
await self._session.commit()
|
|
except HTTPException:
|
|
raise
|
|
except SQLAlchemyError:
|
|
await self._session.rollback()
|
|
logger.exception("Failed to share schedule item", item_id=str(item_id))
|
|
raise HTTPException(
|
|
status_code=503, detail="Schedule item store unavailable"
|
|
)
|
|
except ValueError:
|
|
await self._session.rollback()
|
|
logger.exception(
|
|
"Auth lookup returned invalid user id", email=request.email
|
|
)
|
|
raise HTTPException(status_code=503, detail="Auth lookup unavailable")
|
|
|
|
return ScheduleItemShareResponse(message="Calendar invitation sent")
|
|
|
|
def _to_response(self, item: ScheduleItem) -> ScheduleItemResponse:
|
|
return ScheduleItemResponse(
|
|
id=item.id,
|
|
title=item.title,
|
|
description=item.description,
|
|
start_at=item.start_at,
|
|
end_at=item.end_at,
|
|
timezone=item.timezone,
|
|
metadata=ScheduleItemMetadata.model_validate(item.extra_metadata)
|
|
if item.extra_metadata
|
|
else None,
|
|
status=ScheduleItemStatus(item.status.value),
|
|
source_type=ScheduleItemSourceType(item.source_type.value),
|
|
created_at=item.created_at,
|
|
updated_at=item.updated_at,
|
|
)
|