Daniil
125 lines
4.2 KiB
Python
125 lines
4.2 KiB
Python
from __future__ import annotations
|
|
|
|
import uuid
|
|
|
|
from sqlalchemy import Select, select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from cpv3.modules.media.models import ArtifactMediaFile, MediaFile
|
|
from cpv3.modules.media.schemas import (
|
|
ArtifactMediaFileCreate,
|
|
ArtifactMediaFileUpdate,
|
|
MediaFileCreate,
|
|
MediaFileUpdate,
|
|
)
|
|
from cpv3.modules.users.models import User
|
|
|
|
|
|
class MediaFileRepository:
|
|
"""Repository for MediaFile database operations."""
|
|
|
|
def __init__(self, session: AsyncSession) -> None:
|
|
self._session = session
|
|
|
|
async def list_all(self, *, requester: User) -> list[MediaFile]:
|
|
stmt: Select[tuple[MediaFile]] = select(MediaFile).where(
|
|
MediaFile.is_deleted.is_(False)
|
|
)
|
|
if not requester.is_staff:
|
|
stmt = stmt.where(MediaFile.owner_id == requester.id)
|
|
|
|
result = await self._session.execute(stmt.order_by(MediaFile.created_at.desc()))
|
|
return list(result.scalars().all())
|
|
|
|
async def get_by_id(self, media_file_id: uuid.UUID) -> MediaFile | None:
|
|
result = await self._session.execute(
|
|
select(MediaFile).where(MediaFile.id == media_file_id)
|
|
)
|
|
media_file = result.scalar_one_or_none()
|
|
if media_file is None or media_file.is_deleted:
|
|
return None
|
|
return media_file
|
|
|
|
async def create(self, *, requester: User, data: MediaFileCreate) -> MediaFile:
|
|
media_file = MediaFile(
|
|
owner_id=requester.id,
|
|
project_id=data.project_id,
|
|
duration_seconds=data.duration_seconds,
|
|
frame_rate=data.frame_rate,
|
|
width=data.width,
|
|
height=data.height,
|
|
probe_json=data.probe_json,
|
|
notes=data.notes,
|
|
meta=data.meta,
|
|
)
|
|
|
|
self._session.add(media_file)
|
|
await self._session.commit()
|
|
await self._session.refresh(media_file)
|
|
return media_file
|
|
|
|
async def update(self, media_file: MediaFile, data: MediaFileUpdate) -> MediaFile:
|
|
for key, value in data.model_dump(exclude_unset=True).items():
|
|
if value is not None:
|
|
setattr(media_file, key, value)
|
|
|
|
await self._session.commit()
|
|
await self._session.refresh(media_file)
|
|
return media_file
|
|
|
|
async def mark_deleted(self, media_file: MediaFile) -> None:
|
|
media_file.is_deleted = True
|
|
await self._session.commit()
|
|
|
|
|
|
class ArtifactRepository:
|
|
"""Repository for ArtifactMediaFile database operations."""
|
|
|
|
def __init__(self, session: AsyncSession) -> None:
|
|
self._session = session
|
|
|
|
async def list_all(self) -> list[ArtifactMediaFile]:
|
|
result = await self._session.execute(
|
|
select(ArtifactMediaFile)
|
|
.where(ArtifactMediaFile.is_deleted.is_(False))
|
|
.order_by(ArtifactMediaFile.created_at.desc())
|
|
)
|
|
return list(result.scalars().all())
|
|
|
|
async def get_by_id(self, artifact_id: uuid.UUID) -> ArtifactMediaFile | None:
|
|
result = await self._session.execute(
|
|
select(ArtifactMediaFile).where(ArtifactMediaFile.id == artifact_id)
|
|
)
|
|
artifact = result.scalar_one_or_none()
|
|
if artifact is None or artifact.is_deleted:
|
|
return None
|
|
return artifact
|
|
|
|
async def create(self, data: ArtifactMediaFileCreate) -> ArtifactMediaFile:
|
|
artifact = ArtifactMediaFile(
|
|
project_id=data.project_id,
|
|
file_id=data.file_id,
|
|
media_file_id=data.media_file_id,
|
|
artifact_type=data.artifact_type,
|
|
)
|
|
|
|
self._session.add(artifact)
|
|
await self._session.commit()
|
|
await self._session.refresh(artifact)
|
|
return artifact
|
|
|
|
async def update(
|
|
self, artifact: ArtifactMediaFile, data: ArtifactMediaFileUpdate
|
|
) -> ArtifactMediaFile:
|
|
for key, value in data.model_dump(exclude_unset=True).items():
|
|
if value is not None:
|
|
setattr(artifact, key, value)
|
|
|
|
await self._session.commit()
|
|
await self._session.refresh(artifact)
|
|
return artifact
|
|
|
|
async def mark_deleted(self, artifact: ArtifactMediaFile) -> None:
|
|
artifact.is_deleted = True
|
|
await self._session.commit()
|