backend/src/api/services/message.py - master - FlysAt/DataFoundry

backend/src/api/services/message.py
75 строк3 KB
AlexanderShmygol
refactoring
07 апр 2026, 13:55
07 апр 2026, 13:555cff70c
from fastapi import HTTPException
from sqlalchemy.ext.asyncio import AsyncSession

from src.api.repositories.message import MessageRepository
from src.api.repositories.order import OrderRepository
from src.models.message import Message
from src.models.order import Order
from src.models.user import User
from src.schemas.message import MessageCreateSchema, MessageUpdateSchema


class MessageService:
    def __init__(self, db: AsyncSession) -> None:
        self.messages = MessageRepository(db)
        self.orders = OrderRepository(db)

    @staticmethod
    def _can_access_order_chat(order: Order, user: User) -> bool:
        return user.id in {order.customer_id, order.current_executor_id}

    async def _get_order(self, order_id: int) -> Order:
        order = await self.orders.get_by_id(order_id)
        if not order:
            raise HTTPException(status_code=404, detail="Order not found")
        return order

    async def _get_message(self, message_id: int, order_id: int) -> Message:
        message = await self.messages.get_by_id_and_order(message_id, order_id)
        if not message:
            raise HTTPException(status_code=404, detail="Message not found")
        return message

    async def create_message(
        self,
        order_id: int,
        payload: MessageCreateSchema,
        current_user: User,
    ) -> Message:
        order = await self._get_order(order_id)
        if not self._can_access_order_chat(order, current_user):
            raise HTTPException(
                status_code=403,
                detail="Chat is available only for order participants",
            )

        message = Message(order_id=order_id, sender_id=current_user.id, text=payload.text)
        return await self.messages.create(message)

    async def list_messages(self, order_id: int, current_user: User) -> list[Message]:
        order = await self._get_order(order_id)
        if not self._can_access_order_chat(order, current_user):
            raise HTTPException(status_code=403, detail="No access to chat")

        return await self.messages.list_by_order(order_id)

    async def update_message(
        self,
        order_id: int,
        message_id: int,
        payload: MessageUpdateSchema,
        current_user: User,
    ) -> Message:
        message = await self._get_message(message_id, order_id)
        if message.sender_id != current_user.id:
            raise HTTPException(status_code=403, detail="You can edit only your messages")

        message.text = payload.text
        return await self.messages.save(message)

    async def delete_message(self, order_id: int, message_id: int, current_user: User) -> None:
        message = await self._get_message(message_id, order_id)
        if message.sender_id != current_user.id:
            raise HTTPException(status_code=403, detail="You can delete only your messages")

        await self.messages.delete(message)