Починить комменты, фотки, excludes в гетах и выпилить details, limit=0 fix (#42)

Author: grigoriev-semyon

calendar_backend/models/__init__.py

@@ -1,3 +1,4 @@
-from .db import Credentials, Group, Lecturer, Event, Room, Direction, CommentEvent, CommentLecturer
+from .db import Credentials, Group, Lecturer, Event, Room, Direction, CommentEvent, CommentLecturer, EventsLecturers, EventsRooms
 
-__all__ = ["Credentials", "Group", "Lecturer", "Event", "Room", "Direction", "CommentEvent", "CommentLecturer"]
+__all__ = ["Credentials", "Group", "Lecturer", "Event",
+           "Room", "Direction", "CommentEvent", "CommentLecturer", "EventsLecturers", "EventsRooms"]

calendar_backend/routes/event.py

@@ -3,18 +3,19 @@
 import logging
 from typing import Literal
 
-from fastapi import APIRouter, Depends, Query
+from fastapi import APIRouter, Depends, Query, HTTPException
 from fastapi_sqlalchemy import db
 
-from calendar_backend.exceptions import NotEnoughCriteria
+from calendar_backend.exceptions import NotEnoughCriteria, ObjectNotFound
 from calendar_backend.methods import auth, list_calendar
-from calendar_backend.models import Group, Room, Lecturer, Event, CommentEvent
+from calendar_backend.models import Group, Room, Lecturer, Event, EventsLecturers, EventsRooms
+from calendar_backend.models import CommentEvent as DbCommentEvent
 from calendar_backend.routes.models.event import (
     CommentEventGet,
     EventGet,
     EventPatch,
     EventPost,
-    GetListEvent,
+    GetListEvent, EventCommentPost, EventCommentPatch, EventComments,
 )
 from calendar_backend.settings import get_settings
 
@@ -39,11 +40,16 @@ async def _get_timetable(start: date, end: date, group_id, lecturer_id, room_id,
     if group_id:
         events = events.filter(Event.group_id == group_id)
     elif lecturer_id:
-        events = events.filter(Event.lecturer == Lecturer.get(lecturer_id, session=db.session))
+        ids_ = EventsLecturers.get_all(session=db.session).filter(EventsLecturers.lecturer_id == lecturer_id).all()
+        events = events.filter(Event.id.in_(row.event_id for row in ids_))
     elif room_id:
-        events = events.filter(Event.lecturer == Room.get(room_id, session=db.session))
+        ids_ = EventsRooms.get_all(session=db.session).filter(EventsRooms.room_id == room_id).all()
+        events = events.filter(Event.id.in_(row.event_id for row in ids_))
     cnt = events.count()
-    events = events.order_by(Event.start_ts).limit(limit).offset(offset).all()
+    if limit:
+        events = events.order_by(Event.start_ts).limit(limit).offset(offset).all()
+    else:
+        events = events.order_by(Event.start_ts).offset(offset).all()
 
     fmt = {}
     if detail and "comment" not in detail:
@@ -96,19 +102,55 @@ async def http_create_event(event: EventPost, _: auth.User = Depends(auth.get_cu
 
 @event_router.patch("/{id}", response_model=EventGet)
 async def http_patch_event(id: int, event_inp: EventPatch, _: auth.User = Depends(auth.get_current_user)) -> EventGet:
-    return Event.update(id, session=db.session, **event_inp.dict(exclude_unset=True))
+    return EventGet.from_orm(Event.update(id, session=db.session, **event_inp.dict(exclude_unset=True)))
 
 
 @event_router.delete("/{id}", response_model=None)
 async def http_delete_event(id: int, _: auth.User = Depends(auth.get_current_user)) -> None:
     Event.delete(id, session=db.session)
 
 
-# @event_router.post("/{event_id}/comment", response_model=CommentEventGet, deprecated=True)
-# async def http_comment_event(event_id: int, author_name: str, text: str) -> CommentEventGet:
-#     return CommentEventGet.from_orm(CommentEvent(event_id=event_id, db.session, text, author_name))
+@event_router.post("/{id}/comment", response_model=CommentEventGet)
+async def http_comment_event(id: int, comment: EventCommentPost) -> CommentEventGet:
+    return CommentEventGet.from_orm(DbCommentEvent.create(event_id = id, session=db.session, **comment.dict()))
+
+
+@event_router.patch("/{event_id}/comment/{id}", response_model=CommentEventGet)
+async def http_udpate_comment(id: int, event_id: int, comment_inp: EventCommentPatch) -> CommentEventGet:
+    comment = DbCommentEvent.get(id, session=db.session)
+    if comment.event_id != event_id:
+        raise ObjectNotFound(DbCommentEvent, id)
+    return CommentEventGet.from_orm(DbCommentEvent.update(id, session=db.session, **comment_inp.dict(exclude_unset=True)))
+
+
+@event_router.get("/{event_id}/comment/{id}", response_model=CommentEventGet)
+async def http_get_comment(id: int, event_id: int) -> CommentEventGet:
+    comment = DbCommentEvent.get(id, session=db.session)
+    if not comment.event_id == event_id:
+        raise ObjectNotFound(DbCommentEvent, id)
+    return CommentEventGet.from_orm(comment)
+
+
+@event_router.delete("/{id}/comment", response_model=None)
+async def http_delete_comment(id: int, event_id: int, _: auth.User = Depends(auth.get_current_user)) -> None:
+    comment = DbCommentEvent.get(id, session=db.session)
+    if comment.event_id != event_id:
+        raise ObjectNotFound(DbCommentEvent, id)
+    return DbCommentEvent.delete(id=id, session=db.session)
+
+
+@event_router.get("/{event_id}/comment", response_model=EventComments)
+async def http_get_event_comments(event_id: int, limit: int = 10, offset: int = 0) -> EventComments:
+    res = DbCommentEvent.get_all(session=db.session).filter(DbCommentEvent.event_id == event_id)
+    if limit:
+        cnt, res = res.count(), res.offset(offset).limit(limit).all()
+    else:
+        cnt, res = res.count(), res.offset(offset).all()
+    return EventComments(**{
+        "items": res,
+        "limit": limit,
+        "offset": offset,
+        "total": cnt
+    })
 
 
-# @event_router.patch("/{id}/comment", response_model=CommentEventGet, deprecated=True)
-# async def http_udpate_comment(comment_id: int, new_text: str) -> CommentEventGet:
-#     return CommentEventGet.from_orm(await utils.update_comment_event(comment_id, db.session, new_text))

calendar_backend/routes/group.py

@@ -27,14 +27,18 @@ async def http_get_group_by_id(
 
 
 @group_router.get("/", response_model=GetListGroup)
-async def http_get_groups(query: str = "", limit: int = 10, offset: int = 0) -> dict[str, Any]:
-    result = Group.get_all(session=db.session).filter(Group.number.contains(query))
-    return {
-        "items": [GroupGet.from_orm(row) for row in result.offset(offset).limit(limit).all()],
+async def http_get_groups(query: str = "", limit: int = 10, offset: int = 0) -> GetListGroup:
+    res = Group.get_all(session=db.session).filter(Group.number.contains(query))
+    if limit:
+        cnt, res = res.count(), res.offset(offset).limit(limit).all()
+    else:
+        cnt, res = res.count(), res.offset(offset).all()
+    return GetListGroup(**{
+        "items": res,
         "limit": limit,
         "offset": offset,
-        "total": result.count(),
-    }
+        "total": cnt,
+    })
 
 
 @group_router.post("/", response_model=GroupGet)
@@ -50,7 +54,7 @@ async def http_patch_group(
     group_inp: GroupPatch,
     _: auth.User = Depends(auth.get_current_user),
 ) -> GroupGet:
-    return Group.update(id, **group_inp.dict(exclude_unset=True), session=db.session)
+    return GroupGet.from_orm(Group.update(id, **group_inp.dict(exclude_unset=True), session=db.session))
 
 
 @group_router.delete("/{id}", response_model=None)

calendar_backend/routes/lecturer.py

@@ -2,9 +2,11 @@
 import logging
 from typing import Any, Literal
 
-from fastapi import APIRouter, Depends, UploadFile, File, Query
+from fastapi import APIRouter, Depends, UploadFile, File, Query, HTTPException
 from fastapi_sqlalchemy import db
 from calendar_backend.models.db import Lecturer
+from calendar_backend.models.db import CommentLecturer as DbCommentLecturer
+from calendar_backend.models.db import Photo as DbPhoto
 
 from calendar_backend.settings import get_settings
 from calendar_backend.methods import utils, auth
@@ -16,8 +18,9 @@
     LecturerPatch,
     Photo,
     LecturerPhotos,
-    CommentLecturer,
+    CommentLecturer, LecturerCommentPost, LecturerCommentPatch, LecturerComments
 )
+from calendar_backend.exceptions import ObjectNotFound
 
 lecturer_router = APIRouter(prefix="/timetable/lecturer", tags=["Lecturer"])
 settings = get_settings()
@@ -41,25 +44,17 @@ async def http_get_lecturers(
     query: str = "",
     limit: int = 10,
     offset: int = 0,
-    details: list[Literal["photo", "description", "comments", ""]] | None = Query([]),
 ) -> dict[str, Any]:
     res = Lecturer.get_all(session=db.session).filter(Lecturer.search(query))
-    cnt, res = res.count(), res.offset(offset).limit(limit).all()
+    if limit:
+        cnt, res = res.count(), res.offset(offset).limit(limit).all()
+    else:
+        cnt, res = res.count(), res.offset(offset).all()
     for row in res:
         row.avatar_link = row.avatar.link if row.avatar else None
     result = [LecturerGet.from_orm(row) for row in res]
-    exclude = []
-    details = details or [""]
-    if "" in details:
-        exclude.append(["photo", "description", "comments"])
-    if "photo" not in details:
-        exclude.append("photo")
-    if "description" not in details:
-        exclude.append("description")
-    if "comments" not in details:
-        exclude.append("comments")
     return {
-        "items": [row.dict(exclude={*exclude}) for row in result],
+        "items": result,
         "limit": limit,
         "offset": offset,
         "total": cnt,
@@ -68,7 +63,7 @@ async def http_get_lecturers(
 
 @lecturer_router.post("/", response_model=LecturerGet)
 async def http_create_lecturer(lecturer: LecturerPost, _: auth.User = Depends(auth.get_current_user)) -> LecturerGet:
-    return Lecturer.create(session=db.session, **lecturer.dict())
+    return LecturerGet.from_orm(Lecturer.create(session=db.session, **lecturer.dict()))
 
 
 @lecturer_router.patch("/{id}", response_model=LecturerGet)
@@ -84,28 +79,88 @@ async def http_delete_lecturer(id: int, _: auth.User = Depends(auth.get_current_
     Lecturer.delete(id, session=db.session)
 
 
-@lecturer_router.post("/{id}/photo", response_model=Photo)
-async def http_upload_photo(id: int, photo: UploadFile = File(...)) -> Photo:
-    return Photo.from_orm(await utils.upload_lecturer_photo(id, db.session, file=photo))
+@lecturer_router.post("/{lecturer_id}/photo", response_model=Photo)
+async def http_upload_photo(lecturer_id: int, photo: UploadFile = File(...)) -> Photo:
+    return Photo.from_orm(await utils.upload_lecturer_photo(lecturer_id, db.session, file=photo))
 
 
-@lecturer_router.get("/{id}/photo", response_model=LecturerPhotos)
-async def http_get_lecturer_photos(id: int) -> LecturerPhotos:
-    lecturer = Lecturer.get(id, session=db.session)
-    lecturer.links = [row.link for row in lecturer.photos]
-    return LecturerPhotos.from_orm(lecturer)
+@lecturer_router.get("/{lecturer_id}/photo", response_model=LecturerPhotos)
+async def http_get_lecturer_photos(lecturer_id: int, limit: int = 10,
+                                   offset: int = 0) -> LecturerPhotos:
+    res = DbPhoto.get_all(session=db.session).filter(DbPhoto.lecturer_id == lecturer_id)
+    if limit:
+        cnt, res = res.count(), res.offset(offset).limit(limit).all()
+    else:
+        cnt, res = res.count(), res.offset(offset).all()
+    return LecturerPhotos(**{
+        "items": [row.link for row in res],
+        "limit": limit,
+        "offset": offset,
+        "total": cnt
+    })
 
 
-@lecturer_router.post("/{id}/comment", response_model=CommentLecturer)
-async def http_comment_lecturer(id: int, comment_text: str, author_name: str) -> CommentLecturer:
-    return CommentLecturer.from_orm(await utils.create_comment_lecturer(id, db.session, comment_text, author_name))
+@lecturer_router.post("/{lecturer_id}/comment/", response_model=CommentLecturer)
+async def http_comment_lecturer(lecturer_id: int, comment: LecturerCommentPost) -> CommentLecturer:
+    return CommentLecturer.from_orm(DbCommentLecturer.create(lecturer_id=lecturer_id, session=db.session, **comment.dict()))
 
 
-@lecturer_router.patch("/{id}/comment", response_model=CommentLecturer)
-async def http_update_comment_lecturer(comment_id: int, new_text: str) -> CommentLecturer:
-    return CommentLecturer.from_orm(await utils.update_comment_lecturer(comment_id, db.session, new_text))
+@lecturer_router.patch("/{lecturer_id}/comment/{id}", response_model=CommentLecturer)
+async def http_update_comment_lecturer(id: int, lecturer_id: int, comment_inp: LecturerCommentPatch) -> CommentLecturer:
+    comment = DbCommentLecturer.get(id=id, session=db.session)
+    if comment.lecturer_id != lecturer_id:
+        raise ObjectNotFound(DbCommentLecturer, id)
+    return CommentLecturer.from_orm(DbCommentLecturer.update(id, session=db.session, **comment_inp.dict(exclude_unset=True)))
 
 
 @lecturer_router.post("/{id}/avatar", response_model=LecturerGet)
 async def http_set_lecturer_avatar(id: int, photo_id: int) -> LecturerGet:
     return LecturerGet.from_orm(await utils.set_lecturer_avatar(id, photo_id, db.session))
+
+
+@lecturer_router.delete("/{lecturer_id}/comment/{id}", response_model=None)
+async def http_delete_comment(id: int, lecturer_id: int, _: auth.User = Depends(auth.get_current_user)) -> None:
+    comment = DbCommentLecturer.get(id, session=db.session)
+    if comment.lecturer_id != lecturer_id:
+        raise ObjectNotFound(DbCommentLecturer, id)
+    return DbCommentLecturer.delete(id=id, session=db.session)
+
+
+@lecturer_router.get("/{lecturer_id}/comment/{id}", response_model=CommentLecturer)
+async def http_get_comment(id: int, lecturer_id: int) -> CommentLecturer:
+    comment = DbCommentLecturer.get(id, session=db.session)
+    if not comment.lecturer_id == lecturer_id:
+        raise ObjectNotFound(DbCommentLecturer, id)
+    return CommentLecturer.from_orm(comment)
+
+
+@lecturer_router.delete("/{lecturer_id}/photo/{id}", response_model=None)
+async def http_delete_photo(id: int, lecturer_id: int) -> None:
+    photo = DbPhoto.get(id, session=db.session)
+    if photo.lecturer_id != lecturer_id:
+        raise ObjectNotFound(DbPhoto, id)
+    return DbPhoto.delete(id=id, session=db.session)
+
+
+@lecturer_router.get("/{lecturer_id}/comment/", response_model=LecturerComments)
+async def http_get_all_lecturer_comments(lecturer_id: int, limit: int = 10, offset: int = 0) -> LecturerComments:
+    res = DbCommentLecturer.get_all(session=db.session).filter(DbCommentLecturer.lecturer_id == lecturer_id)
+    if limit:
+        cnt, res = res.count(), res.offset(offset).limit(limit).all()
+    else:
+        cnt, res = res.count(), res.offset(offset).all()
+    return LecturerComments(**{
+        "items": res,
+        "limit": limit,
+        "offset": offset,
+        "total": cnt
+    })
+
+
+@lecturer_router.get("/{lecturer_id}/photo/{id}", response_model=Photo)
+async def get_photo(id: int, lecturer_id: int) -> Photo:
+    photo = DbPhoto.get(id, session=db.session)
+    if photo.lecturer_id != lecturer_id:
+        raise ObjectNotFound(DbPhoto, id)
+    return Photo.from_orm(photo)
+

calendar_backend/routes/models/__init__.py

@@ -5,9 +5,11 @@
     LecturerPatch,
     LecturerPhotos,
     LecturerEvents,
-    CommentLecturer,
     GetListLecturer,
     Photo,
+    LecturerCommentPost,
+    LecturerCommentPatch,
+    LecturerComments
 )
 from .room import RoomPost, RoomPatch, RoomEvents, GetListRoom
 from .event import (
@@ -16,5 +18,6 @@
     Event,
     GetListEvent,
     CommentEventGet,
+    EventComments
 )
 from .group import GroupPost, GroupPatch, GroupEvents, GetListGroup

calendar_backend/routes/models/event.py

@@ -51,3 +51,20 @@ class GetListEvent(Base):
     limit: int
     offset: int
     total: int
+
+
+class EventCommentPost(Base):
+    text: str
+    author_name: str
+
+
+class EventCommentPatch(Base):
+    text: str
+    author_name: str
+
+
+class EventComments(Base):
+    items: list[CommentEventGet]
+    limit: int
+    offset: int
+    total: int

calendar_backend/routes/models/lecturer.py

@@ -1,8 +1,11 @@
 from .base import Base, LecturerGet, EventGet, CommentLecturer
 
 
-class LecturerPhotos(LecturerGet):
-    links: list[str]
+class LecturerPhotos(Base):
+    items: list[str]
+    limit: int
+    offset: int
+    total: int
 
 
 class LecturerPatch(Base):
@@ -41,3 +44,20 @@ class Photo(Base):
 
 class LecturerEvents(LecturerGet):
     events: list[EventGet] = []
+
+
+class LecturerCommentPost(Base):
+    author_name: str
+    text: str
+
+
+class LecturerCommentPatch(Base):
+    author_name: str | None
+    text: str | None
+
+
+class LecturerComments(Base):
+    items: list[CommentLecturer]
+    limit: int
+    offset: int
+    total: int