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

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

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 # Форматирование этим параметром меняет файлы в гите. Включать там где надо, а не *

View file

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