Files
mtusi2026lab5/app/storage/attachments.py
T
2026-11-07 16:10:32 +03:00

100 lines
3.0 KiB
Python

"""SQL-запросы метаданных и журнала; commit выполняется в domain."""
from datetime import timedelta
from uuid import UUID
from sqlalchemy import delete, func, select
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.attachment import Attachment, MessageAttachment, UploadIntent
async def create_attachment(session: AsyncSession, **values) -> Attachment:
record = Attachment(**values)
session.add(record)
await session.flush()
return record
async def get_attachment(
session: AsyncSession, attachment_id: UUID
) -> Attachment | None:
return await session.get(Attachment, attachment_id)
async def get_by_key(session: AsyncSession, key: str) -> Attachment | None:
return await session.scalar(select(Attachment).where(Attachment.object_key == key))
async def get_for_chat(
session: AsyncSession, chat_id: UUID, attachment_ids: list[UUID]
) -> list[Attachment]:
records = []
if attachment_ids:
records = list(
await session.scalars(
select(Attachment).where(
Attachment.id.in_(attachment_ids),
Attachment.chat_id == chat_id,
)
)
)
return records
async def bind_attachments(
session: AsyncSession, message_id: UUID, attachment_ids: list[UUID]
) -> None:
session.add_all(
MessageAttachment(message_id=message_id, attachment_id=id, position=position)
for position, id in enumerate(attachment_ids)
)
await session.flush()
async def message_attachment_ids(
session: AsyncSession, message_ids: list[UUID]
) -> dict[UUID, list[UUID]]:
result: dict[UUID, list[UUID]] = {id: [] for id in message_ids}
if not message_ids:
return result
rows = await session.execute(
select(MessageAttachment)
.where(MessageAttachment.message_id.in_(message_ids))
.order_by(MessageAttachment.position)
)
for link in rows.scalars():
result[link.message_id].append(link.attachment_id)
return result
async def reserve_upload(session: AsyncSession, id: UUID, key: str) -> None:
session.add(UploadIntent(id=id, object_key=key))
await session.flush()
async def lock_upload(session: AsyncSession, id: UUID) -> UploadIntent | None:
return await session.scalar(
select(UploadIntent).where(UploadIntent.id == id).with_for_update()
)
async def finish_upload(session: AsyncSession, id: UUID) -> None:
await session.execute(delete(UploadIntent).where(UploadIntent.id == id))
async def stale_uploads(
session: AsyncSession, grace_seconds: int, limit: int
) -> list[UploadIntent]:
result = await session.scalars(
select(UploadIntent)
.where(
UploadIntent.created_at
< func.clock_timestamp() - timedelta(seconds=grace_seconds),
)
.order_by(UploadIntent.created_at)
.limit(limit)
.with_for_update(skip_locked=True)
)
return list(result)