298 lines
12 KiB
Python
298 lines
12 KiB
Python
from typing import Annotated
|
|
|
|
from fastapi import APIRouter, File, HTTPException, Query, UploadFile, status
|
|
from fastapi.concurrency import run_in_threadpool
|
|
from fastapi.responses import FileResponse
|
|
from sqlalchemy import func, or_, select, update
|
|
|
|
from app.core.config import settings
|
|
from app.core.deps import AnyAdmin, DbSession
|
|
from app.models import Project, ProjectCategory, ProjectImage, ProjectStatus
|
|
from app.schemas.common import Page
|
|
from app.schemas.project import (
|
|
ProjectAdmin,
|
|
ProjectCreate,
|
|
ProjectImageAdmin,
|
|
ProjectImageUpdate,
|
|
ProjectPublicDetail,
|
|
ProjectPublicSummary,
|
|
ProjectUpdate,
|
|
UploadResult,
|
|
)
|
|
from app.services.image_processing import (
|
|
ImageValidationError,
|
|
StoredImage,
|
|
WatermarkUnavailableError,
|
|
delete_media_files,
|
|
load_logo,
|
|
process_image,
|
|
read_upload,
|
|
resolve_media_path,
|
|
)
|
|
from app.utils.helpers import escape_like, paginate, unique_slug
|
|
|
|
public_router = APIRouter(prefix="/projects", tags=["Projects"])
|
|
admin_router = APIRouter(prefix="/admin/projects", tags=["Admin: projects"])
|
|
images_router = APIRouter(prefix="/admin/project-images", tags=["Admin: project images"])
|
|
|
|
|
|
async def _load_project(db, project_id: int) -> Project:
|
|
project = await db.scalar(
|
|
select(Project).where(Project.id == project_id).execution_options(populate_existing=True)
|
|
)
|
|
if not project:
|
|
raise HTTPException(status.HTTP_404_NOT_FOUND, "Project not found")
|
|
return project
|
|
|
|
|
|
# ------------------------------------------------------------------ public
|
|
|
|
|
|
@public_router.get("", response_model=Page[ProjectPublicSummary], summary="Published projects")
|
|
async def list_published_projects(
|
|
db: DbSession,
|
|
category: ProjectCategory | None = None,
|
|
project_status: Annotated[ProjectStatus | None, Query(alias="status")] = None,
|
|
page: Annotated[int, Query(ge=1)] = 1,
|
|
page_size: Annotated[int, Query(ge=1, le=100)] = 12,
|
|
):
|
|
stmt = (
|
|
select(Project)
|
|
.where(Project.is_published.is_(True))
|
|
.order_by(Project.installation_date.desc().nulls_last(), Project.id.desc())
|
|
)
|
|
if category:
|
|
stmt = stmt.where(Project.category == category)
|
|
if project_status:
|
|
stmt = stmt.where(Project.status == project_status)
|
|
rows, total = await paginate(db, stmt, page, page_size)
|
|
return Page(items=[ProjectPublicSummary.build(p) for p in rows], total=total, page=page, page_size=page_size)
|
|
|
|
|
|
@public_router.get("/{id_or_slug}", response_model=ProjectPublicDetail, summary="Project by id or slug")
|
|
async def get_published_project(id_or_slug: str, db: DbSession):
|
|
cond = Project.id == int(id_or_slug) if id_or_slug.isdigit() else Project.slug == id_or_slug
|
|
project = await db.scalar(select(Project).where(cond, Project.is_published.is_(True)))
|
|
if not project:
|
|
raise HTTPException(status.HTTP_404_NOT_FOUND, "Project not found")
|
|
return ProjectPublicDetail.build(project)
|
|
|
|
|
|
# ------------------------------------------------------------------ admin CRUD
|
|
|
|
|
|
@admin_router.get("", response_model=Page[ProjectAdmin])
|
|
async def admin_list_projects(
|
|
_: AnyAdmin,
|
|
db: DbSession,
|
|
search: Annotated[str | None, Query(max_length=100)] = None,
|
|
category: ProjectCategory | None = None,
|
|
project_status: Annotated[ProjectStatus | None, Query(alias="status")] = None,
|
|
is_published: bool | None = None,
|
|
page: Annotated[int, Query(ge=1)] = 1,
|
|
page_size: Annotated[int, Query(ge=1, le=100)] = 20,
|
|
):
|
|
stmt = select(Project).order_by(Project.created_at.desc(), Project.id.desc())
|
|
if search and (term := search.strip()):
|
|
like = f"%{escape_like(term)}%"
|
|
stmt = stmt.where(or_(Project.title.ilike(like), Project.location.ilike(like)))
|
|
if category:
|
|
stmt = stmt.where(Project.category == category)
|
|
if project_status:
|
|
stmt = stmt.where(Project.status == project_status)
|
|
if is_published is not None:
|
|
stmt = stmt.where(Project.is_published.is_(is_published))
|
|
rows, total = await paginate(db, stmt, page, page_size)
|
|
return Page(items=[ProjectAdmin.build(p) for p in rows], total=total, page=page, page_size=page_size)
|
|
|
|
|
|
@admin_router.get("/{project_id}", response_model=ProjectAdmin)
|
|
async def admin_get_project(project_id: int, _: AnyAdmin, db: DbSession):
|
|
return ProjectAdmin.build(await _load_project(db, project_id))
|
|
|
|
|
|
@admin_router.post("", response_model=ProjectAdmin, status_code=status.HTTP_201_CREATED)
|
|
async def create_project(body: ProjectCreate, _: AnyAdmin, db: DbSession):
|
|
data = body.model_dump()
|
|
data["slug"] = await unique_slug(db, Project, data["slug"] or data["title"])
|
|
project = Project(**data)
|
|
db.add(project)
|
|
await db.commit()
|
|
return ProjectAdmin.build(await _load_project(db, project.id))
|
|
|
|
|
|
@admin_router.put("/{project_id}", response_model=ProjectAdmin)
|
|
async def update_project(project_id: int, body: ProjectUpdate, _: AnyAdmin, db: DbSession):
|
|
project = await _load_project(db, project_id)
|
|
data = body.model_dump(exclude_unset=True)
|
|
for required in ("title", "category", "status", "is_published"):
|
|
if required in data and data[required] is None:
|
|
raise HTTPException(status.HTTP_422_UNPROCESSABLE_CONTENT, f"'{required}' cannot be null")
|
|
if data.get("slug"):
|
|
data["slug"] = await unique_slug(db, Project, data["slug"], exclude_id=project.id)
|
|
else:
|
|
data.pop("slug", None)
|
|
for key, value in data.items():
|
|
setattr(project, key, value)
|
|
await db.commit()
|
|
return ProjectAdmin.build(await _load_project(db, project_id))
|
|
|
|
|
|
@admin_router.delete("/{project_id}", status_code=status.HTTP_204_NO_CONTENT)
|
|
async def delete_project(project_id: int, _: AnyAdmin, db: DbSession):
|
|
project = await _load_project(db, project_id)
|
|
files = [p for img in project.images for p in (img.original_path, img.watermarked_path, img.thumbnail_path)]
|
|
await db.delete(project)
|
|
await db.commit()
|
|
delete_media_files(*files) # only after the DB change succeeded
|
|
|
|
|
|
# ------------------------------------------------------------------ images
|
|
|
|
|
|
@admin_router.post(
|
|
"/{project_id}/images",
|
|
response_model=UploadResult,
|
|
status_code=status.HTTP_201_CREATED,
|
|
summary="Upload one or more photos (auto-watermarked)",
|
|
description=(
|
|
"Accepts JPG/JPEG/PNG/WEBP. Each file is validated, the original is stored privately, "
|
|
"a copy with the Saura Shakti logo watermark (bottom-right) is generated, plus a WEBP thumbnail. "
|
|
"If any file is invalid the whole batch is rejected and nothing is saved."
|
|
),
|
|
)
|
|
async def upload_project_images(
|
|
project_id: int,
|
|
_: AnyAdmin,
|
|
db: DbSession,
|
|
files: Annotated[list[UploadFile], File(description="Image files (field name: files)")],
|
|
):
|
|
project = await _load_project(db, project_id)
|
|
if not files:
|
|
raise HTTPException(status.HTTP_400_BAD_REQUEST, "No files uploaded")
|
|
if len(files) > settings.MAX_FILES_PER_UPLOAD:
|
|
raise HTTPException(
|
|
status.HTTP_400_BAD_REQUEST, f"Upload at most {settings.MAX_FILES_PER_UPLOAD} files at a time"
|
|
)
|
|
try:
|
|
load_logo()
|
|
except WatermarkUnavailableError as exc:
|
|
raise HTTPException(status.HTTP_503_SERVICE_UNAVAILABLE, str(exc)) from None
|
|
|
|
# 1. validate every file before touching disk
|
|
validated, errors, worst = [], [], status.HTTP_400_BAD_REQUEST
|
|
for f in files:
|
|
try:
|
|
validated.append(await read_upload(f))
|
|
except ImageValidationError as exc:
|
|
errors.append(exc.message)
|
|
worst = exc.status_code
|
|
if errors:
|
|
raise HTTPException(worst if len(errors) == 1 else status.HTTP_400_BAD_REQUEST, {"errors": errors})
|
|
|
|
# 2. process (watermark + thumbnail) off the event loop
|
|
stored: list[StoredImage] = []
|
|
try:
|
|
for v in validated:
|
|
stored.append(await run_in_threadpool(process_image, v))
|
|
|
|
next_order = (
|
|
await db.scalar(
|
|
select(func.coalesce(func.max(ProjectImage.sort_order), -1)).where(
|
|
ProjectImage.project_id == project.id
|
|
)
|
|
)
|
|
) + 1
|
|
has_featured = any(img.is_featured for img in project.images)
|
|
new_rows = []
|
|
for i, (v, s) in enumerate(zip(validated, stored, strict=True)):
|
|
row = ProjectImage(
|
|
project_id=project.id,
|
|
original_filename=v.original_filename,
|
|
original_path=s.original_path,
|
|
watermarked_path=s.watermarked_path,
|
|
thumbnail_path=s.thumbnail_path,
|
|
mime_type=s.mime_type,
|
|
file_size=s.file_size,
|
|
width=s.width,
|
|
height=s.height,
|
|
sort_order=next_order + i,
|
|
is_featured=not has_featured and i == 0,
|
|
)
|
|
db.add(row)
|
|
new_rows.append(row)
|
|
await db.commit()
|
|
except Exception:
|
|
await db.rollback()
|
|
delete_media_files(*[p for s in stored for p in (s.original_path, s.watermarked_path, s.thumbnail_path)])
|
|
raise
|
|
|
|
project = await _load_project(db, project_id)
|
|
ids = {r.id for r in new_rows}
|
|
return UploadResult(
|
|
uploaded=[ProjectImageAdmin.build(img) for img in project.images if img.id in ids],
|
|
project=ProjectAdmin.build(project),
|
|
)
|
|
|
|
|
|
async def _get_image(db, image_id: int) -> ProjectImage:
|
|
image = await db.get(ProjectImage, image_id)
|
|
if not image:
|
|
raise HTTPException(status.HTTP_404_NOT_FOUND, "Image not found")
|
|
return image
|
|
|
|
|
|
@images_router.patch("/{image_id}", response_model=ProjectAdmin, summary="Edit caption/order or set as featured")
|
|
async def update_project_image(image_id: int, body: ProjectImageUpdate, _: AnyAdmin, db: DbSession):
|
|
image = await _get_image(db, image_id)
|
|
data = body.model_dump(exclude_unset=True)
|
|
if data.get("is_featured") is True:
|
|
await db.execute(
|
|
update(ProjectImage)
|
|
.where(ProjectImage.project_id == image.project_id, ProjectImage.id != image.id)
|
|
.values(is_featured=False)
|
|
)
|
|
await db.flush()
|
|
for key, value in data.items():
|
|
if value is None and key in ("sort_order", "is_featured"):
|
|
continue
|
|
setattr(image, key, value)
|
|
await db.commit()
|
|
return ProjectAdmin.build(await _load_project(db, image.project_id))
|
|
|
|
|
|
@images_router.delete("/{image_id}", status_code=status.HTTP_204_NO_CONTENT)
|
|
async def delete_project_image(image_id: int, _: AnyAdmin, db: DbSession):
|
|
image = await _get_image(db, image_id)
|
|
project_id, was_featured = image.project_id, image.is_featured
|
|
files = (image.original_path, image.watermarked_path, image.thumbnail_path)
|
|
await db.delete(image)
|
|
await db.flush()
|
|
if was_featured: # promote the next image so the project keeps a cover photo
|
|
next_img = await db.scalar(
|
|
select(ProjectImage)
|
|
.where(ProjectImage.project_id == project_id)
|
|
.order_by(ProjectImage.sort_order, ProjectImage.id)
|
|
.limit(1)
|
|
)
|
|
if next_img:
|
|
next_img.is_featured = True
|
|
await db.commit()
|
|
delete_media_files(*files)
|
|
|
|
|
|
@images_router.get(
|
|
"/{image_id}/original",
|
|
response_class=FileResponse,
|
|
summary="Download the un-watermarked original (admin only)",
|
|
)
|
|
async def download_original(image_id: int, _: AnyAdmin, db: DbSession):
|
|
image = await _get_image(db, image_id)
|
|
try:
|
|
path = resolve_media_path(image.original_path)
|
|
except ValueError:
|
|
raise HTTPException(status.HTTP_404_NOT_FOUND, "File not found") from None
|
|
if not path.is_file():
|
|
raise HTTPException(status.HTTP_404_NOT_FOUND, "File not found")
|
|
return FileResponse(path, media_type=image.mime_type, filename=image.original_filename)
|