Dev

src/app/bot.py

@@ -3,6 +3,7 @@
 from aiogram.fsm.storage.memory import MemoryStorage
 
 from src.db import db
+from src.middlewares import UpdateUserMiddleware
 from src.handlers import (
     legacy_route,
     common,
@@ -11,16 +12,20 @@
     wishes,
     invitation,
     debug,
-    join_room
+    join_room,
+    settings as room_settings,
 )
 
 
 async def run_bot(token: str) -> None:
     await db.start_db()
-    bot = Bot(token,
-              default=DefaultBotProperties(parse_mode="HTML"),
-              )
+    bot = Bot(
+        token,
+        default=DefaultBotProperties(parse_mode="HTML"),
+    )
     dp = Dispatcher(storage=MemoryStorage())
+    dp.message.middleware(UpdateUserMiddleware())
+    dp.callback_query.middleware(UpdateUserMiddleware())
 
     dp.include_routers(
         legacy_route.router,
@@ -31,6 +36,7 @@ async def run_bot(token: str) -> None:
         invitation.router,
         debug.router,
         join_room.router,
+        room_settings.router,
     )
 
     await bot.delete_webhook(drop_pending_updates=True)

src/db/db.py

@@ -7,12 +7,25 @@
 db = sq.connect(DB_PATH)
 cur = db.cursor()
 
+ROOM_DEFAULT_PRICE = "не установлен"
+ROOM_DEFAULT_EVENT_TIME = "не установлено"
+ROOM_DEFAULT_EXCHANGE_TYPE = "централизованый"
+
 
 async def start_db():
     cur.execute(
-        "CREATE TABLE IF NOT EXISTS rooms(room_iden TEXT PRIMARY KEY,status BOOLEAN DEFAULT FALSE,admin INTEGER)")
+        "CREATE TABLE IF NOT EXISTS rooms("
+        "room_iden TEXT PRIMARY KEY,"
+        "status BOOLEAN DEFAULT FALSE,"
+        "admin INTEGER,"
+        "gift_price_range TEXT DEFAULT 'не установлен',"
+        "event_time TEXT DEFAULT 'не установлено',"
+        "exchange_type TEXT DEFAULT 'централизованый'"
+        ")"
+    )
     cur.execute(
-        "CREATE TABLE IF NOT EXISTS users(tg_id INTEGER PRIMARY KEY,first_name TEXT,last_name TEXT,username TEXT)")
+        "CREATE TABLE IF NOT EXISTS users(tg_id INTEGER PRIMARY KEY,first_name TEXT,last_name TEXT,username TEXT)"
+    )
     cur.execute(
         """
         CREATE TABLE IF NOT EXISTS user_rooms(
@@ -24,27 +37,78 @@ async def start_db():
         )
         """
     )
+    await migrate_rooms_table()
     db.commit()
 
 
 async def create_room(room_name, user_id):
-    disvalid = ["_saint", "_mem", "\\", ".", "/", ",", ":", ";", "'", "\"", " ", "*", "+", "-", "#", "@", "$", "%", "^",
-                "!", "~", "`", "&", "|", "<", ">", "[", "]", "(", ")", "{", "}"]
-    if all([a not in room_name for a in disvalid]) and room_name[0] not in "0123456789" and len(room_name) <= 30:
+    disvalid = [
+        "_saint",
+        "_mem",
+        "\\",
+        ".",
+        "/",
+        ",",
+        ":",
+        ";",
+        "'",
+        '"',
+        " ",
+        "*",
+        "+",
+        "-",
+        "#",
+        "@",
+        "$",
+        "%",
+        "^",
+        "!",
+        "~",
+        "`",
+        "&",
+        "|",
+        "<",
+        ">",
+        "[",
+        "]",
+        "(",
+        ")",
+        "{",
+        "}",
+    ]
+    if (
+        all([a not in room_name for a in disvalid])
+        and room_name[0] not in "0123456789"
+        and len(room_name) <= 30
+    ):
         while True:
             room_id = f"{random.randint(1, 9999):04}"
             room_iden = f"{room_name}{room_id}"
-            _room_iden = cur.execute("SELECT 1 FROM rooms WHERE room_iden = ?", (room_iden,)).fetchone()
+            _room_iden = cur.execute(
+                "SELECT 1 FROM rooms WHERE room_iden = ?", (room_iden,)
+            ).fetchone()
             if not _room_iden:
                 break
         member_table_name = f"{room_iden}_mem"
         saint_table_name = f"{room_iden}_saint"
-        cur.execute("INSERT INTO rooms (room_iden,admin) VALUES (?, ?)", (room_iden, user_id))
-        cur.execute(f"CREATE TABLE {member_table_name} (user_id INTEGER PRIMARY KEY, wishes TEXT, photo_id TEXT)")
-        cur.execute(f"CREATE TABLE {saint_table_name} (saint_user_id INTEGER PRIMARY KEY,reciver_user_id INTEGER)")
+        cur.execute(
+            "INSERT INTO rooms (room_iden,admin) VALUES (?, ?)", (room_iden, user_id)
+        )
+        cur.execute(
+            f"CREATE TABLE {member_table_name} (user_id INTEGER PRIMARY KEY, wishes TEXT, photo_id TEXT)"
+        )
+        cur.execute(
+            f"CREATE TABLE {saint_table_name} (saint_user_id INTEGER PRIMARY KEY,reciver_user_id INTEGER)"
+        )
 
-        cur.execute("INSERT OR IGNORE INTO user_rooms (tg_id, room_iden) VALUES (?, ?)", (user_id, room_iden))
-        cur.execute("UPDATE user_rooms SET is_admin = TRUE WHERE tg_id = ? AND room_iden = ?", (user_id, room_iden))
+        cur.execute(
+            "INSERT OR IGNORE INTO user_rooms (tg_id, room_iden) VALUES (?, ?)",
+            (user_id, room_iden),
+        )
+        cur.execute(
+            "UPDATE user_rooms SET is_admin = TRUE WHERE tg_id = ? AND room_iden = ?",
+            (user_id, room_iden),
+        )
 
         db.commit()
         return room_id
@@ -74,15 +138,21 @@ async def connect2room(raw_data, user_id):
     room_name, room_id, *_ = raw_data.split(":")
     room_iden = f"{room_name}{room_id}"
     table_name = f"{room_iden}_mem"
-    _room = cur.execute("SELECT * FROM rooms WHERE room_iden = ?", (room_iden,)).fetchone()
+    _room = cur.execute(
+        "SELECT * FROM rooms WHERE room_iden = ?", (room_iden,)
+    ).fetchone()
     if not _room:
         return "room_error"
     if _room[1] == True:
         return "joined late"
-    _user = cur.execute(f"SELECT * FROM {table_name} WHERE user_id = ?", (user_id,)).fetchone()
+    _user = cur.execute(
+        f"SELECT * FROM {table_name} WHERE user_id = ?", (user_id,)
+    ).fetchone()
     if _user:
         return "user_error"
-    cur.execute(f"INSERT INTO {table_name} (user_id,wishes) VALUES (?, '-')", (user_id,))
+    cur.execute(
+        f"INSERT INTO {table_name} (user_id,wishes) VALUES (?, '-')", (user_id,)
+    )
 
     _room = cur.execute(
         "SELECT * FROM user_rooms WHERE tg_id = ? AND room_iden = ?",
@@ -104,17 +174,23 @@ async def connect2room(raw_data, user_id):
 
 
 async def get_members_list(room_iden):
-    admin_raw = cur.execute("SELECT * FROM rooms WHERE room_iden = ?", (room_iden,)).fetchone()
-    *_, admin_id = admin_raw
+    admin_raw = cur.execute(
+        "SELECT * FROM rooms WHERE room_iden = ?", (room_iden,)
+    ).fetchone()
+    admin_id = admin_raw[2]
     isAdminMember = False
 
     member_id_list = cur.execute(f"SELECT * FROM {room_iden}_mem ").fetchall()
-    admin = member = cur.execute("SELECT * FROM users WHERE tg_id = ?", (admin_id,)).fetchone()
+    admin = member = cur.execute(
+        "SELECT * FROM users WHERE tg_id = ?", (admin_id,)
+    ).fetchone()
 
     member_list = []
     for member_id in member_id_list:
         if member_id[0] != admin_id:
-            member = cur.execute("SELECT * FROM users WHERE tg_id = ?", (member_id[0],)).fetchone()
+            member = cur.execute(
+                "SELECT * FROM users WHERE tg_id = ?", (member_id[0],)
+            ).fetchone()
             member_list.append(member)
         else:
             isAdminMember = True
@@ -154,9 +230,15 @@ async def delete_room(room_iden, admin_id):
     saint_table_name = f"{room_iden}_saint"
 
     users_id = cur.execute(f"SELECT user_id FROM {member_table_name}").fetchall()
-    cur.execute("DELETE FROM user_rooms WHERE tg_id = ? AND room_iden = ?", (admin_id, room_iden))
+    cur.execute(
+        "DELETE FROM user_rooms WHERE tg_id = ? AND room_iden = ?",
+        (admin_id, room_iden),
+    )
     for user_id in users_id:
-        cur.execute("DELETE FROM user_rooms WHERE tg_id = ? AND room_iden = ?", (user_id[0], room_iden))
+        cur.execute(
+            "DELETE FROM user_rooms WHERE tg_id = ? AND room_iden = ?",
+            (user_id[0], room_iden),
+        )
 
     cur.execute(f"DROP TABLE IF EXISTS {member_table_name}")
     cur.execute(f"DROP TABLE IF EXISTS {saint_table_name}")
@@ -181,34 +263,51 @@ async def start_event(room_iden):
 
 async def who_gives(room_iden, user_id):
     table_name = f"{room_iden}_saint"
-    pair = cur.execute(f"SELECT * FROM {table_name} WHERE saint_user_id = ?", (user_id,)).fetchone()
+    pair = cur.execute(
+        f"SELECT * FROM {table_name} WHERE saint_user_id = ?", (user_id,)
+    ).fetchone()
     if not pair:
-        return 'JOINED LATE'
+        return "JOINED LATE"
     return pair[1]
 
 
 async def isStarted(room_iden):
-    _, status, _ = cur.execute("SELECT * FROM rooms WHERE room_iden = ?", (room_iden,)).fetchone()
-    return status
+    room_raw = cur.execute(
+        "SELECT * FROM rooms WHERE room_iden = ?", (room_iden,)
+    ).fetchone()
+    return room_raw[1]
 
 
 async def get_user(user_id):
     return cur.execute("SELECT * FROM users WHERE tg_id = ?", (user_id,)).fetchone()
 
 
 async def check_room_and_member(user_id, room_iden):
-    _room = cur.execute("SELECT * FROM rooms WHERE room_iden = ?", (room_iden,)).fetchone()
+    _room = cur.execute(
+        "SELECT * FROM rooms WHERE room_iden = ?", (room_iden,)
+    ).fetchone()
     if not _room:
         return "ROOM NOT EXISTS"
     table_name = f"{room_iden}_mem"
-    _user = cur.execute(f"SELECT * FROM {table_name} WHERE user_id = ?", (user_id,)).fetchone()
+    _user = cur.execute(
+        f"SELECT * FROM {table_name} WHERE user_id = ?", (user_id,)
+    ).fetchone()
     if not _user and _room[2] == user_id:
         return "IS ADMIN"
     if not _user:
         return "MEMBER NOT EXISTS"
     return True
 
 
+async def get_room_admin(room_iden):
+    admin_raw = cur.execute(
+        "SELECT admin FROM rooms WHERE room_iden = ?", (room_iden,)
+    ).fetchone()
+    if not admin_raw:
+        return None
+    return admin_raw[0]
+
+
 async def count_user_room(user_id):
     count = cur.execute(
         "SELECT COUNT(*) FROM user_rooms WHERE tg_id = ?",
@@ -218,11 +317,15 @@ async def count_user_room(user_id):
 
 
 async def get_wishes_and_photo(room_iden, user_id):
-    _room = cur.execute("SELECT * FROM rooms WHERE room_iden = ?", (room_iden,)).fetchone()
+    _room = cur.execute(
+        "SELECT * FROM rooms WHERE room_iden = ?", (room_iden,)
+    ).fetchone()
     if not _room:
         return "ROOM NOT EXISTS", None, None
     table_name = f"{room_iden}_mem"
-    _user = cur.execute(f"SELECT * FROM {table_name} WHERE user_id = ?", (user_id,)).fetchone()
+    _user = cur.execute(
+        f"SELECT * FROM {table_name} WHERE user_id = ?", (user_id,)
+    ).fetchone()
     if not _user:
         return "MEMBER NOT EXISTS", None, None
     _, wishes, photo_id = _user
@@ -238,11 +341,81 @@ async def edit_wishes(wishes, user_id, room_iden, photo_id=""):
         return "ROOM NOT EXISTS"
 
     table_name = f"{room_iden}_mem"
-    _user = cur.execute(f"SELECT * FROM {table_name} WHERE user_id = ?", (user_id,)).fetchone()
+    _user = cur.execute(
+        f"SELECT * FROM {table_name} WHERE user_id = ?", (user_id,)
+    ).fetchone()
     if not _user:
         return "MEMBER NOT EXISTS"
 
-    cur.execute(f"UPDATE {table_name} SET wishes = ?, photo_id = ? WHERE user_id = ?", (wishes, photo_id, user_id))
+    cur.execute(
+        f"UPDATE {table_name} SET wishes = ?, photo_id = ? WHERE user_id = ?",
+        (wishes, photo_id, user_id),
+    )
+
+    db.commit()
+    return True
+
+
+async def migrate_rooms_table():
+    columns = [
+        column[1] for column in cur.execute("PRAGMA table_info(rooms)").fetchall()
+    ]
+    migrations = [
+        (
+            "gift_price_range",
+            f"ALTER TABLE rooms ADD COLUMN gift_price_range TEXT DEFAULT '{ROOM_DEFAULT_PRICE}'",
+        ),
+        (
+            "event_time",
+            f"ALTER TABLE rooms ADD COLUMN event_time TEXT DEFAULT '{ROOM_DEFAULT_EVENT_TIME}'",
+        ),
+        (
+            "exchange_type",
+            f"ALTER TABLE rooms ADD COLUMN exchange_type TEXT DEFAULT '{ROOM_DEFAULT_EXCHANGE_TYPE}'",
+        ),
+    ]
+
+    for column, query in migrations:
+        if column not in columns:
+            cur.execute(query)
+
+    db.commit()
+
+
+async def get_room_settings(room_iden):
+    _room = cur.execute(
+        "SELECT gift_price_range, event_time, exchange_type FROM rooms WHERE room_iden = ?",
+        (room_iden,),
+    ).fetchone()
+    if not _room:
+        return "ROOM NOT EXISTS", None, None, None
+    price, event_time, exchange_type = _room
+    return True, price, event_time, exchange_type
+
+
+async def update_room_settings(room_iden, price=None, event_time=None, exchange_type=None):
+    _room = cur.execute(
+        "SELECT 1 FROM rooms WHERE room_iden = ?",
+        (room_iden,),
+    ).fetchone()
+    if not _room:
+        return "ROOM NOT EXISTS"
+
+    if price is not None:
+        cur.execute(
+            "UPDATE rooms SET gift_price_range = ? WHERE room_iden = ?",
+            (price, room_iden),
+        )
+    if event_time is not None:
+        cur.execute(
+            "UPDATE rooms SET event_time = ? WHERE room_iden = ?",
+            (event_time, room_iden),
+        )
+    if exchange_type is not None:
+        cur.execute(
+            "UPDATE rooms SET exchange_type = ? WHERE room_iden = ?",
+            (exchange_type, room_iden),
+        )
 
     db.commit()
     return True