попыточка пофиксить время работы

Author: grigoriev-semyon

calendar_backend/methods/list_calendar.py

@@ -25,7 +25,7 @@ async def get_user_calendar(group_id: int, session: Session, start_date: date_,
     logger.debug(f"Getting user calendar (iCal) for group {group_id}")
     group = Group.get(group_id, session=session)
     user_calendar = Calendar()
-    timetable = await utils.get_group_lessons_in_daterange(group, start_date, end_date)
+    timetable = await utils.get_group_lessons_in_daterange(group, start_date, end_date, session=session)
     for lesson in timetable:
         teacher = (
             str([f"{row.first_name} {row.middle_name} {row.last_name}" for row in lesson.lecturer])

calendar_backend/methods/utils.py

@@ -7,10 +7,9 @@
 from fastapi import File, UploadFile
 from sqlalchemy.orm import Session
 
-from calendar_backend.models.db import Event, Group, Lecturer, Photo, Room
+from calendar_backend.models.db import Event, Group, Lecturer, Photo, Room, EventsRooms, EventsLecturers
 from calendar_backend.settings import get_settings
 
-
 settings = get_settings()
 
 
@@ -36,30 +35,34 @@ async def get_lessons_by_group_from_date(group: Group, date: datetime.date) -> l
 
 
 async def get_group_lessons_in_daterange(
-    group: Group, date_start: datetime.date, date_end: datetime.date
+    group: Group, date_start: datetime.date, date_end: datetime.date, session: Session
 ) -> list[Event]:
     events_list = []
-    events = group.events
+    events = Event.get_all(session=session).filter(Event.group_id == group.id).all()
     for lesson in events:
         if lesson.start_ts.date() >= date_start and lesson.end_ts.date() < date_end:
             events_list.append(lesson)
     return events_list
 
 
-async def get_room_lessons_in_daterange(room: Room, date_start: datetime.date, date_end: datetime.date) -> list[Event]:
+async def get_room_lessons_in_daterange(
+    room: Room, date_start: datetime.date, date_end: datetime.date, session: Session
+) -> list[Event]:
     events_list = []
-    events = room.events
+    events_ids = EventsRooms.get_all(session=session).filter(EventsRooms.room_id == room.id).all()
+    events = [Event.get(row, session=session) for row in events_ids]
     for lesson in events:
         if lesson.start_ts.date() >= date_start and lesson.end_ts.date() < date_end:
             events_list.append(lesson)
     return events_list
 
 
 async def get_lecturer_lessons_in_daterange(
-    lecturer: Lecturer, date_start: datetime.date, date_end: datetime.date
+    lecturer: Lecturer, date_start: datetime.date, date_end: datetime.date, session: Session
 ) -> list[Event]:
     events_list = []
-    events = lecturer.events
+    events_ids = EventsLecturers.get_all(session=session).filter(EventsRooms.room_id == lecturer.id).all()
+    events = [Event.get(row, session=session) for row in events_ids]
     for lesson in events:
         if lesson.start_ts.date() >= date_start and lesson.end_ts.date() < date_end:
             events_list.append(lesson)

calendar_backend/models/__init__.py

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

calendar_backend/routes/event.py

@@ -15,7 +15,10 @@
     EventGet,
     EventPatch,
     EventPost,
-    GetListEvent, EventCommentPost, EventCommentPatch, EventComments,
+    GetListEvent,
+    EventCommentPost,
+    EventCommentPatch,
+    EventComments,
 )
 from calendar_backend.settings import get_settings
 
@@ -55,11 +58,13 @@ async def _get_timetable(start: date, end: date, group_id, lecturer_id, room_id,
     if detail and "comment" not in detail:
         fmt["comments"] = ...
     if detail and "description" not in detail:
-        fmt["lecturer"] = [{
-            "avatar_id": ...,
-            "description": ...,
-            "is_deleted": ...,
-        }]
+        fmt["lecturer"] = [
+            {
+                "avatar_id": ...,
+                "description": ...,
+                "is_deleted": ...,
+            }
+        ]
 
     return GetListEvent(items=events, limit=limit, offset=offset, total=cnt).dict(exclude=fmt)
 
@@ -112,15 +117,17 @@ async def http_delete_event(id: int, _: auth.User = Depends(auth.get_current_use
 
 @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()))
+    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)))
+    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)
@@ -146,11 +153,4 @@ async def http_get_event_comments(event_id: int, limit: int = 10, offset: int =
         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
-    })
-
-
+    return EventComments(**{"items": res, "limit": limit, "offset": offset, "total": cnt})

calendar_backend/routes/group.py

@@ -1,6 +1,6 @@
 import datetime
 import logging
-from typing import Any
+from typing import Any, Union
 
 from fastapi import APIRouter, HTTPException, Depends
 from fastapi_sqlalchemy import db
@@ -15,15 +15,16 @@
 logger = logging.getLogger(__name__)
 
 
-@group_router.get("/{id}", response_model=GroupEvents)
+@group_router.get("/{id}", response_model=Union[GroupEvents, GroupGet])
 async def http_get_group_by_id(
     id: int, start: datetime.date | None = None, end: datetime.date | None = None
 ) -> GroupEvents:
     group = Group.get(id, session=db.session)
     result = GroupEvents.from_orm(group)
     if start and end:
-        result.events = await utils.get_group_lessons_in_daterange(group, start, end)
-    return result
+        result.events = await utils.get_group_lessons_in_daterange(group, start, end, db.session)
+        return GroupEvents.from_orm(result)
+    return GroupGet.from_orm(result)
 
 
 @group_router.get("/", response_model=GetListGroup)
@@ -33,12 +34,14 @@ async def http_get_groups(query: str = "", limit: int = 10, offset: int = 0) ->
         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": cnt,
-    })
+    return GetListGroup(
+        **{
+            "items": res,
+            "limit": limit,
+            "offset": offset,
+            "total": cnt,
+        }
+    )
 
 
 @group_router.post("/", response_model=GroupGet)

calendar_backend/routes/lecturer.py

@@ -1,15 +1,15 @@
 import datetime
 import logging
-from typing import Any, Literal
+from typing import Any, Union
 
-from fastapi import APIRouter, Depends, UploadFile, File, Query, HTTPException
+from fastapi import APIRouter, Depends, UploadFile, File
 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.exceptions import ObjectNotFound
 from calendar_backend.methods import utils, auth
+from calendar_backend.models.db import CommentLecturer as DbCommentLecturer
+from calendar_backend.models.db import Lecturer
+from calendar_backend.models.db import Photo as DbPhoto
 from calendar_backend.routes.models import (
     LecturerEvents,
     GetListLecturer,
@@ -18,25 +18,29 @@
     LecturerPatch,
     Photo,
     LecturerPhotos,
-    CommentLecturer, LecturerCommentPost, LecturerCommentPatch, LecturerComments
+    CommentLecturer,
+    LecturerCommentPost,
+    LecturerCommentPatch,
+    LecturerComments,
 )
-from calendar_backend.exceptions import ObjectNotFound
+from calendar_backend.settings import get_settings
 
 lecturer_router = APIRouter(prefix="/timetable/lecturer", tags=["Lecturer"])
 settings = get_settings()
 logger = logging.getLogger(__name__)
 
 
-@lecturer_router.get("/{id}", response_model=LecturerEvents)
+@lecturer_router.get("/{id}", response_model=Union[LecturerEvents, LecturerGet])
 async def http_get_lecturer_by_id(
     id: int, start: datetime.date | None = None, end: datetime.date | None = None
-) -> LecturerEvents:
+) -> LecturerEvents | LecturerGet:
     lecturer = Lecturer.get(id, session=db.session)
     lecturer.avatar_link = lecturer.avatar.link if lecturer.avatar else None
     result = LecturerEvents.from_orm(lecturer)
     if start and end:
-        result.events = await utils.get_lecturer_lessons_in_daterange(lecturer, start, end)
-    return result
+        result.events = await utils.get_lecturer_lessons_in_daterange(lecturer, start, end, db.session)
+        return LecturerEvents.from_orm(result)
+    return LecturerGet.from_orm(result)
 
 
 @lecturer_router.get("/", response_model=GetListLecturer)
@@ -85,32 +89,30 @@ async def http_upload_photo(lecturer_id: int, photo: UploadFile = File(...)) ->
 
 
 @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:
+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
-    })
+    return LecturerPhotos(**{"items": [row.link for row in res], "limit": limit, "offset": offset, "total": cnt})
 
 
 @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()))
+    return CommentLecturer.from_orm(
+        DbCommentLecturer.create(lecturer_id=lecturer_id, session=db.session, **comment.dict())
+    )
 
 
 @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)))
+    return CommentLecturer.from_orm(
+        DbCommentLecturer.update(id, session=db.session, **comment_inp.dict(exclude_unset=True))
+    )
 
 
 @lecturer_router.post("/{id}/avatar", response_model=LecturerGet)
@@ -149,12 +151,7 @@ async def http_get_all_lecturer_comments(lecturer_id: int, limit: int = 10, offs
         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
-    })
+    return LecturerComments(**{"items": res, "limit": limit, "offset": offset, "total": cnt})
 
 
 @lecturer_router.get("/{lecturer_id}/photo/{id}", response_model=Photo)
@@ -163,4 +160,3 @@ async def get_photo(id: int, lecturer_id: int) -> Photo:
     if photo.lecturer_id != lecturer_id:
         raise ObjectNotFound(DbPhoto, id)
     return Photo.from_orm(photo)
-

calendar_backend/routes/models/__init__.py

@@ -9,15 +9,8 @@
     Photo,
     LecturerCommentPost,
     LecturerCommentPatch,
-    LecturerComments
+    LecturerComments,
 )
 from .room import RoomPost, RoomPatch, RoomEvents, GetListRoom
-from .event import (
-    EventPost,
-    EventPatch,
-    Event,
-    GetListEvent,
-    CommentEventGet,
-    EventComments
-)
+from .event import EventPost, EventPatch, Event, GetListEvent, CommentEventGet, EventComments
 from .group import GroupPost, GroupPatch, GroupEvents, GetListGroup

calendar_backend/routes/models/event.py

@@ -36,6 +36,7 @@ def __repr__(self):
             f" lecturer={self.lecturer_id}, start_ts={self.start_ts}, end_ts={self.end_ts})"
         )
 
+
 class Event(Base):
     id: int
     name: str
@@ -67,4 +68,4 @@ class EventComments(Base):
     items: list[CommentEventGet]
     limit: int
     offset: int
-    total: int
+    total: int

calendar_backend/routes/models/group.py

@@ -50,4 +50,4 @@ class GetListGroup(Base):
 
 
 class GroupEvents(GroupGet):
-    events: list[EventGet] = []
+    events: list[EventGet]

calendar_backend/routes/models/lecturer.py

@@ -43,7 +43,7 @@ class Photo(Base):
 
 
 class LecturerEvents(LecturerGet):
-    events: list[EventGet] = []
+    events: list[EventGet]
 
 
 class LecturerCommentPost(Base):
@@ -60,4 +60,4 @@ class LecturerComments(Base):
     items: list[CommentLecturer]
     limit: int
     offset: int
-    total: int
+    total: int