405 lines
15 KiB
Python
405 lines
15 KiB
Python
from fastapi import APIRouter, Depends, status
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.auth.service import get_current_user
|
|
from app.chats.schemas import (
|
|
ChatBanRead,
|
|
ChatCreateRequest,
|
|
ChatDetailRead,
|
|
ChatDiscoverRead,
|
|
ChatDeleteRequest,
|
|
ChatInviteLinkRead,
|
|
ChatJoinByInviteRequest,
|
|
ChatMemberAddRequest,
|
|
ChatMemberRead,
|
|
ChatMemberRoleUpdateRequest,
|
|
ChatNotificationSettingsRead,
|
|
ChatNotificationSettingsUpdate,
|
|
ChatPinMessageRequest,
|
|
ChatProfileUpdateRequest,
|
|
ChatRead,
|
|
ChatTitleUpdateRequest,
|
|
)
|
|
from app.chats import repository as chats_repository
|
|
from app.chats.models import ChatMemberRole, ChatType
|
|
from app.chats.service import (
|
|
add_chat_member_for_user,
|
|
ban_chat_member_for_user,
|
|
create_chat_for_user,
|
|
create_chat_invite_link_for_user,
|
|
clear_chat_for_user,
|
|
delete_chat_for_user,
|
|
discover_public_chats_for_user,
|
|
ensure_saved_messages_chat,
|
|
get_chat_for_user,
|
|
get_chat_notification_settings_for_user,
|
|
get_chats_for_user,
|
|
join_public_chat_for_user,
|
|
join_chat_by_invite_for_user,
|
|
leave_chat_for_user,
|
|
pin_chat_message_for_user,
|
|
remove_chat_member_for_user,
|
|
list_chat_bans_for_user,
|
|
serialize_chat_for_user,
|
|
serialize_chats_for_user,
|
|
set_chat_archived_for_user,
|
|
set_chat_pinned_for_user,
|
|
unban_chat_member_for_user,
|
|
update_chat_member_role_for_user,
|
|
update_chat_notification_settings_for_user,
|
|
update_chat_profile_for_user,
|
|
update_chat_title_for_user,
|
|
)
|
|
from app.database.session import get_db
|
|
from app.realtime.service import realtime_gateway
|
|
from app.users.models import User
|
|
|
|
router = APIRouter(prefix="/chats", tags=["chats"])
|
|
|
|
|
|
@router.get("", response_model=list[ChatRead])
|
|
async def list_chats(
|
|
limit: int = 50,
|
|
before_id: int | None = None,
|
|
query: str | None = None,
|
|
archived: bool = False,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> list[ChatRead]:
|
|
chats = await get_chats_for_user(
|
|
db,
|
|
user_id=current_user.id,
|
|
limit=limit,
|
|
before_id=before_id,
|
|
query=query,
|
|
archived=archived,
|
|
)
|
|
return await serialize_chats_for_user(db, user_id=current_user.id, chats=chats)
|
|
|
|
|
|
@router.get("/saved", response_model=ChatRead)
|
|
async def get_saved_messages_chat(
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> ChatRead:
|
|
chat = await ensure_saved_messages_chat(db, user_id=current_user.id)
|
|
return await serialize_chat_for_user(db, user_id=current_user.id, chat=chat)
|
|
|
|
|
|
@router.get("/discover", response_model=list[ChatDiscoverRead])
|
|
async def discover_chats(
|
|
query: str | None = None,
|
|
limit: int = 30,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> list[ChatDiscoverRead]:
|
|
return await discover_public_chats_for_user(db, user_id=current_user.id, query=query, limit=limit)
|
|
|
|
|
|
@router.post("", response_model=ChatRead)
|
|
async def create_chat(
|
|
payload: ChatCreateRequest,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> ChatRead:
|
|
chat = await create_chat_for_user(db, creator_id=current_user.id, payload=payload)
|
|
member_user_ids = await chats_repository.list_chat_member_user_ids(db, chat_id=chat.id)
|
|
for member_user_id in member_user_ids:
|
|
realtime_gateway.add_chat_subscription(chat_id=chat.id, user_id=member_user_id)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat.id)
|
|
return await serialize_chat_for_user(db, user_id=current_user.id, chat=chat)
|
|
|
|
|
|
@router.post("/{chat_id}/join", response_model=ChatRead)
|
|
async def join_chat(
|
|
chat_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> ChatRead:
|
|
chat = await join_public_chat_for_user(db, chat_id=chat_id, user_id=current_user.id)
|
|
realtime_gateway.add_chat_subscription(chat_id=chat.id, user_id=current_user.id)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat.id)
|
|
return await serialize_chat_for_user(db, user_id=current_user.id, chat=chat)
|
|
|
|
|
|
@router.get("/{chat_id}", response_model=ChatDetailRead)
|
|
async def get_chat(
|
|
chat_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> ChatDetailRead:
|
|
chat, members = await get_chat_for_user(db, chat_id=chat_id, user_id=current_user.id)
|
|
base = await serialize_chat_for_user(db, user_id=current_user.id, chat=chat)
|
|
return ChatDetailRead.model_validate(
|
|
{
|
|
**base.model_dump(),
|
|
"members": members,
|
|
}
|
|
)
|
|
|
|
|
|
@router.patch("/{chat_id}/title", response_model=ChatRead)
|
|
async def update_chat_title(
|
|
chat_id: int,
|
|
payload: ChatTitleUpdateRequest,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> ChatRead:
|
|
chat = await update_chat_title_for_user(db, chat_id=chat_id, user_id=current_user.id, payload=payload)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat.id)
|
|
return await serialize_chat_for_user(db, user_id=current_user.id, chat=chat)
|
|
|
|
|
|
@router.patch("/{chat_id}/profile", response_model=ChatRead)
|
|
async def update_chat_profile(
|
|
chat_id: int,
|
|
payload: ChatProfileUpdateRequest,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> ChatRead:
|
|
chat = await update_chat_profile_for_user(db, chat_id=chat_id, user_id=current_user.id, payload=payload)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat.id)
|
|
return await serialize_chat_for_user(db, user_id=current_user.id, chat=chat)
|
|
|
|
|
|
@router.get("/{chat_id}/members", response_model=list[ChatMemberRead])
|
|
async def list_chat_members(
|
|
chat_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> list[ChatMemberRead]:
|
|
_chat, members = await get_chat_for_user(db, chat_id=chat_id, user_id=current_user.id)
|
|
return members
|
|
|
|
|
|
@router.post("/{chat_id}/members", response_model=ChatMemberRead, status_code=status.HTTP_201_CREATED)
|
|
async def add_chat_member(
|
|
chat_id: int,
|
|
payload: ChatMemberAddRequest,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> ChatMemberRead:
|
|
member = await add_chat_member_for_user(db, chat_id=chat_id, actor_user_id=current_user.id, target_user_id=payload.user_id)
|
|
realtime_gateway.add_chat_subscription(chat_id=chat_id, user_id=payload.user_id)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat_id)
|
|
return member
|
|
|
|
|
|
@router.patch("/{chat_id}/members/{user_id}/role", response_model=ChatMemberRead)
|
|
async def update_chat_member_role(
|
|
chat_id: int,
|
|
user_id: int,
|
|
payload: ChatMemberRoleUpdateRequest,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> ChatMemberRead:
|
|
member = await update_chat_member_role_for_user(
|
|
db,
|
|
chat_id=chat_id,
|
|
actor_user_id=current_user.id,
|
|
target_user_id=user_id,
|
|
role=payload.role,
|
|
)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat_id)
|
|
return member
|
|
|
|
|
|
@router.delete("/{chat_id}/members/{user_id}", status_code=status.HTTP_204_NO_CONTENT)
|
|
async def remove_chat_member(
|
|
chat_id: int,
|
|
user_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> None:
|
|
await remove_chat_member_for_user(db, chat_id=chat_id, actor_user_id=current_user.id, target_user_id=user_id)
|
|
realtime_gateway.remove_chat_subscription(chat_id=chat_id, user_id=user_id)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat_id)
|
|
|
|
|
|
@router.post("/{chat_id}/bans/{user_id}", status_code=status.HTTP_204_NO_CONTENT)
|
|
async def ban_chat_member(
|
|
chat_id: int,
|
|
user_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> None:
|
|
await ban_chat_member_for_user(db, chat_id=chat_id, actor_user_id=current_user.id, target_user_id=user_id)
|
|
realtime_gateway.remove_chat_subscription(chat_id=chat_id, user_id=user_id)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat_id)
|
|
|
|
|
|
@router.get("/{chat_id}/bans", response_model=list[ChatBanRead])
|
|
async def list_chat_bans(
|
|
chat_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> list[ChatBanRead]:
|
|
return await list_chat_bans_for_user(db, chat_id=chat_id, actor_user_id=current_user.id)
|
|
|
|
|
|
@router.delete("/{chat_id}/bans/{user_id}", status_code=status.HTTP_204_NO_CONTENT)
|
|
async def unban_chat_member(
|
|
chat_id: int,
|
|
user_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> None:
|
|
await unban_chat_member_for_user(db, chat_id=chat_id, actor_user_id=current_user.id, target_user_id=user_id)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat_id)
|
|
|
|
|
|
@router.post("/{chat_id}/leave", status_code=status.HTTP_204_NO_CONTENT)
|
|
async def leave_chat(
|
|
chat_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> None:
|
|
await leave_chat_for_user(db, chat_id=chat_id, user_id=current_user.id)
|
|
realtime_gateway.remove_chat_subscription(chat_id=chat_id, user_id=current_user.id)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat_id)
|
|
|
|
|
|
@router.delete("/{chat_id}", status_code=status.HTTP_204_NO_CONTENT)
|
|
async def delete_chat(
|
|
chat_id: int,
|
|
for_all: bool = False,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> None:
|
|
chat_before_delete = await chats_repository.get_chat_by_id(db, chat_id)
|
|
membership_before_delete = (
|
|
await chats_repository.get_chat_member(db, chat_id=chat_id, user_id=current_user.id) if chat_before_delete else None
|
|
)
|
|
delete_for_all = bool(
|
|
chat_before_delete
|
|
and (
|
|
(for_all and not chat_before_delete.is_saved)
|
|
or (
|
|
chat_before_delete.type == ChatType.CHANNEL
|
|
and not chat_before_delete.is_saved
|
|
and membership_before_delete is not None
|
|
and membership_before_delete.role in {ChatMemberRole.OWNER, ChatMemberRole.ADMIN}
|
|
)
|
|
)
|
|
)
|
|
await delete_chat_for_user(db, chat_id=chat_id, user_id=current_user.id, payload=ChatDeleteRequest(for_all=for_all))
|
|
if chat_before_delete and not chat_before_delete.is_saved:
|
|
realtime_gateway.remove_chat_subscription(chat_id=chat_id, user_id=current_user.id)
|
|
if delete_for_all:
|
|
await realtime_gateway.publish_chat_deleted(chat_id=chat_id)
|
|
else:
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat_id)
|
|
|
|
|
|
@router.post("/{chat_id}/clear", status_code=status.HTTP_204_NO_CONTENT)
|
|
async def clear_chat(
|
|
chat_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> None:
|
|
await clear_chat_for_user(db, chat_id=chat_id, user_id=current_user.id)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat_id)
|
|
|
|
|
|
@router.post("/{chat_id}/pin", response_model=ChatRead)
|
|
async def pin_chat_message(
|
|
chat_id: int,
|
|
payload: ChatPinMessageRequest,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> ChatRead:
|
|
chat = await pin_chat_message_for_user(db, chat_id=chat_id, user_id=current_user.id, payload=payload)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat.id)
|
|
return await serialize_chat_for_user(db, user_id=current_user.id, chat=chat)
|
|
|
|
|
|
@router.get("/{chat_id}/notifications", response_model=ChatNotificationSettingsRead)
|
|
async def get_chat_notifications(
|
|
chat_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> ChatNotificationSettingsRead:
|
|
return await get_chat_notification_settings_for_user(db, chat_id=chat_id, user_id=current_user.id)
|
|
|
|
|
|
@router.put("/{chat_id}/notifications", response_model=ChatNotificationSettingsRead)
|
|
async def update_chat_notifications(
|
|
chat_id: int,
|
|
payload: ChatNotificationSettingsUpdate,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> ChatNotificationSettingsRead:
|
|
settings = await update_chat_notification_settings_for_user(
|
|
db,
|
|
chat_id=chat_id,
|
|
user_id=current_user.id,
|
|
payload=payload,
|
|
)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat_id)
|
|
return settings
|
|
|
|
|
|
@router.post("/{chat_id}/archive", response_model=ChatRead)
|
|
async def archive_chat(
|
|
chat_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> ChatRead:
|
|
chat = await set_chat_archived_for_user(db, chat_id=chat_id, user_id=current_user.id, archived=True)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat_id)
|
|
return await serialize_chat_for_user(db, user_id=current_user.id, chat=chat)
|
|
|
|
|
|
@router.post("/{chat_id}/unarchive", response_model=ChatRead)
|
|
async def unarchive_chat(
|
|
chat_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> ChatRead:
|
|
chat = await set_chat_archived_for_user(db, chat_id=chat_id, user_id=current_user.id, archived=False)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat_id)
|
|
return await serialize_chat_for_user(db, user_id=current_user.id, chat=chat)
|
|
|
|
|
|
@router.post("/{chat_id}/pin-chat", response_model=ChatRead)
|
|
async def pin_chat(
|
|
chat_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> ChatRead:
|
|
chat = await set_chat_pinned_for_user(db, chat_id=chat_id, user_id=current_user.id, pinned=True)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat_id)
|
|
return await serialize_chat_for_user(db, user_id=current_user.id, chat=chat)
|
|
|
|
|
|
@router.post("/{chat_id}/unpin-chat", response_model=ChatRead)
|
|
async def unpin_chat(
|
|
chat_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> ChatRead:
|
|
chat = await set_chat_pinned_for_user(db, chat_id=chat_id, user_id=current_user.id, pinned=False)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat_id)
|
|
return await serialize_chat_for_user(db, user_id=current_user.id, chat=chat)
|
|
|
|
|
|
@router.post("/{chat_id}/invite-link", response_model=ChatInviteLinkRead)
|
|
async def create_invite_link(
|
|
chat_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> ChatInviteLinkRead:
|
|
return await create_chat_invite_link_for_user(db, chat_id=chat_id, user_id=current_user.id)
|
|
|
|
|
|
@router.post("/join-by-invite", response_model=ChatRead)
|
|
async def join_by_invite(
|
|
payload: ChatJoinByInviteRequest,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
) -> ChatRead:
|
|
chat = await join_chat_by_invite_for_user(db, user_id=current_user.id, payload=payload)
|
|
realtime_gateway.add_chat_subscription(chat_id=chat.id, user_id=current_user.id)
|
|
await realtime_gateway.publish_chat_updated(chat_id=chat.id)
|
|
return await serialize_chat_for_user(db, user_id=current_user.id, chat=chat)
|