urec/chat_back
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Чё-то исправил

Browse source
This commit is contained in:
urec56 2024-04-26 10:38:15 +05:00
parent 7bbca84d21
commit 845f014a8e
2 changed files with 238 additions and 223 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
.editorconfig Normal file
View file

@ -0,0 +1,13 @@
# Чтоб применить изменения в JetBrains, надо нажать "Code" -> "Reformat Code" (или Ctrl+Alt+L)
root = true # Главный конфиг. Если в другом каталоге будет другой, то применять этот
[*]
charset = utf-8 # Кодировка ютф8
indent_style = tab # Табуляция пробелами или табуляциями. "space" или "tab"
#indent_size = 4 # Для пробелов
tab_width = 4 # Для табов
insert_final_newline = true # При сохранении файла в конце должна быть пустая строка
trim_trailing_whitespace = true # При сохранении файла удалить все лишние пробелы в конце строк
end_of_line = lf # Символ конца строки для linux. Этот символ говорит, когда перенос строки происходит
#max_line_length = 100 # Форматирование этим параметром меняет файлы в гите. Включать там где надо, а не *

448
app/users/chat/dao.py
View file

@ -8,77 +8,77 @@ from app.users.chat.models import Chats, Messages, UsersXChats, PinnedChats, Pin
class ChatDAO(BaseDAO): class ChatDAO(BaseDAO):
model = Chats model = Chats
@staticmethod @staticmethod
async def create(user_id: int, chat_name: str, created_by: int) -> int: async def create(user_id: int, chat_name: str, created_by: int) -> int:
query = insert(Chats).values(chat_for=user_id, chat_name=chat_name, created_by=created_by).returning(Chats.id) query = insert(Chats).values(chat_for=user_id, chat_name=chat_name, created_by=created_by).returning(Chats.id)
async with async_session_maker() as session: async with async_session_maker() as session:
result = await session.execute(query) result = await session.execute(query)
await session.commit() await session.commit()
result = result.scalar() result = result.scalar()
return result return result
@staticmethod @staticmethod
async def add_user_to_chat(user_id: int, chat_id: int) -> bool: async def add_user_to_chat(user_id: int, chat_id: int) -> bool:
query = select(UsersXChats.user_id).where(UsersXChats.chat_id == chat_id) query = select(UsersXChats.user_id).where(UsersXChats.chat_id == chat_id)
async with async_session_maker() as session: async with async_session_maker() as session:
result = await session.execute(query) result = await session.execute(query)
result = result.scalars().all() result = result.scalars().all()
if user_id in result: if user_id in result:
raise UserAlreadyInChatException raise UserAlreadyInChatException
query = insert(UsersXChats).values(user_id=user_id, chat_id=chat_id) query = insert(UsersXChats).values(user_id=user_id, chat_id=chat_id)
await session.execute(query) await session.execute(query)
await session.commit() await session.commit()
return True return True
@staticmethod @staticmethod
async def send_message(user_id: int, chat_id: int, message: str, image_url: str | None = None) -> list[dict]: async def send_message(user_id: int, chat_id: int, message: str, image_url: str | None = None) -> list[dict]:
inserted_image = ( inserted_image = (
insert(Messages).values(chat_id=chat_id, user_id=user_id, message=message, image_url=image_url) insert(Messages).values(chat_id=chat_id, user_id=user_id, message=message, image_url=image_url)
.returning(Messages.id, Messages.message, Messages.image_url, Messages.chat_id, .returning(Messages.id, Messages.message, Messages.image_url, Messages.chat_id,
Messages.user_id, Messages.created_at).cte("inserted_image")) Messages.user_id, Messages.created_at).cte("inserted_image"))
query = (select(inserted_image.c.id, inserted_image.c.message, inserted_image.c.image_url, query = (select(inserted_image.c.id, inserted_image.c.message, inserted_image.c.image_url,
inserted_image.c.chat_id, inserted_image.c.user_id, inserted_image.c.created_at, inserted_image.c.chat_id, inserted_image.c.user_id, inserted_image.c.created_at,
Users.avatar_image, Users.username, Users.avatar_hex, Answers.answer_id, Answers.message_id) Users.avatar_image, Users.username, Users.avatar_hex, Answers.answer_id, Answers.message_id)
.select_from(inserted_image) .select_from(inserted_image)
.join(Users, Users.id == inserted_image.c.user_id) .join(Users, Users.id == inserted_image.c.user_id)
.join(Answers, Answers.answer_id == inserted_image.c.id, isouter=True)) .join(Answers, Answers.answer_id == inserted_image.c.id, isouter=True))
async with async_session_maker() as session: async with async_session_maker() as session:
result = await session.execute(query) result = await session.execute(query)
await session.commit() await session.commit()
return result.mappings().all() return result.mappings().all()
@staticmethod @staticmethod
async def get_message_by_id(message_id: int): async def get_message_by_id(message_id: int):
query = (select(Messages.id, Messages.message, Messages.image_url, Messages.chat_id, Messages.user_id, query = (select(Messages.id, Messages.message, Messages.image_url, Messages.chat_id, Messages.user_id,
Messages.created_at, Users.avatar_image, Users.username, Users.avatar_hex, Messages.created_at, Users.avatar_image, Users.username, Users.avatar_hex,
Answers.answer_id, Answers.message_id).select_from(Messages) Answers.answer_id, Answers.message_id).select_from(Messages)
.join(Users, Users.id == Messages.user_id) .join(Users, Users.id == Messages.user_id)
.join(Answers, Answers.answer_id == Messages.id, isouter=True) .join(Answers, Answers.answer_id == Messages.id, isouter=True)
.where( .where(
and_( and_(
Messages.id == message_id, Messages.id == message_id,
Messages.visibility == True Messages.visibility == True
) )
)) ))
async with async_session_maker() as session: async with async_session_maker() as session:
result = await session.execute(query) result = await session.execute(query)
result = result.mappings().all() result = result.mappings().all()
if result: if result:
return result[0] return result[0]
@staticmethod @staticmethod
async def delete_message(message_id: int) -> bool: async def delete_message(message_id: int) -> bool:
query = update(Messages).where(Messages.id == message_id).values(visibility=False) query = update(Messages).where(Messages.id == message_id).values(visibility=False)
async with async_session_maker() as session: async with async_session_maker() as session:
await session.execute(query) await session.execute(query)
await session.commit() await session.commit()
return True return True
@staticmethod @staticmethod
async def get_some_messages(chat_id: int, message_number_from: int, messages_to_get: int) -> list[dict]: async def get_some_messages(chat_id: int, message_number_from: int, messages_to_get: int) -> list[dict]:
""" """
WITH messages_with_users AS ( WITH messages_with_users AS (
SELECT * SELECT *
FROM messages FROM messages
@ -91,175 +91,177 @@ class ChatDAO(BaseDAO):
ORDER BY created_at DESC ORDER BY created_at DESC
LIMIT 15 OFFSET 0; LIMIT 15 OFFSET 0;
""" """
messages_with_users = ( messages_with_users = (
select(Messages.__table__.columns, Users.__table__.columns, Answers.__table__.columns) select(Messages.__table__.columns, Users.__table__.columns, Answers.__table__.columns)
.select_from(Messages) .select_from(Messages)
.join(Users, Messages.user_id == Users.id) .join(Users, Messages.user_id == Users.id)
.join(Answers, Answers.answer_id == Messages.id, isouter=True)).cte('messages_with_users') .join(Answers, Answers.answer_id == Messages.id, isouter=True)).cte('messages_with_users')
messages = (select(messages_with_users.c.id, messages_with_users.c.message, messages_with_users.c.image_url, messages = (select(messages_with_users.c.id, 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.chat_id, messages_with_users.c.user_id,
messages_with_users.c.created_at, messages_with_users.c.avatar_image, messages_with_users.c.created_at, messages_with_users.c.avatar_image,
messages_with_users.c.username, messages_with_users.c.avatar_hex, messages_with_users.c.username, messages_with_users.c.avatar_hex,
messages_with_users.c.answer_id, messages_with_users.c.message_id, messages_with_users.c.answer_id, messages_with_users.c.message_id,
) )
.where( .where(
and_( and_(
messages_with_users.c.chat_id == chat_id, messages_with_users.c.chat_id == chat_id,
messages_with_users.c.visibility == True messages_with_users.c.visibility == True
) )
).order_by(messages_with_users.c.created_at.desc()).limit(messages_to_get).offset(message_number_from)) ).order_by(messages_with_users.c.created_at.desc()).limit(messages_to_get).offset(message_number_from))
async with async_session_maker() as session: async with async_session_maker() as session:
result = await session.execute(messages) result = await session.execute(messages)
result = result.mappings().all() result = result.mappings().all()
if result: if result:
result = [dict(res) for res in result] result = [dict(res) for res in result]
return result return result
@staticmethod @staticmethod
async def edit_message(message_id: int, new_message: str, new_image_url: str) -> bool: async def edit_message(message_id: int, new_message: str, new_image_url: str) -> bool:
query = update(Messages).where(Messages.id == message_id).values(message=new_message, image_url=new_image_url) query = update(Messages).where(Messages.id == message_id).values(message=new_message, image_url=new_image_url)
async with async_session_maker() as session: async with async_session_maker() as session:
await session.execute(query) await session.execute(query)
await session.commit() await session.commit()
return True return True
@staticmethod @staticmethod
async def add_answer(message_id: int, answer_id: int) -> list[dict]: async def add_answer(message_id: int, answer_id: int) -> list[dict]:
answer = (insert(Answers).values(message_id=message_id, answer_id=answer_id) answer = (insert(Answers).values(message_id=message_id, answer_id=answer_id)
.returning(Answers.answer_id, Answers.message_id).cte("answer")) .returning(Answers.answer_id, Answers.message_id).cte("answer"))
query = (select(Messages.id, Messages.message, Messages.image_url, query = (select(Messages.id, Messages.message, Messages.image_url,
Messages.chat_id, Messages.user_id, Messages.created_at, Messages.chat_id, Messages.user_id, Messages.created_at,
Users.avatar_image, Users.username, Users.avatar_hex, answer.c.answer_id, answer.c.message_id) Users.avatar_image, Users.username, Users.avatar_hex, answer.c.answer_id, answer.c.message_id)
.select_from(Messages) .select_from(Messages)
.join(Users, Users.id == Messages.user_id) .join(Users, Users.id == Messages.user_id)
.join(answer, answer.c.answer_id == Messages.id, isouter=True) .join(answer, answer.c.answer_id == Messages.id, isouter=True)
.where(Messages.id == answer_id)) .where(Messages.id == answer_id))
async with async_session_maker() as session: async with async_session_maker() as session:
result = await session.execute(query) result = await session.execute(query)
await session.commit() await session.commit()
return result.mappings().all() return result.mappings().all()
@staticmethod @staticmethod
async def delete_chat(chat_id: int) -> bool: async def delete_chat(chat_id: int) -> bool:
query = update(Chats).where(Chats.id == chat_id).values(visibility=False) query = update(Chats).where(Chats.id == chat_id).values(visibility=False)
async with async_session_maker() as session: async with async_session_maker() as session:
await session.execute(query) await session.execute(query)
await session.commit() await session.commit()
return True return True
@staticmethod @staticmethod
async def delete_user(chat_id: int, user_id: int) -> bool: async def delete_user(chat_id: int, user_id: int) -> bool:
query = delete(UsersXChats).where(and_( query = delete(UsersXChats).where(and_(
UsersXChats.chat_id == chat_id, UsersXChats.chat_id == chat_id,
UsersXChats.user_id == user_id UsersXChats.user_id == user_id
)) ))
async with async_session_maker() as session: async with async_session_maker() as session:
await session.execute(query) await session.execute(query)
await session.commit() await session.commit()
return True return True
@staticmethod @staticmethod
async def pinn_chat(chat_id: int, user_id: int) -> bool: async def pinn_chat(chat_id: int, user_id: int) -> bool:
query = select(PinnedChats.chat_id).where(PinnedChats.user_id == user_id) query = select(PinnedChats.chat_id).where(PinnedChats.user_id == user_id)
async with async_session_maker() as session: async with async_session_maker() as session:
result = await session.execute(query) result = await session.execute(query)
result = result.scalars().all() result = result.scalars().all()
if chat_id in result: if chat_id in result:
raise UserAlreadyPinnedChatException raise UserAlreadyPinnedChatException
query = insert(PinnedChats).values(chat_id=chat_id, user_id=user_id) query = insert(PinnedChats).values(chat_id=chat_id, user_id=user_id)
await session.execute(query) await session.execute(query)
await session.commit() await session.commit()
return True return True
@staticmethod @staticmethod
async def unpinn_chat(chat_id: int, user_id: int) -> bool: async def unpinn_chat(chat_id: int, user_id: int) -> bool:
query = delete(PinnedChats).where(PinnedChats.chat_id == chat_id, PinnedChats.user_id == user_id) query = delete(PinnedChats).where(PinnedChats.chat_id == chat_id, PinnedChats.user_id == user_id)
async with async_session_maker() as session: async with async_session_maker() as session:
await session.execute(query) await session.execute(query)
await session.commit() await session.commit()
return True return True
@staticmethod @staticmethod
async def get_pinned_chats(user_id: int): async def get_pinned_chats(user_id: int):
chats_with_descriptions = (select(UsersXChats.__table__.columns, Chats.__table__.columns) chats_with_descriptions = (select(UsersXChats.__table__.columns, Chats.__table__.columns)
.select_from(UsersXChats) .select_from(UsersXChats)
.join(Chats, UsersXChats.chat_id == Chats.id) .join(Chats, UsersXChats.chat_id == Chats.id)
).cte('chats_with_descriptions') ).cte('chats_with_descriptions')
chats_with_avatars = (select( chats_with_avatars = (select(
chats_with_descriptions.c.chat_id, chats_with_descriptions.c.chat_id,
chats_with_descriptions.c.chat_for, chats_with_descriptions.c.chat_for,
chats_with_descriptions.c.chat_name, chats_with_descriptions.c.chat_name,
chats_with_descriptions.c.visibility, chats_with_descriptions.c.visibility,
Users.id, Users.id,
Users.avatar_image, Users.avatar_image,
) Users.avatar_hex,
.select_from(chats_with_descriptions) )
.join(Users, Users.id == chats_with_descriptions.c.user_id) .select_from(chats_with_descriptions)
.cte('chats_with_avatars')) .join(Users, Users.id == chats_with_descriptions.c.user_id)
.cte('chats_with_avatars'))
query = (select( query = (select(
chats_with_avatars.c.chat_id, chats_with_avatars.c.chat_id,
chats_with_avatars.c.chat_for, chats_with_avatars.c.chat_for,
chats_with_avatars.c.chat_name, chats_with_avatars.c.chat_name,
chats_with_avatars.c.avatar_image chats_with_avatars.c.avatar_image,
) chats_with_avatars.c.avatar_hex,
.distinct() )
.select_from(PinnedChats) .distinct()
.join(chats_with_avatars, PinnedChats.chat_id == chats_with_avatars.c.chat_id) .select_from(PinnedChats)
.where( .join(chats_with_avatars, PinnedChats.chat_id == chats_with_avatars.c.chat_id)
and_( .where(
chats_with_avatars.c.id == user_id, and_(
chats_with_avatars.c.visibility == True chats_with_avatars.c.id == user_id,
))) chats_with_avatars.c.visibility == True
# print(query.compile(engine, compile_kwargs={"literal_binds": True})) # Проверка SQL запроса )))
async with async_session_maker() as session: # print(query.compile(engine, compile_kwargs={"literal_binds": True})) # Проверка SQL запроса
result = await session.execute(query) async with async_session_maker() as session:
result = result.mappings().all() result = await session.execute(query)
return result result = result.mappings().all()
return result
@staticmethod @staticmethod
async def pinn_message(chat_id: int, message_id: int, user_id: int) -> bool: async def pinn_message(chat_id: int, message_id: int, user_id: int) -> bool:
query = insert(PinnedMessages).values(chat_id=chat_id, message_id=message_id, user_id=user_id) query = insert(PinnedMessages).values(chat_id=chat_id, message_id=message_id, user_id=user_id)
async with async_session_maker() as session: async with async_session_maker() as session:
await session.execute(query) await session.execute(query)
await session.commit() await session.commit()
return True return True
@staticmethod @staticmethod
async def get_message_pinner(chat_id: int, message_id: int) -> bool: async def get_message_pinner(chat_id: int, message_id: int) -> bool:
query = select(PinnedMessages.user_id).where( query = select(PinnedMessages.user_id).where(
PinnedMessages.chat_id == chat_id, PinnedMessages.message_id == message_id PinnedMessages.chat_id == chat_id, PinnedMessages.message_id == message_id
) )
async with async_session_maker() as session: async with async_session_maker() as session:
result = await session.execute(query) result = await session.execute(query)
result = result.scalar() result = result.scalar()
return result return result
@staticmethod @staticmethod
async def unpinn_message(chat_id: int, message_id: int) -> bool: async def unpinn_message(chat_id: int, message_id: int) -> bool:
query = delete(PinnedMessages).where( query = delete(PinnedMessages).where(
PinnedMessages.chat_id == chat_id, PinnedMessages.message_id == message_id PinnedMessages.chat_id == chat_id, PinnedMessages.message_id == message_id
) )
async with async_session_maker() as session: async with async_session_maker() as session:
await session.execute(query) await session.execute(query)
await session.commit() await session.commit()
return True return True
@staticmethod @staticmethod
async def get_pinned_messages(chat_id: int) -> list[dict]: async def get_pinned_messages(chat_id: int) -> list[dict]:
query = (select(Messages.id, Messages.message, Messages.image_url, query = (select(Messages.id, Messages.message, Messages.image_url,
Messages.chat_id, Messages.user_id, Messages.chat_id, Messages.user_id,
Messages.created_at, Users.avatar_image, Messages.created_at, Users.avatar_image,
Users.username).select_from(PinnedMessages) Users.username).select_from(PinnedMessages)
.join(Messages, PinnedMessages.message_id == Messages.id, isouter=True) .join(Messages, PinnedMessages.message_id == Messages.id, isouter=True)
.join(Users, PinnedMessages.user_id == Users.id, isouter=True) .join(Users, PinnedMessages.user_id == Users.id, isouter=True)
.where(and_(PinnedMessages.chat_id == chat_id, Messages.visibility == True)) .where(and_(PinnedMessages.chat_id == chat_id, Messages.visibility == True))
.order_by(Messages.created_at.desc())) .order_by(Messages.created_at.desc()))
async with async_session_maker() as session: async with async_session_maker() as session:
result = await session.execute(query) result = await session.execute(query)
result = result.mappings().all() result = result.mappings().all()
if result: if result:
result = [dict(res) for res in result] result = [dict(res) for res in result]
return result return result