Доделанно получение сообщений

chat_test/app/exceptions.py

@@ -62,3 +62,8 @@ class IncorrectPasswordException(BlackPhoenixException):
 class PasswordsМismatchException(BlackPhoenixException):
     status_code = status.HTTP_409_CONFLICT
     detail = "Пароли не совпадают"
+
+
+class UsersIdIsTheSameException(BlackPhoenixException):
+    status_code = status.HTTP_409_CONFLICT
+    detail = "Айди юзеров совпадают"

chat_test/app/users/chat/dao.py

@@ -10,7 +10,7 @@ class ChatDAO(BaseDAO):
     model = Chats
 
     @classmethod
-    async def create(cls, user_id):
+    async def create(cls, user_id: int):
         query = insert(Chats).values(chat_for=user_id)
         async with async_session_maker() as session:
             await session.execute(query)
@@ -18,7 +18,7 @@ class ChatDAO(BaseDAO):
         return True
 
     @classmethod
-    async def send_message(cls, user_id, chat_id, message):
+    async def send_message(cls, user_id, chat_id: int, message: str):
         query = insert(Messages).values(chat_id=chat_id, user_id=user_id, message=message, image_url=None)
         async with async_session_maker() as session:
             await session.execute(query)
@@ -26,7 +26,7 @@ class ChatDAO(BaseDAO):
         return True
 
     @classmethod
-    async def get_message_by_id(cls, message_id):
+    async def get_message_by_id(cls, message_id: int):
         query = select(Messages.__table__.columns).where(
             and_(
                 Messages.id == message_id,
@@ -41,25 +41,45 @@ class ChatDAO(BaseDAO):
             return result[0]
 
     @classmethod
-    async def get_last_message(cls, chat_id):
-        query = select(Messages.__table__.columns).where(
-            and_(
-                Messages.chat_id == chat_id,
-                Messages.visibility == True
-            )
-        ).order_by(Messages.created_at.desc()).limit(1)
-        async with async_session_maker() as session:
-            result = await session.execute(query)
-        result = result.mappings().all()
-        if result:
-            return result[0]
-
-    @classmethod
-    async def delete_message(cls, message_id):
+    async def delete_message(cls, message_id: int):
         query = update(Messages).where(Messages.id == message_id).values(visibility=False)
         async with async_session_maker() as session:
             await session.execute(query)
             await session.commit()
         return True
 
+    @classmethod
+    async def get_some_messages(cls, chat_id: int, message_number_from: int, messages_to_get: int):
+        """
+        WITH messages_with_users AS (
+            SELECT *
+            FROM messages
+            LEFT JOIN users ON messages.user_id = users.id
+        )
+
+        SELECT message, image_url, chat_id, user_id, created_at, avatar_image
+        FROM messages_with_users
+        WHERE visibility = true AND chat_id = 2
+        ORDER BY created_at DESC
+        LIMIT 15 OFFSET 0;
+        """
+        messages_with_users = (
+            select(Messages.__table__.columns, Users.__table__.columns)
+            .select_from(Messages)
+            .join(Users, Messages.user_id == Users.id)).cte('messages_with_users')
+
+        messages = (select(messages_with_users.c.message, messages_with_users.c.image_url,
+                           messages_with_users.c.chat_id, messages_with_users.c.user_id,
+                           messages_with_users.c.created_at, messages_with_users.c.avatar_image)
+                    .where(
+            and_(
+                messages_with_users.c.chat_id == chat_id,
+                messages_with_users.c.visibility == True
+            )
+        ).order_by(messages_with_users.c.created_at.desc()).limit(messages_to_get).offset(message_number_from))
+        async with async_session_maker() as session:
+            result = await session.execute(messages)
+        result = result.mappings().all()
+        if result:
+            return result
 

chat_test/app/users/chat/router.py

@@ -1,9 +1,8 @@
 from fastapi import APIRouter, Depends, status
 
-
-from app.exceptions import UserDontHavePermissionException, MessageNotFoundException
+from app.exceptions import UserDontHavePermissionException, MessageNotFoundException, UsersIdIsTheSameException
 from app.users.chat.dao import ChatDAO
-from app.users.chat.shemas import SMessage
+from app.users.chat.shemas import SMessage, SLastMessages
 
 from app.users.dao import UserDAO
 from app.users.dependencies import get_current_user, validate_user_access_to_chat
@@ -15,6 +14,7 @@ router = APIRouter(
 )
 
 
+# Мусор
 @router.get("")
 async def root(user: Users = Depends(get_current_user)):
     print(user)
@@ -25,14 +25,12 @@ async def root(user: Users = Depends(get_current_user)):
 async def add_message_to_chat(
         chat_id: int,
         message: str,
-        image_url: str = None,
         user: Users = Depends(get_current_user)
 ):
     send_message_to_chat = await ChatDAO.send_message(
         user_id=user.id,
         chat_id=chat_id,
         message=message,
-        image_url=image_url
     )
 
 
@@ -52,27 +50,37 @@ async def delete_message_from_chat(
     return deleted_message
 
 
-@router.get("/get_last_message", response_model=SMessage)
-async def get_last_message(chat_id: int, user: Users = Depends(get_current_user)):
-    message = dict(await ChatDAO.get_last_message(chat_id=chat_id))
-    user_avatar = await UserDAO.get_user_avatar(user_id=user.id)
-    message["user_avatar"] = user_avatar
-    print(message)
-    if message is not None:
-        return message
-    raise MessageNotFoundException
-
-
-@router.post("/create_chat")
+#  Не доделан
+@router.post("/create_chat", status_code=status.HTTP_201_CREATED)
 async def create_chat(
         user_to_exclude: int,
         user: Users = Depends(get_current_user)
 ):
+    if user.id == user_to_exclude:
+        raise UsersIdIsTheSameException
     created_chat = await ChatDAO.create(user_id=user_to_exclude)
     return created_chat
 
-@router.get("/last_messages")
-async def get_last_messages():
-    pass
+
+@router.get("/get_last_message/{chat_id}", response_model=list[SMessage])
+async def get_last_message(chat_id: int, user: Users = Depends(get_current_user)):
+    await validate_user_access_to_chat(chat_id=chat_id, user_id=user.id)
+    message = await ChatDAO.get_some_messages(chat_id=chat_id, message_number_from=0, messages_to_get=1)
+    if message is None:
+        raise MessageNotFoundException
+    return message
 
 
+@router.get("/get_some_messages/{chat_id}", response_model=list[SMessage])
+async def get_some_messages(
+        chat_id: int, last_messages: SLastMessages = Depends(), user: Users = Depends(get_current_user)
+):
+    await validate_user_access_to_chat(chat_id=chat_id, user_id=user.id)
+    messages = await ChatDAO.get_some_messages(
+        chat_id=chat_id,
+        message_number_from=last_messages.messages_count,
+        messages_to_get=last_messages.messages_to_get
+    )
+    if not messages:
+        raise MessageNotFoundException
+    return messages

chat_test/app/users/chat/shemas.py

@@ -10,7 +10,17 @@ class SMessage(BaseModel):
     chat_id: int
     user_id: int
     created_at: datetime
-    user_avatar: str
+    avatar_image: str
 
     class Config:
         from_attributes = True
+
+
+class SLastMessages:
+    def __init__(
+            self,
+            messages_count: int,
+            messages_to_get: int,
+    ):
+        self.messages_count = messages_count
+        self.messages_to_get = messages_to_get