Files
saura_shakti_website/backend/app/routes/projects.py
T
Shubhankar45 53dbfa976b -
2026-11-13 12:14:55 +00:00

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)