feat: logging on sending file error, refactoring

external/chat/schemas.py

@@ -6,18 +6,13 @@ from schemas.base import BaseSchema, OkMessageSchema
 
 # region Entities
 
-class ExternalSendFileSchema(BaseSchema):
-    buffer: bytes
-    file_name: str
-    file_size: int
-
-
 class ExternalMessageFileSchema(BaseSchema):
     file_path: str
     type: str
     file_name: str
     file_size: int
 
+
 # endregion
 
 # region Requests

external/kafka/consumer.py

@@ -20,11 +20,9 @@ async def consume_messages():
 
     async with session_maker() as session:
         consumer_service = ConsumerService(session)
-        print("started consuming messages")
 
         try:
             async for message in consumer:
-                print("consume")
                 await consumer_service.consume_message(message)
         finally:
             await consumer.stop()

external/kafka/schemas/consumer.py

@@ -41,19 +41,18 @@ class MessageFromTelegramRequest(BaseSchema):
 
 class BaseConnectorResponse(OkMessageSchema):
     message_type: int
+    message_id: int
 
 
 class SendMessageToConnectorResponse(BaseConnectorResponse):
-    message_id: int
+    tg_message_id: Optional[int] = None
-    tg_message_id: int
 
 
 class DeleteMessageResponse(BaseConnectorResponse):
-    message_id: int
+    pass
 
 
 class EditMessageResponse(BaseConnectorResponse):
-    message_id: int
     text: str
 
 # endregion

external/kafka/services/consumer_service.py

@@ -14,7 +14,6 @@ from services.base import BaseService
 class ConsumerService(BaseService):
     async def consume_message(self, message: ConsumerRecord):
         value = pickle.loads(message.value)
-        print("Consumer: received message: ", value)
 
         try:
             if 'ok' in value:

external/kafka/services/producer_service.py

@@ -16,7 +16,7 @@ class ProducerService(BaseService):
         try:
             await producer.send(KAFKA_PRODUCER_TOPIC, value=pickle.dumps(request.model_dump()))
         except ClientConnectorError:
-            return False, 'Ошибка подключения к коннектору'
+            return False, 'Ошибка подключения к сервису'
         except Exception as e:
             return False, str(e)
         return True, 'Сообщение отправлено'
@@ -72,6 +72,6 @@ class ProducerService(BaseService):
                 tg_message_id=tg_message_id,
                 group_id=str(group_id),
                 text=text,
-            )
+            ),
         )
         return await ProducerService._send_message(request)

routers/chat.py

@@ -4,7 +4,9 @@ from fastapi import APIRouter, Depends, UploadFile
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from backend.session import get_session
+from models import User
 from schemas.chat import *
+from services.auth import get_current_user
 from services.chat import ChatService
 
 chat_router = APIRouter(
@@ -20,9 +22,10 @@ chat_router = APIRouter(
 )
 async def send_text_message(
         session: Annotated[AsyncSession, Depends(get_session)],
+        user: Annotated[User, Depends(get_current_user)],
         request: SendTextMessageRequest,
 ):
-    return await ChatService(session).send_message(request)
+    return await ChatService(session).send_message(request, user)
 
 
 @chat_router.post(
@@ -44,11 +47,12 @@ async def repeat_sending_text_message(
 )
 async def send_messages_with_files(
         session: Annotated[AsyncSession, Depends(get_session)],
+        user: Annotated[User, Depends(get_current_user)],
         files: list[UploadFile],
         chat_id: int,
         caption: str,
 ):
-    return await ChatService(session).send_messages_with_files(files, chat_id, caption)
+    return await ChatService(session).send_messages_with_files(files, chat_id, caption, user)
 
 
 @chat_router.delete(

schemas/chat.py

@@ -1,7 +1,8 @@
 from datetime import datetime
-from typing import Optional, List
+from typing import Optional
 
 from schemas.base import BaseSchema, OkMessageSchema
+from schemas.user import UserSchema
 
 
 # region Entities
@@ -33,6 +34,7 @@ class EditMessageSchema(BaseMessageSchema):
 class MessageSchema(EditMessageSchema):
     created_at: datetime
     tg_sender: Optional[TgUserSchema]
+    crm_sender: Optional[UserSchema]
     status: str
     is_edited: bool
     file: Optional[MessageFileSchema] = None

services/chat.py

@@ -9,7 +9,7 @@ from backend.config import CHAT_CONNECTOR_API_KEY, CHAT_TELEGRAM_BOT_TOKEN
 from external.chat.chat_client import ChatClient
 from external.chat.schemas import *
 from external.kafka.services.producer_service import ProducerService
-from models import Message, Chat, MessageStatus, TgGroup, Client, Card, MessageFile
+from models import Message, Chat, MessageStatus, TgGroup, Client, Card, MessageFile, User
 from schemas.chat import *
 from services.base import BaseService
 
@@ -162,7 +162,7 @@ class ChatService(BaseService):
         messages = (await self.session.scalars(stmt)).all()
         return GetMessagesResponse(messages=messages)
 
-    async def send_message(self, request: SendTextMessageRequest) -> SendTextMessageResponse:
+    async def send_message(self, request: SendTextMessageRequest, user: User) -> SendTextMessageResponse:
         chat: Optional[Chat] = await self.session.get(Chat, request.message.chat_id)
         if not chat:
             return SendTextMessageResponse(ok=False, message=f'Чат с ID: {request.message.chat_id} не найден')
@@ -172,6 +172,7 @@ class ChatService(BaseService):
             created_at=datetime.now(),
             chat_id=request.message.chat_id,
             status=MessageStatus.sending,
+            crm_sender_id=user.id,
         )
         self.session.add(message)
         await self.session.commit()
@@ -211,39 +212,46 @@ class ChatService(BaseService):
             files: list[UploadFile],
             chat_id: int,
             caption: str,
+            user: User,
     ) -> LoadMessagesResponse:
         chat: Optional[Chat] = await self.session.get(Chat, chat_id)
         if not chat:
             return SendTextMessageResponse(ok=False, message=f'Чат с ID: {chat_id} не найден')
 
-        chat_client = ChatClient(api_key=CHAT_CONNECTOR_API_KEY)
+        try:
-        response = await chat_client.send_messages_with_files(
+            chat_client = ChatClient(api_key=CHAT_CONNECTOR_API_KEY)
-            str(chat.tg_group_id),
+            response = await chat_client.send_messages_with_files(
-            chat.tg_topic_id,
+                str(chat.tg_group_id),
-            caption,
+                chat.tg_topic_id,
-            files
+                caption,
-        )
+                files
-
-        last_message = None
-        for file_schema in response.files:
-            file = MessageFile(**file_schema.model_dump())
-            self.session.add(file)
-
-            message = Message(
-                text='',
-                created_at=datetime.now(),
-                chat_id=chat_id,
-                status=MessageStatus.success,
-                file=file,
             )
-            last_message = message
-            self.session.add(message)
 
-        if last_message:
+            last_message = None
-            last_message.text = caption
+            for file_schema in response.files:
-        await self.session.commit()
+                file = MessageFile(**file_schema.model_dump())
+                self.session.add(file)
 
-        return LoadMessagesResponse(ok=response.ok, message=response.message)
+                message = Message(
+                    text='',
+                    created_at=datetime.now(),
+                    chat_id=chat_id,
+                    status=MessageStatus.success,
+                    file=file,
+                    crm_sender_id=user.id,
+                )
+                last_message = message
+                self.session.add(message)
+
+            if last_message:
+                last_message.text = caption
+            await self.session.commit()
+
+            return LoadMessagesResponse(ok=response.ok, message=response.message)
+        except ClientConnectorError:
+            return LoadMessagesResponse(ok=False, message='Ошибка подключения к сервису')
+        except Exception as e:
+            return LoadMessagesResponse(ok=False, message=str(e))
 
     async def _get_message_by_id(self, message_id: int) -> Optional[Message]:
         stmt = (
@@ -286,7 +294,6 @@ class ChatService(BaseService):
             raise HTTPException(status_code=404, detail=f'Файл с ID {file_id} не найден')
 
         url: str = f'https://api.telegram.org/file/bot{CHAT_TELEGRAM_BOT_TOKEN}/{file.file_path}'
-        print(f'URL = {url}')
 
         response = requests.get(url, stream=True)