Delete Database directory

Database/mongodb/db.py

@@ -1,6 +0,0 @@
-from motor.motor_asyncio import AsyncIOMotorClient as MongoClient
-
-from Mikobot import DB_NAME, MONGO_DB_URI
-
-mongo = MongoClient(MONGO_DB_URI)
-dbname = mongo[DB_NAME]

Database/mongodb/fsub_db.py

@@ -1,18 +0,0 @@
-from Infamous.temp import dbname
-
-fsub = dbname.force_sub
-
-
-def fs_settings(chat_id: int):
-    _x = fsub.find_one({"chat_id": chat_id})
-    if _x:
-        return _x
-    return None
-
-
-def add_channel(chat_id: int, channel):
-    fsub.update_one({"chat_id": chat_id}, {"$set": {"channel": channel}}, upsert=True)
-
-
-def disapprove(chat_id: int):
-    fsub.delete_one({"chat_id": chat_id})

Database/mongodb/karma_mongo.py

@@ -1,122 +0,0 @@
-from typing import Dict, Union
-
-from pymongo import MongoClient
-
-from Mikobot import DB_NAME, MONGO_DB_URI
-
-client = MongoClient(MONGO_DB_URI)
-db = client[DB_NAME]
-
-coupledb = db.couple
-karmadb = db.karma
-
-
-async def _get_lovers(chat_id: int):
-    lovers = coupledb.find_one({"chat_id": chat_id})
-    if lovers:
-        lovers = lovers["couple"]
-    else:
-        lovers = {}
-    return lovers
-
-
-async def get_couple(chat_id: int, date: str):
-    lovers = await _get_lovers(chat_id)
-    if date in lovers:
-        return lovers[date]
-    else:
-        return False
-
-
-async def save_couple(chat_id: int, date: str, couple: dict):
-    lovers = await _get_lovers(chat_id)
-    lovers[date] = couple
-    coupledb.update_one({"chat_id": chat_id}, {"$set": {"couple": lovers}}, upsert=True)
-
-
-async def get_karmas_count() -> dict:
-    chats = karmadb.find({"chat_id": {"$lt": 0}})
-    if not chats:
-        return {}
-    chats_count = 0
-    karmas_count = 0
-    for chat in await chats.to_list(length=1000000):
-        for i in chat["karma"]:
-            karma_ = chat["karma"][i]["karma"]
-            if karma_ > 0:
-                karmas_count += karma_
-        chats_count += 1
-    return {"chats_count": chats_count, "karmas_count": karmas_count}
-
-
-async def user_global_karma(user_id) -> int:
-    chats = karmadb.find({"chat_id": {"$lt": 0}})
-    if not chats:
-        return 0
-    total_karma = 0
-    for chat in await chats.to_list(length=1000000):
-        karma = await get_karma(chat["chat_id"], await int_to_alpha(user_id))
-        if karma and (int(karma["karma"]) > 0):
-            total_karma += int(karma["karma"])
-    return total_karma
-
-
-async def get_karmas(chat_id: int) -> Dict[str, int]:
-    karma = karmadb.find_one({"chat_id": chat_id})
-    if not karma:
-        return {}
-    return karma["karma"]
-
-
-async def get_karma(chat_id: int, name: str) -> Union[bool, dict]:
-    name = name.lower().strip()
-    karmas = await get_karmas(chat_id)
-    if name in karmas:
-        return karmas[name]
-
-
-async def update_karma(chat_id: int, name: str, karma: dict):
-    name = name.lower().strip()
-    karmas = await get_karmas(chat_id)
-    karmas[name] = karma
-    karmadb.update_one({"chat_id": chat_id}, {"$set": {"karma": karmas}}, upsert=True)
-
-
-async def is_karma_on(chat_id: int) -> bool:
-    chat = karmadb.find_one({"chat_id_toggle": chat_id})
-    if not chat:
-        return True
-    return False
-
-
-async def karma_on(chat_id: int):
-    is_karma = await is_karma_on(chat_id)
-    if is_karma:
-        return
-    return karmadb.delete_one({"chat_id_toggle": chat_id})
-
-
-async def karma_off(chat_id: int):
-    is_karma = await is_karma_on(chat_id)
-    if not is_karma:
-        return
-    return karmadb.insert_one({"chat_id_toggle": chat_id})
-
-
-async def int_to_alpha(user_id: int) -> str:
-    alphabet = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
-    text = ""
-    user_id = str(user_id)
-    for i in user_id:
-        text += alphabet[int(i)]
-    return text
-
-
-async def alpha_to_int(user_id_alphabet: str) -> int:
-    alphabet = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
-    user_id = ""
-    for i in user_id_alphabet:
-        index = alphabet.index(i)
-        user_id += str(index)
-    user_id = int(user_id)
-    return user_id

Database/mongodb/mongodb.py

@@ -1,75 +0,0 @@
-from sys import exit as exiter
-
-from pymongo import MongoClient
-from pymongo.errors import PyMongoError
-
-from Mikobot import DB_NAME, LOGGER, MONGO_DB_URI
-
-try:
-    Mikobot_db_client = MongoClient(MONGO_DB_URI)
-except PyMongoError as f:
-    LOGGER.error(f"Error in Mongodb: {f}")
-    exiter(1)
-Mikobot_main_db = Mikobot_db_client[DB_NAME]
-
-
-class MongoDB:
-    """Class for interacting with Bot database."""
-
-    def __init__(self, collection) -> None:
-        self.collection = Mikobot_main_db[collection]
-
-    # Insert one entry into collection
-    def insert_one(self, document):
-        result = self.collection.insert_one(document)
-        return repr(result.inserted_id)
-
-    # Find one entry from collection
-    def find_one(self, query):
-        result = self.collection.find_one(query)
-        if result:
-            return result
-        return False
-
-    # Find entries from collection
-    def find_all(self, query=None):
-        if query is None:
-            query = {}
-        return list(self.collection.find(query))
-
-    # Count entries from collection
-    def count(self, query=None):
-        if query is None:
-            query = {}
-        return self.collection.count_documents(query)
-
-    # Delete entry/entries from collection
-    def delete_one(self, query):
-        self.collection.delete_many(query)
-        return self.collection.count_documents({})
-
-    # Replace one entry in collection
-    def replace(self, query, new_data):
-        old = self.collection.find_one(query)
-        _id = old["_id"]
-        self.collection.replace_one({"_id": _id}, new_data)
-        new = self.collection.find_one({"_id": _id})
-        return old, new
-
-    # Update one entry from collection
-    def update(self, query, update):
-        result = self.collection.update_one(query, {"$set": update})
-        new_document = self.collection.find_one(query)
-        return result.modified_count, new_document
-
-    @staticmethod
-    def close():
-        return Mikobot_db_client.close()
-
-
-def __connect_first():
-    _ = MongoDB("test")
-    LOGGER.info("Initialized Mongo Database!\n")
-
-
-__connect_first()

Database/mongodb/toggle_mongo.py

@@ -1,50 +0,0 @@
-from Database.mongodb.db import *
-
-dwelcomedb = dbname.dwelcome
-nsfwdb = dbname.nsfw
-nekomodedb = dbname.nekomode
-
-
-async def is_dwelcome_on(chat_id: int) -> bool:
-    chat = await dwelcomedb.find_one({"chat_id_toggle": chat_id})
-    return not bool(chat)
-
-
-async def dwelcome_on(chat_id: int):
-    await dwelcomedb.delete_one({"chat_id_toggle": chat_id})
-
-
-async def dwelcome_off(chat_id: int):
-    await dwelcomedb.insert_one({"chat_id_toggle": chat_id})
-
-
-async def is_nsfw_on(chat_id: int) -> bool:
-    chat = await nsfwdb.find_one({"chat_id": chat_id})
-    return chat
-
-
-async def nsfw_on(chat_id: int):
-    is_nsfw = await is_nsfw_on(chat_id)
-    if is_nsfw:
-        return
-    return await nsfwdb.insert_one({"chat_id": chat_id})
-
-
-async def nsfw_off(chat_id: int):
-    is_nsfw = await is_nsfw_on(chat_id)
-    if not is_nsfw:
-        return
-    return await nsfwdb.delete_one({"chat_id": chat_id})
-
-
-async def is_nekomode_on(chat_id: int) -> bool:
-    chat = await nekomodedb.find_one({"chat_id_toggle": chat_id})
-    return not bool(chat)
-
-
-async def nekomode_on(chat_id: int):
-    await nekomodedb.delete_one({"chat_id_toggle": chat_id})
-
-
-async def nekomode_off(chat_id: int):
-    await nekomodedb.insert_one({"chat_id_toggle": chat_id})

Database/mongodb/users_db.py

@@ -1,102 +0,0 @@
-from threading import RLock
-from time import time
-
-from Database.mongodb.mongodb import MongoDB
-from Mikobot import LOGGER
-
-INSERTION_LOCK = RLock()
-
-
-class Users(MongoDB):
-    """Class to manage users for bot."""
-
-    db_name = "users"
-
-    def __init__(self, user_id: int) -> None:
-        super().__init__(self.db_name)
-        self.user_id = user_id
-        self.user_info = self.__ensure_in_db()
-
-    def update_user(self, name: str, username: str = None):
-        with INSERTION_LOCK:
-            if name != self.user_info["name"] or username != self.user_info["username"]:
-                return self.update(
-                    {"_id": self.user_id},
-                    {"username": username, "name": name},
-                )
-            return True
-
-    def delete_user(self):
-        with INSERTION_LOCK:
-            return self.delete_one({"_id": self.user_id})
-
-    @staticmethod
-    def count_users():
-        with INSERTION_LOCK:
-            collection = MongoDB(Users.db_name)
-            return collection.count()
-
-    def get_my_info(self):
-        with INSERTION_LOCK:
-            return self.user_info
-
-    @staticmethod
-    def list_users():
-        with INSERTION_LOCK:
-            collection = MongoDB(Users.db_name)
-            return collection.find_all()
-
-    @staticmethod
-    def get_user_info(user_id: int or str):
-        with INSERTION_LOCK:
-            collection = MongoDB(Users.db_name)
-            if isinstance(user_id, int):
-                curr = collection.find_one({"_id": user_id})
-            elif isinstance(user_id, str):
-                # user_id[1:] because we don't want the '@' in the username
-                # search!
-                curr = collection.find_one({"username": user_id[1:]})
-            else:
-                curr = None
-
-            if curr:
-                return curr
-
-            return {}
-
-    def __ensure_in_db(self):
-        chat_data = self.find_one({"_id": self.user_id})
-        if not chat_data:
-            new_data = {"_id": self.user_id, "username": "", "name": "unknown_till_now"}
-            self.insert_one(new_data)
-            LOGGER.info(f"Initialized User Document for {self.user_id}")
-            return new_data
-        return chat_data
-
-    @staticmethod
-    def load_from_db():
-        with INSERTION_LOCK:
-            collection = MongoDB(Users.db_name)
-            return collection.find_all()
-
-    @staticmethod
-    def repair_db(collection):
-        all_data = collection.find_all()
-        keys = {"username": "", "name": "unknown_till_now"}
-        for data in all_data:
-            for key, val in keys.items():
-                try:
-                    _ = data[key]
-                except KeyError:
-                    LOGGER.warning(
-                        f"Repairing Users Database - setting '{key}:{val}' for {data['_id']}",
-                    )
-                    collection.update({"_id": data["_id"]}, {key: val})
-
-
-def __pre_req_users():
-    start = time()
-    LOGGER.info("Starting Users Database Repair...")
-    collection = MongoDB(Users.db_name)
-    Users.repair_db(collection)
-    LOGGER.info(f"Done in {round((time() - start), 3)}s!")

Database/mongodb/whispers.py

@@ -1,19 +0,0 @@
-from Database.mongodb.db import dbname
-
-collection = dbname["whisper"]
-
-
-class Whispers:
-    @staticmethod
-    async def add_whisper(WhisperId, WhisperData):
-        whisper = {"WhisperId": WhisperId, "whisperData": WhisperData}
-        await collection.insert_one(whisper)
-
-    @staticmethod
-    async def del_whisper(WhisperId):
-        await collection.delete_one({"WhisperId": WhisperId})
-
-    @staticmethod
-    async def get_whisper(WhisperId):
-        whisper = await collection.find_one({"WhisperId": WhisperId})
-        return whisper["whisperData"] if whisper else None

Database/sql/__init__.py

@@ -1,27 +0,0 @@
-from sqlalchemy import create_engine
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import scoped_session, sessionmaker
-
-from Mikobot import DB_URI
-from Mikobot import LOGGER as log
-
-if DB_URI and DB_URI.startswith("postgres://"):
-    DB_URI = DB_URI.replace("postgres://", "postgresql://", 1)
-
-
-def start() -> scoped_session:
-    engine = create_engine(DB_URI, client_encoding="utf8")
-    log.info("[PostgreSQL] Connecting to database......")
-    BASE.metadata.bind = engine
-    BASE.metadata.create_all(engine)
-    return scoped_session(sessionmaker(bind=engine, autoflush=False))
-
-
-BASE = declarative_base()
-try:
-    SESSION = start()
-except Exception as e:
-    log.exception(f"[PostgreSQL] Failed to connect due to {e}")
-    exit()
-
-log.info("[PostgreSQL] Connection successful, session started.")

Database/sql/afk_sql.py

@@ -1,99 +0,0 @@
-import threading
-from datetime import datetime
-
-from sqlalchemy import BigInteger, Boolean, Column, DateTime, UnicodeText
-
-from Database.sql import BASE, SESSION
-
-
-class AFK(BASE):
-    __tablename__ = "afk_users"
-
-    user_id = Column(BigInteger, primary_key=True)
-    is_afk = Column(Boolean)
-    reason = Column(UnicodeText)
-    time = Column(DateTime)
-
-    def __init__(self, user_id: int, reason: str = "", is_afk: bool = True):
-        self.user_id = user_id
-        self.reason = reason
-        self.is_afk = is_afk
-        self.time = datetime.now()
-
-    def __repr__(self):
-        return "afk_status for {}".format(self.user_id)
-
-
-AFK.__table__.create(checkfirst=True)
-INSERTION_LOCK = threading.RLock()
-
-AFK_USERS = {}
-
-
-def is_afk(user_id):
-    return user_id in AFK_USERS
-
-
-def check_afk_status(user_id):
-    try:
-        return SESSION.query(AFK).get(user_id)
-    finally:
-        SESSION.close()
-
-
-def set_afk(user_id, reason=""):
-    with INSERTION_LOCK:
-        curr = SESSION.query(AFK).get(user_id)
-        if not curr:
-            curr = AFK(user_id, reason, True)
-        else:
-            curr.is_afk = True
-
-        AFK_USERS[user_id] = {"reason": reason, "time": curr.time}
-
-        SESSION.add(curr)
-        SESSION.commit()
-
-
-def rm_afk(user_id):
-    with INSERTION_LOCK:
-        curr = SESSION.query(AFK).get(user_id)
-        if curr:
-            if user_id in AFK_USERS:  # sanity check
-                del AFK_USERS[user_id]
-
-            SESSION.delete(curr)
-            SESSION.commit()
-            return True
-
-        SESSION.close()
-        return False
-
-
-def toggle_afk(user_id, reason=""):
-    with INSERTION_LOCK:
-        curr = SESSION.query(AFK).get(user_id)
-        if not curr:
-            curr = AFK(user_id, reason, True)
-        elif curr.is_afk:
-            curr.is_afk = False
-        elif not curr.is_afk:
-            curr.is_afk = True
-        SESSION.add(curr)
-        SESSION.commit()
-
-
-def __load_afk_users():
-    global AFK_USERS
-    try:
-        all_afk = SESSION.query(AFK).all()
-        AFK_USERS = {
-            user.user_id: {"reason": user.reason, "time": user.time}
-            for user in all_afk
-            if user.is_afk
-        }
-    finally:
-        SESSION.close()
-
-
-__load_afk_users()

Database/sql/antiflood_sql.py

@@ -1,145 +0,0 @@
-import threading
-
-from sqlalchemy import BigInteger, Column, Integer, String, UnicodeText
-
-from Database.sql import BASE, SESSION
-
-DEF_COUNT = 1
-DEF_LIMIT = 0
-DEF_OBJ = (None, DEF_COUNT, DEF_LIMIT)
-
-
-class FloodControl(BASE):
-    __tablename__ = "antiflood"
-    chat_id = Column(String(14), primary_key=True)
-    user_id = Column(BigInteger)
-    count = Column(Integer, default=DEF_COUNT)
-    limit = Column(Integer, default=DEF_LIMIT)
-
-    def __init__(self, chat_id):
-        self.chat_id = str(chat_id)  # ensure string
-
-    def __repr__(self):
-        return "<flood control for %s>" % self.chat_id
-
-
-class FloodSettings(BASE):
-    __tablename__ = "antiflood_settings"
-    chat_id = Column(String(14), primary_key=True)
-    flood_type = Column(Integer, default=1)
-    value = Column(UnicodeText, default="0")
-
-    def __init__(self, chat_id, flood_type=1, value="0"):
-        self.chat_id = str(chat_id)
-        self.flood_type = flood_type
-        self.value = value
-
-    def __repr__(self):
-        return "<{} will executing {} for flood.>".format(self.chat_id, self.flood_type)
-
-
-FloodControl.__table__.create(checkfirst=True)
-FloodSettings.__table__.create(checkfirst=True)
-
-INSERTION_FLOOD_LOCK = threading.RLock()
-INSERTION_FLOOD_SETTINGS_LOCK = threading.RLock()
-
-CHAT_FLOOD = {}
-
-
-def set_flood(chat_id, amount):
-    with INSERTION_FLOOD_LOCK:
-        flood = SESSION.query(FloodControl).get(str(chat_id))
-        if not flood:
-            flood = FloodControl(str(chat_id))
-
-        flood.user_id = None
-        flood.limit = amount
-
-        CHAT_FLOOD[str(chat_id)] = (None, DEF_COUNT, amount)
-
-        SESSION.add(flood)
-        SESSION.commit()
-
-
-def update_flood(chat_id: str, user_id) -> bool:
-    if str(chat_id) in CHAT_FLOOD:
-        curr_user_id, count, limit = CHAT_FLOOD.get(str(chat_id), DEF_OBJ)
-
-        if limit == 0:  # no antiflood
-            return False
-
-        if user_id != curr_user_id or user_id is None:  # other user
-            CHAT_FLOOD[str(chat_id)] = (user_id, DEF_COUNT, limit)
-            return False
-
-        count += 1
-        if count > limit:  # too many msgs, kick
-            CHAT_FLOOD[str(chat_id)] = (None, DEF_COUNT, limit)
-            return True
-
-        # default -> update
-        CHAT_FLOOD[str(chat_id)] = (user_id, count, limit)
-        return False
-
-
-def get_flood_limit(chat_id):
-    return CHAT_FLOOD.get(str(chat_id), DEF_OBJ)[2]
-
-
-def set_flood_strength(chat_id, flood_type, value):
-    # for flood_type
-    # 1 = ban
-    # 2 = kick
-    # 3 = mute
-    # 4 = tban
-    # 5 = tmute
-    with INSERTION_FLOOD_SETTINGS_LOCK:
-        curr_setting = SESSION.query(FloodSettings).get(str(chat_id))
-        if not curr_setting:
-            curr_setting = FloodSettings(
-                chat_id,
-                flood_type=int(flood_type),
-                value=value,
-            )
-
-        curr_setting.flood_type = int(flood_type)
-        curr_setting.value = str(value)
-
-        SESSION.add(curr_setting)
-        SESSION.commit()
-
-
-def get_flood_setting(chat_id):
-    try:
-        setting = SESSION.query(FloodSettings).get(str(chat_id))
-        if setting:
-            return setting.flood_type, setting.value
-        else:
-            return 1, "0"
-
-    finally:
-        SESSION.close()
-
-
-def migrate_chat(old_chat_id, new_chat_id):
-    with INSERTION_FLOOD_LOCK:
-        flood = SESSION.query(FloodControl).get(str(old_chat_id))
-        if flood:
-            CHAT_FLOOD[str(new_chat_id)] = CHAT_FLOOD.get(str(old_chat_id), DEF_OBJ)
-            flood.chat_id = str(new_chat_id)
-            SESSION.commit()
-
-        SESSION.close()
-
-
-def __load_flood_settings():
-    global CHAT_FLOOD
-    try:
-        all_chats = SESSION.query(FloodControl).all()
-        CHAT_FLOOD = {chat.chat_id: (None, DEF_COUNT, chat.limit) for chat in all_chats}
-    finally:
-        SESSION.close()
-
-
-__load_flood_settings()

Database/sql/approve_sql.py

@@ -1,61 +0,0 @@
-import threading
-
-from sqlalchemy import BigInteger, Column, String
-
-from Database.sql import BASE, SESSION
-
-
-class Approvals(BASE):
-    __tablename__ = "approval"
-    chat_id = Column(String(14), primary_key=True)
-    user_id = Column(BigInteger, primary_key=True)
-
-    def __init__(self, chat_id, user_id):
-        self.chat_id = str(chat_id)  # ensure string
-        self.user_id = user_id
-
-    def __repr__(self):
-        return "<Approve %s>" % self.user_id
-
-
-Approvals.__table__.create(checkfirst=True)
-
-APPROVE_INSERTION_LOCK = threading.RLock()
-
-
-def approve(chat_id, user_id):
-    with APPROVE_INSERTION_LOCK:
-        approve_user = Approvals(str(chat_id), user_id)
-        SESSION.add(approve_user)
-        SESSION.commit()
-
-
-def is_approved(chat_id, user_id):
-    try:
-        return SESSION.query(Approvals).get((str(chat_id), user_id))
-    finally:
-        SESSION.close()
-
-
-def disapprove(chat_id, user_id):
-    with APPROVE_INSERTION_LOCK:
-        disapprove_user = SESSION.query(Approvals).get((str(chat_id), user_id))
-        if disapprove_user:
-            SESSION.delete(disapprove_user)
-            SESSION.commit()
-            return True
-        else:
-            SESSION.close()
-            return False
-
-
-def list_approved(chat_id):
-    try:
-        return (
-            SESSION.query(Approvals)
-            .filter(Approvals.chat_id == str(chat_id))
-            .order_by(Approvals.user_id.asc())
-            .all()
-        )
-    finally:
-        SESSION.close()

Database/sql/blacklist_sql.py

@@ -1,200 +0,0 @@
-import threading
-
-from sqlalchemy import Column, Integer, String, UnicodeText, distinct, func
-
-from Database.sql import BASE, SESSION
-
-
-class BlackListFilters(BASE):
-    __tablename__ = "blacklist"
-    chat_id = Column(String(14), primary_key=True)
-    trigger = Column(UnicodeText, primary_key=True, nullable=False)
-
-    def __init__(self, chat_id, trigger):
-        self.chat_id = str(chat_id)  # ensure string
-        self.trigger = trigger
-
-    def __repr__(self):
-        return "<Blacklist filter '%s' for %s>" % (self.trigger, self.chat_id)
-
-    def __eq__(self, other):
-        return bool(
-            isinstance(other, BlackListFilters)
-            and self.chat_id == other.chat_id
-            and self.trigger == other.trigger,
-        )
-
-
-class BlacklistSettings(BASE):
-    __tablename__ = "blacklist_settings"
-    chat_id = Column(String(14), primary_key=True)
-    blacklist_type = Column(Integer, default=1)
-    value = Column(UnicodeText, default="0")
-
-    def __init__(self, chat_id, blacklist_type=1, value="0"):
-        self.chat_id = str(chat_id)
-        self.blacklist_type = blacklist_type
-        self.value = value
-
-    def __repr__(self):
-        return "<{} will executing {} for blacklist trigger.>".format(
-            self.chat_id,
-            self.blacklist_type,
-        )
-
-
-BlackListFilters.__table__.create(checkfirst=True)
-BlacklistSettings.__table__.create(checkfirst=True)
-
-BLACKLIST_FILTER_INSERTION_LOCK = threading.RLock()
-BLACKLIST_SETTINGS_INSERTION_LOCK = threading.RLock()
-
-CHAT_BLACKLISTS = {}
-CHAT_SETTINGS_BLACKLISTS = {}
-
-
-def add_to_blacklist(chat_id, trigger):
-    with BLACKLIST_FILTER_INSERTION_LOCK:
-        blacklist_filt = BlackListFilters(str(chat_id), trigger)
-
-        SESSION.merge(blacklist_filt)  # merge to avoid duplicate key issues
-        SESSION.commit()
-        global CHAT_BLACKLISTS
-        if CHAT_BLACKLISTS.get(str(chat_id), set()) == set():
-            CHAT_BLACKLISTS[str(chat_id)] = {trigger}
-        else:
-            CHAT_BLACKLISTS.get(str(chat_id), set()).add(trigger)
-
-
-def rm_from_blacklist(chat_id, trigger):
-    with BLACKLIST_FILTER_INSERTION_LOCK:
-        blacklist_filt = SESSION.query(BlackListFilters).get((str(chat_id), trigger))
-        if blacklist_filt:
-            if trigger in CHAT_BLACKLISTS.get(str(chat_id), set()):  # sanity check
-                CHAT_BLACKLISTS.get(str(chat_id), set()).remove(trigger)
-
-            SESSION.delete(blacklist_filt)
-            SESSION.commit()
-            return True
-
-        SESSION.close()
-        return False
-
-
-def get_chat_blacklist(chat_id):
-    return CHAT_BLACKLISTS.get(str(chat_id), set())
-
-
-def num_blacklist_filters():
-    try:
-        return SESSION.query(BlackListFilters).count()
-    finally:
-        SESSION.close()
-
-
-def num_blacklist_chat_filters(chat_id):
-    try:
-        return (
-            SESSION.query(BlackListFilters.chat_id)
-            .filter(BlackListFilters.chat_id == str(chat_id))
-            .count()
-        )
-    finally:
-        SESSION.close()
-
-
-def num_blacklist_filter_chats():
-    try:
-        return SESSION.query(func.count(distinct(BlackListFilters.chat_id))).scalar()
-    finally:
-        SESSION.close()
-
-
-def set_blacklist_strength(chat_id, blacklist_type, value):
-    # for blacklist_type
-    # 0 = nothing
-    # 1 = delete
-    # 2 = warn
-    # 3 = mute
-    # 4 = kick
-    # 5 = ban
-    # 6 = tban
-    # 7 = tmute
-    with BLACKLIST_SETTINGS_INSERTION_LOCK:
-        global CHAT_SETTINGS_BLACKLISTS
-        curr_setting = SESSION.query(BlacklistSettings).get(str(chat_id))
-        if not curr_setting:
-            curr_setting = BlacklistSettings(
-                chat_id,
-                blacklist_type=int(blacklist_type),
-                value=value,
-            )
-
-        curr_setting.blacklist_type = int(blacklist_type)
-        curr_setting.value = str(value)
-        CHAT_SETTINGS_BLACKLISTS[str(chat_id)] = {
-            "blacklist_type": int(blacklist_type),
-            "value": value,
-        }
-
-        SESSION.add(curr_setting)
-        SESSION.commit()
-
-
-def get_blacklist_setting(chat_id):
-    try:
-        setting = CHAT_SETTINGS_BLACKLISTS.get(str(chat_id))
-        if setting:
-            return setting["blacklist_type"], setting["value"]
-        else:
-            return 1, "0"
-
-    finally:
-        SESSION.close()
-
-
-def __load_chat_blacklists():
-    global CHAT_BLACKLISTS
-    try:
-        chats = SESSION.query(BlackListFilters.chat_id).distinct().all()
-        for (chat_id,) in chats:  # remove tuple by ( ,)
-            CHAT_BLACKLISTS[chat_id] = []
-
-        all_filters = SESSION.query(BlackListFilters).all()
-        for x in all_filters:
-            CHAT_BLACKLISTS[x.chat_id] += [x.trigger]
-
-        CHAT_BLACKLISTS = {x: set(y) for x, y in CHAT_BLACKLISTS.items()}
-
-    finally:
-        SESSION.close()
-
-
-def __load_chat_settings_blacklists():
-    global CHAT_SETTINGS_BLACKLISTS
-    try:
-        chats_settings = SESSION.query(BlacklistSettings).all()
-        for x in chats_settings:  # remove tuple by ( ,)
-            CHAT_SETTINGS_BLACKLISTS[x.chat_id] = {
-                "blacklist_type": x.blacklist_type,
-                "value": x.value,
-            }
-
-    finally:
-        SESSION.close()
-
-
-def migrate_chat(old_chat_id, new_chat_id):
-    with BLACKLIST_FILTER_INSERTION_LOCK:
-        chat_filters = (
-            SESSION.query(BlackListFilters)
-            .filter(BlackListFilters.chat_id == str(old_chat_id))
-            .all()
-        )
-        for filt in chat_filters:
-            filt.chat_id = str(new_chat_id)
-        SESSION.commit()
-
-
-__load_chat_blacklists()
-__load_chat_settings_blacklists()

Database/sql/blacklistusers_sql.py

@@ -1,69 +0,0 @@
-import threading
-
-from sqlalchemy import Column, String, UnicodeText
-
-from Database.sql import BASE, SESSION
-
-
-class BlacklistUsers(BASE):
-    __tablename__ = "blacklistusers"
-    user_id = Column(String(14), primary_key=True)
-    reason = Column(UnicodeText)
-
-    def __init__(self, user_id, reason=None):
-        self.user_id = user_id
-        self.reason = reason
-
-
-BlacklistUsers.__table__.create(checkfirst=True)
-
-BLACKLIST_LOCK = threading.RLock()
-BLACKLIST_USERS = set()
-
-
-def blacklist_user(user_id, reason=None):
-    with BLACKLIST_LOCK:
-        user = SESSION.query(BlacklistUsers).get(str(user_id))
-        if not user:
-            user = BlacklistUsers(str(user_id), reason)
-        else:
-            user.reason = reason
-
-        SESSION.add(user)
-        SESSION.commit()
-        __load_blacklist_userid_list()
-
-
-def unblacklist_user(user_id):
-    with BLACKLIST_LOCK:
-        user = SESSION.query(BlacklistUsers).get(str(user_id))
-        if user:
-            SESSION.delete(user)
-
-        SESSION.commit()
-        __load_blacklist_userid_list()
-
-
-def get_reason(user_id):
-    user = SESSION.query(BlacklistUsers).get(str(user_id))
-    rep = ""
-    if user:
-        rep = user.reason
-
-    SESSION.close()
-    return rep
-
-
-def is_user_blacklisted(user_id):
-    return user_id in BLACKLIST_USERS
-
-
-def __load_blacklist_userid_list():
-    global BLACKLIST_USERS
-    try:
-        BLACKLIST_USERS = {int(x.user_id) for x in SESSION.query(BlacklistUsers).all()}
-    finally:
-        SESSION.close()
-
-
-__load_blacklist_userid_list()

Database/sql/blsticker_sql.py

@@ -1,200 +0,0 @@
-import threading
-
-from sqlalchemy import Column, Integer, String, UnicodeText, distinct, func
-
-from Database.sql import BASE, SESSION
-
-
-class StickersFilters(BASE):
-    __tablename__ = "blacklist_stickers"
-    chat_id = Column(String(14), primary_key=True)
-    trigger = Column(UnicodeText, primary_key=True, nullable=False)
-
-    def __init__(self, chat_id, trigger):
-        self.chat_id = str(chat_id)  # ensure string
-        self.trigger = trigger
-
-    def __repr__(self):
-        return "<Stickers filter '%s' for %s>" % (self.trigger, self.chat_id)
-
-    def __eq__(self, other):
-        return bool(
-            isinstance(other, StickersFilters)
-            and self.chat_id == other.chat_id
-            and self.trigger == other.trigger,
-        )
-
-
-class StickerSettings(BASE):
-    __tablename__ = "blsticker_settings"
-    chat_id = Column(String(14), primary_key=True)
-    blacklist_type = Column(Integer, default=1)
-    value = Column(UnicodeText, default="0")
-
-    def __init__(self, chat_id, blacklist_type=1, value="0"):
-        self.chat_id = str(chat_id)
-        self.blacklist_type = blacklist_type
-        self.value = value
-
-    def __repr__(self):
-        return "<{} will executing {} for blacklist trigger.>".format(
-            self.chat_id,
-            self.blacklist_type,
-        )
-
-
-StickersFilters.__table__.create(checkfirst=True)
-StickerSettings.__table__.create(checkfirst=True)
-
-STICKERS_FILTER_INSERTION_LOCK = threading.RLock()
-STICKSET_FILTER_INSERTION_LOCK = threading.RLock()
-
-CHAT_STICKERS = {}
-CHAT_BLSTICK_BLACKLISTS = {}
-
-
-def add_to_stickers(chat_id, trigger):
-    with STICKERS_FILTER_INSERTION_LOCK:
-        stickers_filt = StickersFilters(str(chat_id), trigger)
-
-        SESSION.merge(stickers_filt)  # merge to avoid duplicate key issues
-        SESSION.commit()
-        global CHAT_STICKERS
-        if CHAT_STICKERS.get(str(chat_id), set()) == set():
-            CHAT_STICKERS[str(chat_id)] = {trigger}
-        else:
-            CHAT_STICKERS.get(str(chat_id), set()).add(trigger)
-
-
-def rm_from_stickers(chat_id, trigger):
-    with STICKERS_FILTER_INSERTION_LOCK:
-        stickers_filt = SESSION.query(StickersFilters).get((str(chat_id), trigger))
-        if stickers_filt:
-            if trigger in CHAT_STICKERS.get(str(chat_id), set()):  # sanity check
-                CHAT_STICKERS.get(str(chat_id), set()).remove(trigger)
-
-            SESSION.delete(stickers_filt)
-            SESSION.commit()
-            return True
-
-        SESSION.close()
-        return False
-
-
-def get_chat_stickers(chat_id):
-    return CHAT_STICKERS.get(str(chat_id), set())
-
-
-def num_stickers_filters():
-    try:
-        return SESSION.query(StickersFilters).count()
-    finally:
-        SESSION.close()
-
-
-def num_stickers_chat_filters(chat_id):
-    try:
-        return (
-            SESSION.query(StickersFilters.chat_id)
-            .filter(StickersFilters.chat_id == str(chat_id))
-            .count()
-        )
-    finally:
-        SESSION.close()
-
-
-def num_stickers_filter_chats():
-    try:
-        return SESSION.query(func.count(distinct(StickersFilters.chat_id))).scalar()
-    finally:
-        SESSION.close()
-
-
-def set_blacklist_strength(chat_id, blacklist_type, value):
-    # for blacklist_type
-    # 0 = nothing
-    # 1 = delete
-    # 2 = warn
-    # 3 = mute
-    # 4 = kick
-    # 5 = ban
-    # 6 = tban
-    # 7 = tmute
-    with STICKSET_FILTER_INSERTION_LOCK:
-        global CHAT_BLSTICK_BLACKLISTS
-        curr_setting = SESSION.query(StickerSettings).get(str(chat_id))
-        if not curr_setting:
-            curr_setting = StickerSettings(
-                chat_id,
-                blacklist_type=int(blacklist_type),
-                value=value,
-            )
-
-        curr_setting.blacklist_type = int(blacklist_type)
-        curr_setting.value = str(value)
-        CHAT_BLSTICK_BLACKLISTS[str(chat_id)] = {
-            "blacklist_type": int(blacklist_type),
-            "value": value,
-        }
-
-        SESSION.add(curr_setting)
-        SESSION.commit()
-
-
-def get_blacklist_setting(chat_id):
-    try:
-        setting = CHAT_BLSTICK_BLACKLISTS.get(str(chat_id))
-        if setting:
-            return setting["blacklist_type"], setting["value"]
-        else:
-            return 1, "0"
-
-    finally:
-        SESSION.close()
-
-
-def __load_CHAT_STICKERS():
-    global CHAT_STICKERS
-    try:
-        chats = SESSION.query(StickersFilters.chat_id).distinct().all()
-        for (chat_id,) in chats:  # remove tuple by ( ,)
-            CHAT_STICKERS[chat_id] = []
-
-        all_filters = SESSION.query(StickersFilters).all()
-        for x in all_filters:
-            CHAT_STICKERS[x.chat_id] += [x.trigger]
-
-        CHAT_STICKERS = {x: set(y) for x, y in CHAT_STICKERS.items()}
-
-    finally:
-        SESSION.close()
-
-
-def __load_chat_stickerset_blacklists():
-    global CHAT_BLSTICK_BLACKLISTS
-    try:
-        chats_settings = SESSION.query(StickerSettings).all()
-        for x in chats_settings:  # remove tuple by ( ,)
-            CHAT_BLSTICK_BLACKLISTS[x.chat_id] = {
-                "blacklist_type": x.blacklist_type,
-                "value": x.value,
-            }
-
-    finally:
-        SESSION.close()
-
-
-def migrate_chat(old_chat_id, new_chat_id):
-    with STICKERS_FILTER_INSERTION_LOCK:
-        chat_filters = (
-            SESSION.query(StickersFilters)
-            .filter(StickersFilters.chat_id == str(old_chat_id))
-            .all()
-        )
-        for filt in chat_filters:
-            filt.chat_id = str(new_chat_id)
-        SESSION.commit()
-
-
-__load_CHAT_STICKERS()
-__load_chat_stickerset_blacklists()

Database/sql/connection_sql.py

@@ -1,204 +0,0 @@
-import threading
-import time
-from typing import Union
-
-from sqlalchemy import BigInteger, Boolean, Column, String, UnicodeText
-
-from Database.sql import BASE, SESSION
-
-
-class ChatAccessConnectionSettings(BASE):
-    __tablename__ = "access_connection"
-    chat_id = Column(String(14), primary_key=True)
-    allow_connect_to_chat = Column(Boolean, default=True)
-
-    def __init__(self, chat_id, allow_connect_to_chat):
-        self.chat_id = str(chat_id)
-        self.allow_connect_to_chat = str(allow_connect_to_chat)
-
-    def __repr__(self):
-        return "<Chat access settings ({}) is {}>".format(
-            self.chat_id, self.allow_connect_to_chat
-        )
-
-
-class Connection(BASE):
-    __tablename__ = "connection"
-    user_id = Column(BigInteger, primary_key=True)
-    chat_id = Column(String(14))
-
-    def __init__(self, user_id, chat_id):
-        self.user_id = user_id
-        self.chat_id = str(chat_id)  # Ensure String
-
-
-class ConnectionHistory(BASE):
-    __tablename__ = "connection_history"
-    user_id = Column(BigInteger, primary_key=True)
-    chat_id = Column(String(14), primary_key=True)
-    chat_name = Column(UnicodeText)
-    conn_time = Column(BigInteger)
-
-    def __init__(self, user_id, chat_id, chat_name, conn_time):
-        self.user_id = user_id
-        self.chat_id = str(chat_id)
-        self.chat_name = str(chat_name)
-        self.conn_time = int(conn_time)
-
-    def __repr__(self):
-        return "<connection user {} history {}>".format(self.user_id, self.chat_id)
-
-
-ChatAccessConnectionSettings.__table__.create(checkfirst=True)
-Connection.__table__.create(checkfirst=True)
-ConnectionHistory.__table__.create(checkfirst=True)
-
-CHAT_ACCESS_LOCK = threading.RLock()
-CONNECTION_INSERTION_LOCK = threading.RLock()
-CONNECTION_HISTORY_LOCK = threading.RLock()
-
-HISTORY_CONNECT = {}
-
-
-def allow_connect_to_chat(chat_id: Union[str, int]) -> bool:
-    try:
-        chat_setting = SESSION.query(ChatAccessConnectionSettings).get(str(chat_id))
-        if chat_setting:
-            return chat_setting.allow_connect_to_chat
-        return False
-    finally:
-        SESSION.close()
-
-
-def set_allow_connect_to_chat(chat_id: Union[int, str], setting: bool):
-    with CHAT_ACCESS_LOCK:
-        chat_setting = SESSION.query(ChatAccessConnectionSettings).get(str(chat_id))
-        if not chat_setting:
-            chat_setting = ChatAccessConnectionSettings(chat_id, setting)
-
-        chat_setting.allow_connect_to_chat = setting
-        SESSION.add(chat_setting)
-        SESSION.commit()
-
-
-def connect(user_id, chat_id):
-    with CONNECTION_INSERTION_LOCK:
-        prev = SESSION.query(Connection).get((int(user_id)))
-        if prev:
-            SESSION.delete(prev)
-        connect_to_chat = Connection(int(user_id), chat_id)
-        SESSION.add(connect_to_chat)
-        SESSION.commit()
-        return True
-
-
-def get_connected_chat(user_id):
-    try:
-        return SESSION.query(Connection).get((int(user_id)))
-    finally:
-        SESSION.close()
-
-
-def curr_connection(chat_id):
-    try:
-        return SESSION.query(Connection).get((str(chat_id)))
-    finally:
-        SESSION.close()
-
-
-def disconnect(user_id):
-    with CONNECTION_INSERTION_LOCK:
-        disconnect = SESSION.query(Connection).get((int(user_id)))
-        if disconnect:
-            SESSION.delete(disconnect)
-            SESSION.commit()
-            return True
-        else:
-            SESSION.close()
-            return False
-
-
-def add_history_conn(user_id, chat_id, chat_name):
-    global HISTORY_CONNECT
-    with CONNECTION_HISTORY_LOCK:
-        conn_time = int(time.time())
-        if HISTORY_CONNECT.get(int(user_id)):
-            counting = (
-                SESSION.query(ConnectionHistory.user_id)
-                .filter(ConnectionHistory.user_id == str(user_id))
-                .count()
-            )
-            getchat_id = {}
-            for x in HISTORY_CONNECT[int(user_id)]:
-                getchat_id[HISTORY_CONNECT[int(user_id)][x]["chat_id"]] = x
-            if chat_id in getchat_id:
-                todeltime = getchat_id[str(chat_id)]
-                delold = SESSION.query(ConnectionHistory).get(
-                    (int(user_id), str(chat_id))
-                )
-                if delold:
-                    SESSION.delete(delold)
-                    HISTORY_CONNECT[int(user_id)].pop(todeltime)
-            elif counting >= 5:
-                todel = list(HISTORY_CONNECT[int(user_id)])
-                todel.reverse()
-                todel = todel[4:]
-                for x in todel:
-                    chat_old = HISTORY_CONNECT[int(user_id)][x]["chat_id"]
-                    delold = SESSION.query(ConnectionHistory).get(
-                        (int(user_id), str(chat_old))
-                    )
-                    if delold:
-                        SESSION.delete(delold)
-                        HISTORY_CONNECT[int(user_id)].pop(x)
-        else:
-            HISTORY_CONNECT[int(user_id)] = {}
-        delold = SESSION.query(ConnectionHistory).get((int(user_id), str(chat_id)))
-        if delold:
-            SESSION.delete(delold)
-        history = ConnectionHistory(int(user_id), str(chat_id), chat_name, conn_time)
-        SESSION.add(history)
-        SESSION.commit()
-        HISTORY_CONNECT[int(user_id)][conn_time] = {
-            "chat_name": chat_name,
-            "chat_id": str(chat_id),
-        }
-
-
-def get_history_conn(user_id):
-    if not HISTORY_CONNECT.get(int(user_id)):
-        HISTORY_CONNECT[int(user_id)] = {}
-    return HISTORY_CONNECT[int(user_id)]
-
-
-def clear_history_conn(user_id):
-    global HISTORY_CONNECT
-    todel = list(HISTORY_CONNECT[int(user_id)])
-    for x in todel:
-        chat_old = HISTORY_CONNECT[int(user_id)][x]["chat_id"]
-        delold = SESSION.query(ConnectionHistory).get((int(user_id), str(chat_old)))
-        if delold:
-            SESSION.delete(delold)
-            HISTORY_CONNECT[int(user_id)].pop(x)
-    SESSION.commit()
-    return True
-
-
-def __load_user_history():
-    global HISTORY_CONNECT
-    try:
-        qall = SESSION.query(ConnectionHistory).all()
-        HISTORY_CONNECT = {}
-        for x in qall:
-            check = HISTORY_CONNECT.get(x.user_id)
-            if check is None:
-                HISTORY_CONNECT[x.user_id] = {}
-            HISTORY_CONNECT[x.user_id][x.conn_time] = {
-                "chat_name": x.chat_name,
-                "chat_id": x.chat_id,
-            }
-    finally:
-        SESSION.close()
-
-
-__load_user_history()

Database/sql/cust_filters_sql.py

@@ -1,299 +0,0 @@
-import threading
-
-from sqlalchemy import Boolean, Column, Integer, String, UnicodeText, distinct, func
-
-from Database.sql import BASE, SESSION
-from Mikobot.plugins.helper_funcs.msg_types import Types
-
-
-class CustomFilters(BASE):
-    __tablename__ = "cust_filters"
-    chat_id = Column(String(14), primary_key=True)
-    keyword = Column(UnicodeText, primary_key=True, nullable=False)
-    reply = Column(UnicodeText, nullable=False)
-    reply_text = Column(UnicodeText)
-    file_type = Column(Integer, nullable=False, default=1)
-    file_id = Column(UnicodeText, default=None)
-    has_buttons = Column(Boolean, nullable=False, default=False)
-    # NOTE: Here for legacy purposes, to ensure older filters don't mess up.
-    has_media_spoiler = Column(Boolean, nullable=False, default=False)
-
-    def __init__(
-        self,
-        chat_id: int | str,
-        keyword: str,
-        reply: str,
-        reply_text: str,
-        has_buttons: bool,
-        has_media_spoiler: bool,
-        file_type: int,
-        file_id: str,
-    ):
-        self.chat_id = str(chat_id)  # ensure string
-        self.keyword = keyword
-        self.reply = reply
-        self.reply_text = reply_text
-        self.has_buttons = has_buttons
-        self.has_media_spoiler = has_media_spoiler
-        self.file_type = file_type
-        self.file_id = file_id
-
-    def __repr__(self):
-        return "<Filter for %s>" % self.chat_id
-
-    def __eq__(self, other):
-        return bool(
-            isinstance(other, CustomFilters)
-            and self.chat_id == other.chat_id
-            and self.keyword == other.keyword,
-        )
-
-
-class Buttons(BASE):
-    __tablename__ = "cust_filter_urls"
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    chat_id = Column(String(14), primary_key=True)
-    keyword = Column(UnicodeText, primary_key=True)
-    name = Column(UnicodeText, nullable=False)
-    url = Column(UnicodeText, nullable=False)
-    same_line = Column(Boolean, default=False)
-
-    def __init__(self, chat_id, keyword, name, url, same_line=False):
-        self.chat_id = str(chat_id)
-        self.keyword = keyword
-        self.name = name
-        self.url = url
-        self.same_line = same_line
-
-
-CustomFilters.__table__.create(checkfirst=True)
-Buttons.__table__.create(checkfirst=True)
-
-CUST_FILT_LOCK = threading.RLock()
-BUTTON_LOCK = threading.RLock()
-CHAT_FILTERS = {}
-
-
-def get_all_filters():
-    try:
-        return SESSION.query(CustomFilters).all()
-    finally:
-        SESSION.close()
-
-
-def new_add_filter(
-    chat_id, keyword, reply_text, file_type, file_id, buttons, media_spoiler
-):
-    global CHAT_FILTERS
-
-    if buttons is None:
-        buttons = []
-
-    with CUST_FILT_LOCK:
-        prev = SESSION.query(CustomFilters).get((str(chat_id), keyword))
-        if prev:
-            with BUTTON_LOCK:
-                prev_buttons = (
-                    SESSION.query(Buttons)
-                    .filter(Buttons.chat_id == str(chat_id), Buttons.keyword == keyword)
-                    .all()
-                )
-                for btn in prev_buttons:
-                    SESSION.delete(btn)
-            SESSION.delete(prev)
-
-        filt = CustomFilters(
-            str(chat_id),
-            keyword,
-            reply="there is should be a new reply",
-            has_buttons=bool(buttons),
-            has_media_spoiler=media_spoiler,
-            reply_text=reply_text,
-            file_type=file_type.value,
-            file_id=file_id,
-        )
-
-        if keyword not in CHAT_FILTERS.get(str(chat_id), []):
-            CHAT_FILTERS[str(chat_id)] = sorted(
-                CHAT_FILTERS.get(str(chat_id), []) + [keyword],
-                key=lambda x: (-len(x), x),
-            )
-
-        SESSION.add(filt)
-        SESSION.commit()
-
-    for b_name, url, same_line in buttons:
-        add_note_button_to_db(chat_id, keyword, b_name, url, same_line)
-
-
-def remove_filter(chat_id, keyword):
-    global CHAT_FILTERS
-    with CUST_FILT_LOCK:
-        filt = SESSION.query(CustomFilters).get((str(chat_id), keyword))
-        if filt:
-            if keyword in CHAT_FILTERS.get(str(chat_id), []):  # Sanity check
-                CHAT_FILTERS.get(str(chat_id), []).remove(keyword)
-
-            with BUTTON_LOCK:
-                prev_buttons = (
-                    SESSION.query(Buttons)
-                    .filter(Buttons.chat_id == str(chat_id), Buttons.keyword == keyword)
-                    .all()
-                )
-                for btn in prev_buttons:
-                    SESSION.delete(btn)
-
-            SESSION.delete(filt)
-            SESSION.commit()
-            return True
-
-        SESSION.close()
-        return False
-
-
-def get_chat_triggers(chat_id):
-    return CHAT_FILTERS.get(str(chat_id), set())
-
-
-def get_chat_filters(chat_id):
-    try:
-        return (
-            SESSION.query(CustomFilters)
-            .filter(CustomFilters.chat_id == str(chat_id))
-            .order_by(func.length(CustomFilters.keyword).desc())
-            .order_by(CustomFilters.keyword.asc())
-            .all()
-        )
-    finally:
-        SESSION.close()
-
-
-def get_filter(chat_id, keyword) -> CustomFilters:
-    try:
-        return SESSION.query(CustomFilters).get((str(chat_id), keyword))
-    finally:
-        SESSION.close()
-
-
-def add_note_button_to_db(chat_id, keyword, b_name, url, same_line):
-    with BUTTON_LOCK:
-        button = Buttons(chat_id, keyword, b_name, url, same_line)
-        SESSION.add(button)
-        SESSION.commit()
-
-
-def get_buttons(chat_id, keyword):
-    try:
-        return (
-            SESSION.query(Buttons)
-            .filter(Buttons.chat_id == str(chat_id), Buttons.keyword == keyword)
-            .order_by(Buttons.id)
-            .all()
-        )
-    finally:
-        SESSION.close()
-
-
-def num_filters():
-    try:
-        return SESSION.query(CustomFilters).count()
-    finally:
-        SESSION.close()
-
-
-def num_chats():
-    try:
-        return SESSION.query(func.count(distinct(CustomFilters.chat_id))).scalar()
-    finally:
-        SESSION.close()
-
-
-def __load_chat_filters():
-    global CHAT_FILTERS
-    try:
-        chats = SESSION.query(CustomFilters.chat_id).distinct().all()
-        for (chat_id,) in chats:  # remove tuple by ( ,)
-            CHAT_FILTERS[chat_id] = []
-
-        all_filters = SESSION.query(CustomFilters).all()
-        for x in all_filters:
-            CHAT_FILTERS[x.chat_id] += [x.keyword]
-
-        CHAT_FILTERS = {
-            x: sorted(set(y), key=lambda i: (-len(i), i))
-            for x, y in CHAT_FILTERS.items()
-        }
-
-    finally:
-        SESSION.close()
-
-
-# ONLY USE FOR MIGRATE OLD FILTERS TO NEW FILTERS
-def __migrate_filters():
-    try:
-        all_filters = SESSION.query(CustomFilters).distinct().all()
-        for x in all_filters:
-            if x.is_document:
-                file_type = Types.DOCUMENT
-            elif x.is_image:
-                file_type = Types.PHOTO
-            elif x.is_video:
-                file_type = Types.VIDEO
-            elif x.is_sticker:
-                file_type = Types.STICKER
-            elif x.is_audio:
-                file_type = Types.AUDIO
-            elif x.is_voice:
-                file_type = Types.VOICE
-            else:
-                file_type = Types.TEXT
-
-            if file_type == Types.TEXT:
-                filt = CustomFilters(
-                    str(x.chat_id),
-                    x.keyword,
-                    x.reply,
-                    file_type.value,
-                    None,
-                )
-            else:
-                filt = CustomFilters(
-                    str(x.chat_id),
-                    x.keyword,
-                    None,
-                    file_type.value,
-                    x.reply,
-                )
-
-            SESSION.add(filt)
-            SESSION.commit()
-
-    finally:
-        SESSION.close()
-
-
-def migrate_chat(old_chat_id, new_chat_id):
-    with CUST_FILT_LOCK:
-        chat_filters = (
-            SESSION.query(CustomFilters)
-            .filter(CustomFilters.chat_id == str(old_chat_id))
-            .all()
-        )
-        for filt in chat_filters:
-            filt.chat_id = str(new_chat_id)
-        SESSION.commit()
-        old_filt = CHAT_FILTERS.get(str(old_chat_id))
-        if old_filt:
-            CHAT_FILTERS[str(new_chat_id)] = old_filt
-            del CHAT_FILTERS[str(old_chat_id)]
-
-        with BUTTON_LOCK:
-            chat_buttons = (
-                SESSION.query(Buttons).filter(Buttons.chat_id == str(old_chat_id)).all()
-            )
-            for btn in chat_buttons:
-                btn.chat_id = str(new_chat_id)
-            SESSION.commit()
-
-
-__load_chat_filters()

Database/sql/disable_sql.py

@@ -1,105 +0,0 @@
-import threading
-
-from sqlalchemy import Column, String, UnicodeText, distinct, func
-
-from Database.sql import BASE, SESSION
-
-
-class Disable(BASE):
-    __tablename__ = "disabled_commands"
-    chat_id = Column(String(14), primary_key=True)
-    command = Column(UnicodeText, primary_key=True)
-
-    def __init__(self, chat_id, command):
-        self.chat_id = chat_id
-        self.command = command
-
-    def __repr__(self):
-        return "Disabled cmd {} in {}".format(self.command, self.chat_id)
-
-
-Disable.__table__.create(checkfirst=True)
-DISABLE_INSERTION_LOCK = threading.RLock()
-
-DISABLED = {}
-
-
-def disable_command(chat_id, disable):
-    with DISABLE_INSERTION_LOCK:
-        disabled = SESSION.query(Disable).get((str(chat_id), disable))
-
-        if not disabled:
-            DISABLED.setdefault(str(chat_id), set()).add(disable)
-
-            disabled = Disable(str(chat_id), disable)
-            SESSION.add(disabled)
-            SESSION.commit()
-            return True
-
-        SESSION.close()
-        return False
-
-
-def enable_command(chat_id, enable):
-    with DISABLE_INSERTION_LOCK:
-        disabled = SESSION.query(Disable).get((str(chat_id), enable))
-
-        if disabled:
-            if enable in DISABLED.get(str(chat_id)):  # sanity check
-                DISABLED.setdefault(str(chat_id), set()).remove(enable)
-
-            SESSION.delete(disabled)
-            SESSION.commit()
-            return True
-
-        SESSION.close()
-        return False
-
-
-def is_command_disabled(chat_id, cmd):
-    return str(cmd).lower() in DISABLED.get(str(chat_id), set())
-
-
-def get_all_disabled(chat_id):
-    return DISABLED.get(str(chat_id), set())
-
-
-def num_chats():
-    try:
-        return SESSION.query(func.count(distinct(Disable.chat_id))).scalar()
-    finally:
-        SESSION.close()
-
-
-def num_disabled():
-    try:
-        return SESSION.query(Disable).count()
-    finally:
-        SESSION.close()
-
-
-def migrate_chat(old_chat_id, new_chat_id):
-    with DISABLE_INSERTION_LOCK:
-        chats = SESSION.query(Disable).filter(Disable.chat_id == str(old_chat_id)).all()
-        for chat in chats:
-            chat.chat_id = str(new_chat_id)
-            SESSION.add(chat)
-
-        if str(old_chat_id) in DISABLED:
-            DISABLED[str(new_chat_id)] = DISABLED.get(str(old_chat_id), set())
-
-        SESSION.commit()
-
-
-def __load_disabled_commands():
-    global DISABLED
-    try:
-        all_chats = SESSION.query(Disable).all()
-        for chat in all_chats:
-            DISABLED.setdefault(chat.chat_id, set()).add(chat.command)
-
-    finally:
-        SESSION.close()
-
-
-__load_disabled_commands()

Database/sql/feds_sql.py

@@ -1,931 +0,0 @@
-import ast
-import threading
-
-from sqlalchemy import BigInteger, Boolean, Column, Integer, String, UnicodeText
-from telegram.error import BadRequest, Forbidden
-
-from Database.sql import BASE, SESSION
-from Mikobot import dispatcher
-
-
-class Federations(BASE):
-    __tablename__ = "feds"
-    owner_id = Column(String(14))
-    fed_name = Column(UnicodeText)
-    fed_id = Column(UnicodeText, primary_key=True)
-    fed_rules = Column(UnicodeText)
-    fed_log = Column(UnicodeText)
-    fed_users = Column(UnicodeText)
-
-    def __init__(self, owner_id, fed_name, fed_id, fed_rules, fed_log, fed_users):
-        self.owner_id = owner_id
-        self.fed_name = fed_name
-        self.fed_id = fed_id
-        self.fed_rules = fed_rules
-        self.fed_log = fed_log
-        self.fed_users = fed_users
-
-
-class ChatF(BASE):
-    __tablename__ = "chat_feds"
-    chat_id = Column(String(14), primary_key=True)
-    chat_name = Column(UnicodeText)
-    fed_id = Column(UnicodeText)
-
-    def __init__(self, chat_id, chat_name, fed_id):
-        self.chat_id = chat_id
-        self.chat_name = chat_name
-        self.fed_id = fed_id
-
-
-class BansF(BASE):
-    __tablename__ = "bans_feds"
-    fed_id = Column(UnicodeText, primary_key=True)
-    user_id = Column(String(14), primary_key=True)
-    first_name = Column(UnicodeText, nullable=False)
-    last_name = Column(UnicodeText)
-    user_name = Column(UnicodeText)
-    reason = Column(UnicodeText, default="")
-    time = Column(Integer, default=0)
-
-    def __init__(self, fed_id, user_id, first_name, last_name, user_name, reason, time):
-        self.fed_id = fed_id
-        self.user_id = user_id
-        self.first_name = first_name
-        self.last_name = last_name
-        self.user_name = user_name
-        self.reason = reason
-        self.time = time
-
-
-class FedsUserSettings(BASE):
-    __tablename__ = "feds_settings"
-    user_id = Column(BigInteger, primary_key=True)
-    should_report = Column(Boolean, default=True)
-
-    def __init__(self, user_id):
-        self.user_id = user_id
-
-    def __repr__(self):
-        return "<Feds report settings ({})>".format(self.user_id)
-
-
-class FedSubs(BASE):
-    __tablename__ = "feds_subs"
-    fed_id = Column(UnicodeText, primary_key=True)
-    fed_subs = Column(UnicodeText, primary_key=True, nullable=False)
-
-    def __init__(self, fed_id, fed_subs):
-        self.fed_id = fed_id
-        self.fed_subs = fed_subs
-
-    def __repr__(self):
-        return "<Fed {} subscribes for {}>".format(self.fed_id, self.fed_subs)
-
-
-# Dropping db
-# Federations.__table__.drop()
-# ChatF.__table__.drop()
-# BansF.__table__.drop()
-# FedSubs.__table__.drop()
-
-Federations.__table__.create(checkfirst=True)
-ChatF.__table__.create(checkfirst=True)
-BansF.__table__.create(checkfirst=True)
-FedsUserSettings.__table__.create(checkfirst=True)
-FedSubs.__table__.create(checkfirst=True)
-
-FEDS_LOCK = threading.RLock()
-CHAT_FEDS_LOCK = threading.RLock()
-FEDS_SETTINGS_LOCK = threading.RLock()
-FEDS_SUBSCRIBER_LOCK = threading.RLock()
-
-FEDERATION_BYNAME = {}
-FEDERATION_BYOWNER = {}
-FEDERATION_BYFEDID = {}
-
-FEDERATION_CHATS = {}
-FEDERATION_CHATS_BYID = {}
-
-FEDERATION_BANNED_FULL = {}
-FEDERATION_BANNED_USERID = {}
-
-FEDERATION_NOTIFICATION = {}
-FEDS_SUBSCRIBER = {}
-MYFEDS_SUBSCRIBER = {}
-
-
-def get_fed_info(fed_id):
-    get = FEDERATION_BYFEDID.get(str(fed_id))
-    if get is None:
-        return False
-    return get
-
-
-def get_fed_id(chat_id):
-    get = FEDERATION_CHATS.get(str(chat_id))
-    if get is None:
-        return False
-    else:
-        return get["fid"]
-
-
-def get_fed_name(chat_id):
-    get = FEDERATION_CHATS.get(str(chat_id))
-    if get is None:
-        return False
-    else:
-        return get["chat_name"]
-
-
-def get_user_fban(fed_id, user_id):
-    if not FEDERATION_BANNED_FULL.get(fed_id):
-        return False, False, False
-    user_info = FEDERATION_BANNED_FULL[fed_id].get(user_id)
-    if not user_info:
-        return None, None, None
-    return user_info["first_name"], user_info["reason"], user_info["time"]
-
-
-def get_user_admin_fed_name(user_id):
-    user_feds = []
-    for f in FEDERATION_BYFEDID:
-        if int(user_id) in ast.literal_eval(
-            ast.literal_eval(FEDERATION_BYFEDID[f]["fusers"])["members"]
-        ):
-            user_feds.append(FEDERATION_BYFEDID[f]["fname"])
-    return user_feds
-
-
-def get_user_owner_fed_name(user_id):
-    user_feds = []
-    for f in FEDERATION_BYFEDID:
-        if int(user_id) == int(
-            ast.literal_eval(FEDERATION_BYFEDID[f]["fusers"])["owner"]
-        ):
-            user_feds.append(FEDERATION_BYFEDID[f]["fname"])
-    return user_feds
-
-
-def get_user_admin_fed_full(user_id):
-    user_feds = []
-    for f in FEDERATION_BYFEDID:
-        if int(user_id) in ast.literal_eval(
-            ast.literal_eval(FEDERATION_BYFEDID[f]["fusers"])["members"]
-        ):
-            user_feds.append({"fed_id": f, "fed": FEDERATION_BYFEDID[f]})
-    return user_feds
-
-
-def get_user_owner_fed_full(user_id):
-    user_feds = []
-    for f in FEDERATION_BYFEDID:
-        if int(user_id) == int(
-            ast.literal_eval(FEDERATION_BYFEDID[f]["fusers"])["owner"]
-        ):
-            user_feds.append({"fed_id": f, "fed": FEDERATION_BYFEDID[f]})
-    return user_feds
-
-
-def get_user_fbanlist(user_id):
-    banlist = FEDERATION_BANNED_FULL
-    user_name = ""
-    fedname = []
-    for x in banlist:
-        if banlist[x].get(user_id):
-            if user_name == "":
-                user_name = banlist[x][user_id].get("first_name")
-            fedname.append([x, banlist[x][user_id].get("reason")])
-    return user_name, fedname
-
-
-def new_fed(owner_id, fed_name, fed_id):
-    with FEDS_LOCK:
-        global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME
-        fed = Federations(
-            str(owner_id),
-            fed_name,
-            str(fed_id),
-            "Rules is not set in this federation.",
-            None,
-            str({"owner": str(owner_id), "members": "[]"}),
-        )
-        SESSION.add(fed)
-        SESSION.commit()
-        FEDERATION_BYOWNER[str(owner_id)] = {
-            "fid": str(fed_id),
-            "fname": fed_name,
-            "frules": "Rules is not set in this federation.",
-            "flog": None,
-            "fusers": str({"owner": str(owner_id), "members": "[]"}),
-        }
-        FEDERATION_BYFEDID[str(fed_id)] = {
-            "owner": str(owner_id),
-            "fname": fed_name,
-            "frules": "Rules is not set in this federation.",
-            "flog": None,
-            "fusers": str({"owner": str(owner_id), "members": "[]"}),
-        }
-        FEDERATION_BYNAME[fed_name] = {
-            "fid": str(fed_id),
-            "owner": str(owner_id),
-            "frules": "Rules is not set in this federation.",
-            "flog": None,
-            "fusers": str({"owner": str(owner_id), "members": "[]"}),
-        }
-        return fed
-
-
-def del_fed(fed_id):
-    with FEDS_LOCK:
-        global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME, FEDERATION_CHATS, FEDERATION_CHATS_BYID, FEDERATION_BANNED_USERID, FEDERATION_BANNED_FULL
-        getcache = FEDERATION_BYFEDID.get(fed_id)
-        if getcache is None:
-            return False
-        # Variables
-        getfed = FEDERATION_BYFEDID.get(fed_id)
-        owner_id = getfed["owner"]
-        fed_name = getfed["fname"]
-        # Delete from cache
-        FEDERATION_BYOWNER.pop(owner_id)
-        FEDERATION_BYFEDID.pop(fed_id)
-        FEDERATION_BYNAME.pop(fed_name)
-        if FEDERATION_CHATS_BYID.get(fed_id):
-            for x in FEDERATION_CHATS_BYID[fed_id]:
-                delchats = SESSION.query(ChatF).get(str(x))
-                if delchats:
-                    SESSION.delete(delchats)
-                    SESSION.commit()
-                FEDERATION_CHATS.pop(x)
-            FEDERATION_CHATS_BYID.pop(fed_id)
-        # Delete fedban users
-        getall = FEDERATION_BANNED_USERID.get(fed_id)
-        if getall:
-            for x in getall:
-                banlist = SESSION.query(BansF).get((fed_id, str(x)))
-                if banlist:
-                    SESSION.delete(banlist)
-                    SESSION.commit()
-        if FEDERATION_BANNED_USERID.get(fed_id):
-            FEDERATION_BANNED_USERID.pop(fed_id)
-        if FEDERATION_BANNED_FULL.get(fed_id):
-            FEDERATION_BANNED_FULL.pop(fed_id)
-        # Delete fedsubs
-        getall = MYFEDS_SUBSCRIBER.get(fed_id)
-        if getall:
-            for x in getall:
-                getsubs = SESSION.query(FedSubs).get((fed_id, str(x)))
-                if getsubs:
-                    SESSION.delete(getsubs)
-                    SESSION.commit()
-        if FEDS_SUBSCRIBER.get(fed_id):
-            FEDS_SUBSCRIBER.pop(fed_id)
-        if MYFEDS_SUBSCRIBER.get(fed_id):
-            MYFEDS_SUBSCRIBER.pop(fed_id)
-        # Delete from database
-        curr = SESSION.query(Federations).get(fed_id)
-        if curr:
-            SESSION.delete(curr)
-            SESSION.commit()
-        return True
-
-
-def rename_fed(fed_id, owner_id, newname):
-    with FEDS_LOCK:
-        global FEDERATION_BYFEDID, FEDERATION_BYOWNER, FEDERATION_BYNAME
-        fed = SESSION.query(Federations).get(fed_id)
-        if not fed:
-            return False
-        fed.fed_name = newname
-        SESSION.commit()
-
-        # Update the dicts
-        oldname = FEDERATION_BYFEDID[str(fed_id)]["fname"]
-        tempdata = FEDERATION_BYNAME[oldname]
-        FEDERATION_BYNAME.pop(oldname)
-
-        FEDERATION_BYOWNER[str(owner_id)]["fname"] = newname
-        FEDERATION_BYFEDID[str(fed_id)]["fname"] = newname
-        FEDERATION_BYNAME[newname] = tempdata
-        return True
-
-
-def chat_join_fed(fed_id, chat_name, chat_id):
-    with FEDS_LOCK:
-        global FEDERATION_CHATS, FEDERATION_CHATS_BYID
-        r = ChatF(chat_id, chat_name, fed_id)
-        SESSION.add(r)
-        FEDERATION_CHATS[str(chat_id)] = {"chat_name": chat_name, "fid": fed_id}
-        checkid = FEDERATION_CHATS_BYID.get(fed_id)
-        if checkid is None:
-            FEDERATION_CHATS_BYID[fed_id] = []
-        FEDERATION_CHATS_BYID[fed_id].append(str(chat_id))
-        SESSION.commit()
-        return r
-
-
-def search_fed_by_name(fed_name):
-    allfed = FEDERATION_BYNAME.get(fed_name)
-    if allfed is None:
-        return False
-    return allfed
-
-
-def search_user_in_fed(fed_id, user_id):
-    getfed = FEDERATION_BYFEDID.get(fed_id)
-    if getfed is None:
-        return False
-    getfed = ast.literal_eval(getfed["fusers"])["members"]
-    if user_id in ast.literal_eval(getfed):
-        return True
-    else:
-        return False
-
-
-def user_demote_fed(fed_id, user_id):
-    with FEDS_LOCK:
-        global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME
-        # Variables
-        getfed = FEDERATION_BYFEDID.get(str(fed_id))
-        owner_id = getfed["owner"]
-        fed_name = getfed["fname"]
-        fed_rules = getfed["frules"]
-        fed_log = getfed["flog"]
-        # Temp set
-        try:
-            members = ast.literal_eval(ast.literal_eval(getfed["fusers"])["members"])
-        except ValueError:
-            return False
-        members.remove(user_id)
-        # Set user
-        FEDERATION_BYOWNER[str(owner_id)]["fusers"] = str(
-            {"owner": str(owner_id), "members": str(members)},
-        )
-        FEDERATION_BYFEDID[str(fed_id)]["fusers"] = str(
-            {"owner": str(owner_id), "members": str(members)},
-        )
-        FEDERATION_BYNAME[fed_name]["fusers"] = str(
-            {"owner": str(owner_id), "members": str(members)},
-        )
-        # Set on database
-        fed = Federations(
-            str(owner_id),
-            fed_name,
-            str(fed_id),
-            fed_rules,
-            fed_log,
-            str({"owner": str(owner_id), "members": str(members)}),
-        )
-        SESSION.merge(fed)
-        SESSION.commit()
-        return True
-
-        curr = SESSION.query(UserF).all()
-        result = False
-        for r in curr:
-            if int(r.user_id) == int(user_id):
-                if r.fed_id == fed_id:
-                    SESSION.delete(r)
-                    SESSION.commit()
-                    result = True
-
-        SESSION.close()
-        return result
-
-
-def user_join_fed(fed_id, user_id):
-    with FEDS_LOCK:
-        global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME
-        # Variables
-        getfed = FEDERATION_BYFEDID.get(str(fed_id))
-        owner_id = getfed["owner"]
-        fed_name = getfed["fname"]
-        fed_rules = getfed["frules"]
-        fed_log = getfed["flog"]
-        # Temp set
-        members = ast.literal_eval(ast.literal_eval(getfed["fusers"])["members"])
-        members.append(user_id)
-        # Set user
-        FEDERATION_BYOWNER[str(owner_id)]["fusers"] = str(
-            {"owner": str(owner_id), "members": str(members)},
-        )
-        FEDERATION_BYFEDID[str(fed_id)]["fusers"] = str(
-            {"owner": str(owner_id), "members": str(members)},
-        )
-        FEDERATION_BYNAME[fed_name]["fusers"] = str(
-            {"owner": str(owner_id), "members": str(members)},
-        )
-        # Set on database
-        fed = Federations(
-            str(owner_id),
-            fed_name,
-            str(fed_id),
-            fed_rules,
-            fed_log,
-            str({"owner": str(owner_id), "members": str(members)}),
-        )
-        SESSION.merge(fed)
-        SESSION.commit()
-        __load_all_feds_chats()
-        return True
-
-
-def chat_leave_fed(chat_id):
-    with FEDS_LOCK:
-        global FEDERATION_CHATS, FEDERATION_CHATS_BYID
-        # Set variables
-        fed_info = FEDERATION_CHATS.get(str(chat_id))
-        if fed_info is None:
-            return False
-        fed_id = fed_info["fid"]
-        # Delete from cache
-        FEDERATION_CHATS.pop(str(chat_id))
-        FEDERATION_CHATS_BYID[str(fed_id)].remove(str(chat_id))
-        # Delete from db
-        curr = SESSION.query(ChatF).all()
-        for U in curr:
-            if int(U.chat_id) == int(chat_id):
-                SESSION.delete(U)
-                SESSION.commit()
-        return True
-
-
-def all_fed_chats(fed_id):
-    with FEDS_LOCK:
-        getfed = FEDERATION_CHATS_BYID.get(fed_id)
-        if getfed is None:
-            return []
-        else:
-            return getfed
-
-
-def all_fed_users(fed_id):
-    with FEDS_LOCK:
-        getfed = FEDERATION_BYFEDID.get(str(fed_id))
-        if getfed is None:
-            return False
-        fed_owner = ast.literal_eval(ast.literal_eval(getfed["fusers"])["owner"])
-        fed_admins = ast.literal_eval(ast.literal_eval(getfed["fusers"])["members"])
-        fed_admins.append(fed_owner)
-        return fed_admins
-
-
-def all_fed_members(fed_id):
-    with FEDS_LOCK:
-        getfed = FEDERATION_BYFEDID.get(str(fed_id))
-        fed_admins = ast.literal_eval(ast.literal_eval(getfed["fusers"])["members"])
-        return fed_admins
-
-
-def set_frules(fed_id, rules):
-    with FEDS_LOCK:
-        global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME
-        # Variables
-        getfed = FEDERATION_BYFEDID.get(str(fed_id))
-        owner_id = getfed["owner"]
-        fed_name = getfed["fname"]
-        fed_members = getfed["fusers"]
-        fed_rules = str(rules)
-        fed_log = getfed["flog"]
-        # Set user
-        FEDERATION_BYOWNER[str(owner_id)]["frules"] = fed_rules
-        FEDERATION_BYFEDID[str(fed_id)]["frules"] = fed_rules
-        FEDERATION_BYNAME[fed_name]["frules"] = fed_rules
-        # Set on database
-        fed = Federations(
-            str(owner_id),
-            fed_name,
-            str(fed_id),
-            fed_rules,
-            fed_log,
-            str(fed_members),
-        )
-        SESSION.merge(fed)
-        SESSION.commit()
-        return True
-
-
-def get_frules(fed_id):
-    with FEDS_LOCK:
-        rules = FEDERATION_BYFEDID[str(fed_id)]["frules"]
-        return rules
-
-
-def fban_user(fed_id, user_id, first_name, last_name, user_name, reason, time):
-    with FEDS_LOCK:
-        r = SESSION.query(BansF).all()
-        for I in r:
-            if I.fed_id == fed_id:
-                if int(I.user_id) == int(user_id):
-                    SESSION.delete(I)
-
-        r = BansF(
-            str(fed_id),
-            str(user_id),
-            first_name,
-            last_name,
-            user_name,
-            reason,
-            time,
-        )
-
-        SESSION.add(r)
-        try:
-            SESSION.commit()
-        except:
-            SESSION.rollback()
-            return False
-        finally:
-            SESSION.commit()
-        __load_all_feds_banned()
-        return r
-
-
-def multi_fban_user(
-    multi_fed_id,
-    multi_user_id,
-    multi_first_name,
-    multi_last_name,
-    multi_user_name,
-    multi_reason,
-):
-    if True:  # with FEDS_LOCK:
-        counter = 0
-        time = 0
-        for x in range(len(multi_fed_id)):
-            fed_id = multi_fed_id[x]
-            user_id = multi_user_id[x]
-            first_name = multi_first_name[x]
-            last_name = multi_last_name[x]
-            user_name = multi_user_name[x]
-            reason = multi_reason[x]
-            r = SESSION.query(BansF).all()
-            for I in r:
-                if I.fed_id == fed_id:
-                    if int(I.user_id) == int(user_id):
-                        SESSION.delete(I)
-
-            r = BansF(
-                str(fed_id),
-                str(user_id),
-                first_name,
-                last_name,
-                user_name,
-                reason,
-                time,
-            )
-
-            SESSION.add(r)
-            counter += 1
-        try:
-            SESSION.commit()
-        except:
-            SESSION.rollback()
-            return False
-        finally:
-            SESSION.commit()
-        __load_all_feds_banned()
-        return counter
-
-
-def un_fban_user(fed_id, user_id):
-    with FEDS_LOCK:
-        r = SESSION.query(BansF).all()
-        for I in r:
-            if I.fed_id == fed_id:
-                if int(I.user_id) == int(user_id):
-                    SESSION.delete(I)
-        try:
-            SESSION.commit()
-        except:
-            SESSION.rollback()
-            return False
-        finally:
-            SESSION.commit()
-        __load_all_feds_banned()
-        return I
-
-
-def get_fban_user(fed_id, user_id):
-    list_fbanned = FEDERATION_BANNED_USERID.get(fed_id)
-    if list_fbanned is None:
-        FEDERATION_BANNED_USERID[fed_id] = []
-    if user_id in FEDERATION_BANNED_USERID[fed_id]:
-        r = SESSION.query(BansF).all()
-        reason = None
-        for I in r:
-            if I.fed_id == fed_id:
-                if int(I.user_id) == int(user_id):
-                    reason = I.reason
-                    time = I.time
-        return True, reason, time
-    else:
-        return False, None, None
-
-
-def get_all_fban_users(fed_id):
-    list_fbanned = FEDERATION_BANNED_USERID.get(fed_id)
-    if list_fbanned is None:
-        FEDERATION_BANNED_USERID[fed_id] = []
-    return FEDERATION_BANNED_USERID[fed_id]
-
-
-def get_all_fban_users_target(fed_id, user_id):
-    list_fbanned = FEDERATION_BANNED_FULL.get(fed_id)
-    if list_fbanned is None:
-        FEDERATION_BANNED_FULL[fed_id] = []
-        return False
-    getuser = list_fbanned[str(user_id)]
-    return getuser
-
-
-def get_all_fban_users_global():
-    list_fbanned = FEDERATION_BANNED_USERID
-    total = []
-    for x in list(FEDERATION_BANNED_USERID):
-        for y in FEDERATION_BANNED_USERID[x]:
-            total.append(y)
-    return total
-
-
-def get_all_feds_users_global():
-    list_fed = FEDERATION_BYFEDID
-    total = []
-    for x in list(FEDERATION_BYFEDID):
-        total.append(FEDERATION_BYFEDID[x])
-    return total
-
-
-def search_fed_by_id(fed_id):
-    get = FEDERATION_BYFEDID.get(fed_id)
-    if get is None:
-        return False
-    else:
-        return get
-    result = False
-    for Q in curr:
-        if Q.fed_id == fed_id:
-            result = Q.fed_id
-
-    return result
-
-
-def user_feds_report(user_id: int) -> bool:
-    user_setting = FEDERATION_NOTIFICATION.get(str(user_id))
-    if user_setting is None:
-        user_setting = True
-    return user_setting
-
-
-def set_feds_setting(user_id: int, setting: bool):
-    with FEDS_SETTINGS_LOCK:
-        global FEDERATION_NOTIFICATION
-        user_setting = SESSION.query(FedsUserSettings).get(user_id)
-        if not user_setting:
-            user_setting = FedsUserSettings(user_id)
-
-        user_setting.should_report = setting
-        FEDERATION_NOTIFICATION[str(user_id)] = setting
-        SESSION.add(user_setting)
-        SESSION.commit()
-
-
-async def get_fed_log(fed_id):
-    fed_setting = FEDERATION_BYFEDID.get(str(fed_id))
-    if fed_setting is None:
-        fed_setting = False
-        return fed_setting
-    if fed_setting.get("flog") is None:
-        return False
-    elif fed_setting.get("flog"):
-        try:
-            await dispatcher.bot.get_chat(fed_setting.get("flog"))
-        except BadRequest:
-            set_fed_log(fed_id, None)
-            return False
-        except Forbidden:
-            set_fed_log(fed_id, None)
-            return False
-        return fed_setting.get("flog")
-    else:
-        return False
-
-
-def set_fed_log(fed_id, chat_id):
-    with FEDS_LOCK:
-        global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME
-        # Variables
-        getfed = FEDERATION_BYFEDID.get(str(fed_id))
-        owner_id = getfed["owner"]
-        fed_name = getfed["fname"]
-        fed_members = getfed["fusers"]
-        fed_rules = getfed["frules"]
-        fed_log = str(chat_id)
-        # Set user
-        FEDERATION_BYOWNER[str(owner_id)]["flog"] = fed_log
-        FEDERATION_BYFEDID[str(fed_id)]["flog"] = fed_log
-        FEDERATION_BYNAME[fed_name]["flog"] = fed_log
-        # Set on database
-        fed = Federations(
-            str(owner_id),
-            fed_name,
-            str(fed_id),
-            fed_rules,
-            fed_log,
-            str(fed_members),
-        )
-        SESSION.merge(fed)
-        SESSION.commit()
-        return True
-
-
-def subs_fed(fed_id, my_fed):
-    check = get_spec_subs(fed_id, my_fed)
-    if check:
-        return False
-    with FEDS_SUBSCRIBER_LOCK:
-        subsfed = FedSubs(fed_id, my_fed)
-
-        SESSION.merge(subsfed)  # merge to avoid duplicate key issues
-        SESSION.commit()
-        global FEDS_SUBSCRIBER, MYFEDS_SUBSCRIBER
-        # Temporary Data For Subbed Feds
-        if FEDS_SUBSCRIBER.get(fed_id, set()) == set():
-            FEDS_SUBSCRIBER[fed_id] = {my_fed}
-        else:
-            FEDS_SUBSCRIBER.get(fed_id, set()).add(my_fed)
-        # Temporary data for Fed Subs
-        if MYFEDS_SUBSCRIBER.get(my_fed, set()) == set():
-            MYFEDS_SUBSCRIBER[my_fed] = {fed_id}
-        else:
-            MYFEDS_SUBSCRIBER.get(my_fed, set()).add(fed_id)
-        return True
-
-
-def unsubs_fed(fed_id, my_fed):
-    with FEDS_SUBSCRIBER_LOCK:
-        getsubs = SESSION.query(FedSubs).get((fed_id, my_fed))
-        if getsubs:
-            if my_fed in FEDS_SUBSCRIBER.get(fed_id, set()):  # sanity check
-                FEDS_SUBSCRIBER.get(fed_id, set()).remove(my_fed)
-            if fed_id in MYFEDS_SUBSCRIBER.get(my_fed, set()):  # sanity check
-                MYFEDS_SUBSCRIBER.get(my_fed, set()).remove(fed_id)
-
-            SESSION.delete(getsubs)
-            SESSION.commit()
-            return True
-
-        SESSION.close()
-        return False
-
-
-def get_all_subs(fed_id):
-    return FEDS_SUBSCRIBER.get(fed_id, set())
-
-
-def get_spec_subs(fed_id, fed_target):
-    if FEDS_SUBSCRIBER.get(fed_id, set()) == set():
-        return {}
-    else:
-        return FEDS_SUBSCRIBER.get(fed_id, fed_target)
-
-
-def get_mysubs(my_fed):
-    return list(MYFEDS_SUBSCRIBER.get(my_fed))
-
-
-def get_subscriber(fed_id):
-    return FEDS_SUBSCRIBER.get(fed_id, set())
-
-
-def __load_all_feds():
-    global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME
-    try:
-        feds = SESSION.query(Federations).all()
-        for x in feds:  # remove tuple by ( ,)
-            # Fed by Owner
-            check = FEDERATION_BYOWNER.get(x.owner_id)
-            if check is None:
-                FEDERATION_BYOWNER[x.owner_id] = []
-            FEDERATION_BYOWNER[str(x.owner_id)] = {
-                "fid": str(x.fed_id),
-                "fname": x.fed_name,
-                "frules": x.fed_rules,
-                "flog": x.fed_log,
-                "fusers": str(x.fed_users),
-            }
-            # Fed By FedId
-            check = FEDERATION_BYFEDID.get(x.fed_id)
-            if check is None:
-                FEDERATION_BYFEDID[x.fed_id] = []
-            FEDERATION_BYFEDID[str(x.fed_id)] = {
-                "owner": str(x.owner_id),
-                "fname": x.fed_name,
-                "frules": x.fed_rules,
-                "flog": x.fed_log,
-                "fusers": str(x.fed_users),
-            }
-            # Fed By Name
-            check = FEDERATION_BYNAME.get(x.fed_name)
-            if check is None:
-                FEDERATION_BYNAME[x.fed_name] = []
-            FEDERATION_BYNAME[x.fed_name] = {
-                "fid": str(x.fed_id),
-                "owner": str(x.owner_id),
-                "frules": x.fed_rules,
-                "flog": x.fed_log,
-                "fusers": str(x.fed_users),
-            }
-    finally:
-        SESSION.close()
-
-
-def __load_all_feds_chats():
-    global FEDERATION_CHATS, FEDERATION_CHATS_BYID
-    try:
-        qall = SESSION.query(ChatF).all()
-        FEDERATION_CHATS = {}
-        FEDERATION_CHATS_BYID = {}
-        for x in qall:
-            # Federation Chats
-            check = FEDERATION_CHATS.get(x.chat_id)
-            if check is None:
-                FEDERATION_CHATS[x.chat_id] = {}
-            FEDERATION_CHATS[x.chat_id] = {"chat_name": x.chat_name, "fid": x.fed_id}
-            # Federation Chats By ID
-            check = FEDERATION_CHATS_BYID.get(x.fed_id)
-            if check is None:
-                FEDERATION_CHATS_BYID[x.fed_id] = []
-            FEDERATION_CHATS_BYID[x.fed_id].append(x.chat_id)
-    finally:
-        SESSION.close()
-
-
-def __load_all_feds_banned():
-    global FEDERATION_BANNED_USERID, FEDERATION_BANNED_FULL
-    try:
-        FEDERATION_BANNED_USERID = {}
-        FEDERATION_BANNED_FULL = {}
-        qall = SESSION.query(BansF).all()
-        for x in qall:
-            check = FEDERATION_BANNED_USERID.get(x.fed_id)
-            if check is None:
-                FEDERATION_BANNED_USERID[x.fed_id] = []
-            if int(x.user_id) not in FEDERATION_BANNED_USERID[x.fed_id]:
-                FEDERATION_BANNED_USERID[x.fed_id].append(int(x.user_id))
-            check = FEDERATION_BANNED_FULL.get(x.fed_id)
-            if check is None:
-                FEDERATION_BANNED_FULL[x.fed_id] = {}
-            FEDERATION_BANNED_FULL[x.fed_id][x.user_id] = {
-                "first_name": x.first_name,
-                "last_name": x.last_name,
-                "user_name": x.user_name,
-                "reason": x.reason,
-                "time": x.time,
-            }
-    finally:
-        SESSION.close()
-
-
-def __load_all_feds_settings():
-    global FEDERATION_NOTIFICATION
-    try:
-        getuser = SESSION.query(FedsUserSettings).all()
-        for x in getuser:
-            FEDERATION_NOTIFICATION[str(x.user_id)] = x.should_report
-    finally:
-        SESSION.close()
-
-
-def __load_feds_subscriber():
-    global FEDS_SUBSCRIBER
-    global MYFEDS_SUBSCRIBER
-    try:
-        feds = SESSION.query(FedSubs.fed_id).distinct().all()
-        for (fed_id,) in feds:  # remove tuple by ( ,)
-            FEDS_SUBSCRIBER[fed_id] = []
-            MYFEDS_SUBSCRIBER[fed_id] = []
-
-        all_fedsubs = SESSION.query(FedSubs).all()
-        for x in all_fedsubs:
-            FEDS_SUBSCRIBER[x.fed_id] += [x.fed_subs]
-            try:
-                MYFEDS_SUBSCRIBER[x.fed_subs] += [x.fed_id]
-            except KeyError:
-                getsubs = SESSION.query(FedSubs).get((x.fed_id, x.fed_subs))
-                if getsubs:
-                    SESSION.delete(getsubs)
-                    SESSION.commit()
-
-        FEDS_SUBSCRIBER = {x: set(y) for x, y in FEDS_SUBSCRIBER.items()}
-        MYFEDS_SUBSCRIBER = {x: set(y) for x, y in MYFEDS_SUBSCRIBER.items()}
-
-    finally:
-        SESSION.close()
-
-
-__load_all_feds()
-__load_all_feds_chats()
-__load_all_feds_banned()
-__load_all_feds_settings()
-__load_feds_subscriber()

Database/sql/global_bans_sql.py

@@ -1,167 +0,0 @@
-import threading
-
-from sqlalchemy import BigInteger, Boolean, Column, String, UnicodeText
-
-from Database.sql import BASE, SESSION
-
-
-class GloballyBannedUsers(BASE):
-    __tablename__ = "gbans"
-    user_id = Column(BigInteger, primary_key=True)
-    name = Column(UnicodeText, nullable=False)
-    reason = Column(UnicodeText)
-
-    def __init__(self, user_id, name, reason=None):
-        self.user_id = user_id
-        self.name = name
-        self.reason = reason
-
-    def __repr__(self):
-        return "<GBanned User {} ({})>".format(self.name, self.user_id)
-
-    def to_dict(self):
-        return {"user_id": self.user_id, "name": self.name, "reason": self.reason}
-
-
-class GbanSettings(BASE):
-    __tablename__ = "gban_settings"
-    chat_id = Column(String(14), primary_key=True)
-    setting = Column(Boolean, default=True, nullable=False)
-
-    def __init__(self, chat_id, enabled):
-        self.chat_id = str(chat_id)
-        self.setting = enabled
-
-    def __repr__(self):
-        return "<Gban setting {} ({})>".format(self.chat_id, self.setting)
-
-
-GloballyBannedUsers.__table__.create(checkfirst=True)
-GbanSettings.__table__.create(checkfirst=True)
-
-GBANNED_USERS_LOCK = threading.RLock()
-GBAN_SETTING_LOCK = threading.RLock()
-GBANNED_LIST = set()
-GBANSTAT_LIST = set()
-
-
-def gban_user(user_id, name, reason=None):
-    with GBANNED_USERS_LOCK:
-        user = SESSION.query(GloballyBannedUsers).get(user_id)
-        if not user:
-            user = GloballyBannedUsers(user_id, name, reason)
-        else:
-            user.name = name
-            user.reason = reason
-
-        SESSION.merge(user)
-        SESSION.commit()
-        __load_gbanned_userid_list()
-
-
-def update_gban_reason(user_id, name, reason=None):
-    with GBANNED_USERS_LOCK:
-        user = SESSION.query(GloballyBannedUsers).get(user_id)
-        if not user:
-            return None
-        old_reason = user.reason
-        user.name = name
-        user.reason = reason
-
-        SESSION.merge(user)
-        SESSION.commit()
-        return old_reason
-
-
-def ungban_user(user_id):
-    with GBANNED_USERS_LOCK:
-        user = SESSION.query(GloballyBannedUsers).get(user_id)
-        if user:
-            SESSION.delete(user)
-
-        SESSION.commit()
-        __load_gbanned_userid_list()
-
-
-def is_user_gbanned(user_id):
-    return user_id in GBANNED_LIST
-
-
-def get_gbanned_user(user_id):
-    try:
-        return SESSION.query(GloballyBannedUsers).get(user_id)
-    finally:
-        SESSION.close()
-
-
-def get_gban_list():
-    try:
-        return [x.to_dict() for x in SESSION.query(GloballyBannedUsers).all()]
-    finally:
-        SESSION.close()
-
-
-def enable_gbans(chat_id):
-    with GBAN_SETTING_LOCK:
-        chat = SESSION.query(GbanSettings).get(str(chat_id))
-        if not chat:
-            chat = GbanSettings(chat_id, True)
-
-        chat.setting = True
-        SESSION.add(chat)
-        SESSION.commit()
-        if str(chat_id) in GBANSTAT_LIST:
-            GBANSTAT_LIST.remove(str(chat_id))
-
-
-def disable_gbans(chat_id):
-    with GBAN_SETTING_LOCK:
-        chat = SESSION.query(GbanSettings).get(str(chat_id))
-        if not chat:
-            chat = GbanSettings(chat_id, False)
-
-        chat.setting = False
-        SESSION.add(chat)
-        SESSION.commit()
-        GBANSTAT_LIST.add(str(chat_id))
-
-
-def does_chat_gban(chat_id):
-    return str(chat_id) not in GBANSTAT_LIST
-
-
-def num_gbanned_users():
-    return len(GBANNED_LIST)
-
-
-def __load_gbanned_userid_list():
-    global GBANNED_LIST
-    try:
-        GBANNED_LIST = {x.user_id for x in SESSION.query(GloballyBannedUsers).all()}
-    finally:
-        SESSION.close()
-
-
-def __load_gban_stat_list():
-    global GBANSTAT_LIST
-    try:
-        GBANSTAT_LIST = {
-            x.chat_id for x in SESSION.query(GbanSettings).all() if not x.setting
-        }
-    finally:
-        SESSION.close()
-
-
-def migrate_chat(old_chat_id, new_chat_id):
-    with GBAN_SETTING_LOCK:
-        chat = SESSION.query(GbanSettings).get(str(old_chat_id))
-        if chat:
-            chat.chat_id = new_chat_id
-            SESSION.add(chat)
-
-        SESSION.commit()
-
-
-# Create in memory userid to avoid disk access
-__load_gbanned_userid_list()
-__load_gban_stat_list()

Database/sql/kuki_sql.py

@@ -1,42 +0,0 @@
-import threading
-
-from sqlalchemy import Column, String
-
-from Database.sql import BASE, SESSION
-
-
-class KukiChats(BASE):
-    __tablename__ = "kuki_chats"
-    chat_id = Column(String(14), primary_key=True)
-
-    def __init__(self, chat_id):
-        self.chat_id = chat_id
-
-
-KukiChats.__table__.create(checkfirst=True)
-INSERTION_LOCK = threading.RLock()
-
-
-def is_kuki(chat_id):
-    try:
-        chat = SESSION.query(KukiChats).get(str(chat_id))
-        return bool(chat)
-    finally:
-        SESSION.close()
-
-
-def set_kuki(chat_id):
-    with INSERTION_LOCK:
-        kukichat = SESSION.query(KukiChats).get(str(chat_id))
-        if not kukichat:
-            kukichat = KukiChats(str(chat_id))
-        SESSION.add(kukichat)
-        SESSION.commit()
-
-
-def rem_kuki(chat_id):
-    with INSERTION_LOCK:
-        kukichat = SESSION.query(KukiChats).get(str(chat_id))
-        if kukichat:
-            SESSION.delete(kukichat)
-        SESSION.commit()

Database/sql/log_channel_sql.py

@@ -1,156 +0,0 @@
-import threading
-import typing
-
-from sqlalchemy import BigInteger, Boolean, Column, String, distinct, func
-
-from Database.sql import BASE, SESSION
-
-
-class GroupLogs(BASE):
-    __tablename__ = "log_channels"
-    chat_id = Column(String(14), primary_key=True)
-    log_channel = Column(String(14), nullable=False)
-
-    def __init__(self, chat_id, log_channel):
-        self.chat_id = str(chat_id)
-        self.log_channel = str(log_channel)
-
-
-class LogChannelSettings(BASE):
-    __tablename__ = "log_channel_setting"
-    chat_id = Column(BigInteger, primary_key=True)
-    log_joins = Column(Boolean, default=True)
-    log_leave = Column(Boolean, default=True)
-    log_warn = Column(Boolean, default=True)
-    log_action = Column(Boolean, default=True)
-    # log_media = Column(Boolean)
-    log_report = Column(Boolean, default=True)
-
-    def __init__(
-        self,
-        chat_id: int,
-        log_join: bool,
-        log_leave: bool,
-        log_warn: bool,
-        log_action: bool,
-        log_report: bool,
-    ):
-        self.chat_id = chat_id
-        self.log_warn = log_warn
-        self.log_joins = log_join
-        self.log_leave = log_leave
-        self.log_report = log_report
-        self.log_action = log_action
-
-    def toggle_warn(self) -> bool:
-        self.log_warn = not self.log_warn
-        SESSION.commit()
-        return self.log_warn
-
-    def toggle_joins(self) -> bool:
-        self.log_joins = not self.log_joins
-        SESSION.commit()
-        return self.log_joins
-
-    def toggle_leave(self) -> bool:
-        self.log_leave = not self.log_leave
-        SESSION.commit()
-        return self.log_leave
-
-    def toggle_report(self) -> bool:
-        self.log_report = not self.log_report
-        SESSION.commit()
-        return self.log_report
-
-    def toggle_action(self) -> bool:
-        self.log_action = not self.log_action
-        SESSION.commit()
-        return self.log_action
-
-
-GroupLogs.__table__.create(checkfirst=True)
-LogChannelSettings.__table__.create(checkfirst=True)
-
-LOGS_INSERTION_LOCK = threading.RLock()
-LOG_SETTING_LOCK = threading.RLock()
-CHANNELS = {}
-
-
-def get_chat_setting(chat_id: int) -> typing.Optional[LogChannelSettings]:
-    with LOG_SETTING_LOCK:
-        return SESSION.query(LogChannelSettings).get(chat_id)
-
-
-def set_chat_setting(setting: LogChannelSettings):
-    with LOGS_INSERTION_LOCK:
-        res: LogChannelSettings = SESSION.query(LogChannelSettings).get(setting.chat_id)
-        if res:
-            res.log_warn = setting.log_warn
-            res.log_action = setting.log_action
-            res.log_report = setting.log_report
-            res.log_joins = setting.log_joins
-            res.log_leave = setting.log_leave
-        else:
-            SESSION.add(setting)
-    SESSION.commit()
-
-
-def set_chat_log_channel(chat_id, log_channel):
-    with LOGS_INSERTION_LOCK:
-        res = SESSION.query(GroupLogs).get(str(chat_id))
-        if res:
-            res.log_channel = log_channel
-        else:
-            res = GroupLogs(chat_id, log_channel)
-            SESSION.add(res)
-
-        CHANNELS[str(chat_id)] = log_channel
-        SESSION.commit()
-
-
-def get_chat_log_channel(chat_id):
-    return CHANNELS.get(str(chat_id))
-
-
-def stop_chat_logging(chat_id):
-    with LOGS_INSERTION_LOCK:
-        res = SESSION.query(GroupLogs).get(str(chat_id))
-        if res:
-            if str(chat_id) in CHANNELS:
-                del CHANNELS[str(chat_id)]
-
-            log_channel = res.log_channel
-            SESSION.delete(res)
-            SESSION.commit()
-            return log_channel
-
-
-def num_logchannels():
-    try:
-        return SESSION.query(func.count(distinct(GroupLogs.chat_id))).scalar()
-    finally:
-        SESSION.close()
-
-
-def migrate_chat(old_chat_id, new_chat_id):
-    with LOGS_INSERTION_LOCK:
-        chat = SESSION.query(GroupLogs).get(str(old_chat_id))
-        if chat:
-            chat.chat_id = str(new_chat_id)
-            SESSION.add(chat)
-            if str(old_chat_id) in CHANNELS:
-                CHANNELS[str(new_chat_id)] = CHANNELS.get(str(old_chat_id))
-
-        SESSION.commit()
-
-
-def __load_log_channels():
-    global CHANNELS
-    try:
-        all_chats = SESSION.query(GroupLogs).all()
-        CHANNELS = {chat.chat_id: chat.log_channel for chat in all_chats}
-    finally:
-        SESSION.close()
-
-
-__load_log_channels()

Database/sql/notes_sql.py

@@ -1,187 +0,0 @@
-import threading
-
-from sqlalchemy import Boolean, Column, Integer, String, UnicodeText, distinct, func
-
-from Database.sql import BASE, SESSION
-from Mikobot.plugins.helper_funcs.msg_types import Types
-
-
-class Notes(BASE):
-    __tablename__ = "notes"
-    chat_id = Column(String(14), primary_key=True)
-    name = Column(UnicodeText, primary_key=True)
-    value = Column(UnicodeText, nullable=False)
-    file = Column(UnicodeText)
-    is_reply = Column(Boolean, default=False)
-    has_buttons = Column(Boolean, default=False)
-    msgtype = Column(Integer, default=Types.BUTTON_TEXT.value)
-
-    def __init__(self, chat_id, name, value, msgtype, file=None):
-        self.chat_id = str(chat_id)  # ensure string
-        self.name = name
-        self.value = value
-        self.msgtype = msgtype
-        self.file = file
-
-    def __repr__(self):
-        return "<Note %s>" % self.name
-
-
-class Buttons(BASE):
-    __tablename__ = "note_urls"
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    chat_id = Column(String(14), primary_key=True)
-    note_name = Column(UnicodeText, primary_key=True)
-    name = Column(UnicodeText, nullable=False)
-    url = Column(UnicodeText, nullable=False)
-    same_line = Column(Boolean, default=False)
-
-    def __init__(self, chat_id, note_name, name, url, same_line=False):
-        self.chat_id = str(chat_id)
-        self.note_name = note_name
-        self.name = name
-        self.url = url
-        self.same_line = same_line
-
-
-Notes.__table__.create(checkfirst=True)
-Buttons.__table__.create(checkfirst=True)
-
-NOTES_INSERTION_LOCK = threading.RLock()
-BUTTONS_INSERTION_LOCK = threading.RLock()
-
-
-def add_note_to_db(chat_id, note_name, note_data, msgtype, buttons=None, file=None):
-    if not buttons:
-        buttons = []
-
-    with NOTES_INSERTION_LOCK:
-        prev = SESSION.query(Notes).get((str(chat_id), note_name))
-        if prev:
-            with BUTTONS_INSERTION_LOCK:
-                prev_buttons = (
-                    SESSION.query(Buttons)
-                    .filter(
-                        Buttons.chat_id == str(chat_id),
-                        Buttons.note_name == note_name,
-                    )
-                    .all()
-                )
-                for btn in prev_buttons:
-                    SESSION.delete(btn)
-            SESSION.delete(prev)
-        note = Notes(
-            str(chat_id),
-            note_name,
-            note_data or "",
-            msgtype=msgtype.value,
-            file=file,
-        )
-        SESSION.add(note)
-        SESSION.commit()
-
-    for b_name, url, same_line in buttons:
-        add_note_button_to_db(chat_id, note_name, b_name, url, same_line)
-
-
-def get_note(chat_id, note_name):
-    try:
-        return (
-            SESSION.query(Notes)
-            .filter(func.lower(Notes.name) == note_name, Notes.chat_id == str(chat_id))
-            .first()
-        )
-    finally:
-        SESSION.close()
-
-
-def rm_note(chat_id, note_name):
-    with NOTES_INSERTION_LOCK:
-        note = (
-            SESSION.query(Notes)
-            .filter(func.lower(Notes.name) == note_name, Notes.chat_id == str(chat_id))
-            .first()
-        )
-        if note:
-            with BUTTONS_INSERTION_LOCK:
-                buttons = (
-                    SESSION.query(Buttons)
-                    .filter(
-                        Buttons.chat_id == str(chat_id),
-                        Buttons.note_name == note_name,
-                    )
-                    .all()
-                )
-                for btn in buttons:
-                    SESSION.delete(btn)
-
-            SESSION.delete(note)
-            SESSION.commit()
-            return True
-
-        else:
-            SESSION.close()
-            return False
-
-
-def get_all_chat_notes(chat_id):
-    try:
-        return (
-            SESSION.query(Notes)
-            .filter(Notes.chat_id == str(chat_id))
-            .order_by(Notes.name.asc())
-            .all()
-        )
-    finally:
-        SESSION.close()
-
-
-def add_note_button_to_db(chat_id, note_name, b_name, url, same_line):
-    with BUTTONS_INSERTION_LOCK:
-        button = Buttons(chat_id, note_name, b_name, url, same_line)
-        SESSION.add(button)
-        SESSION.commit()
-
-
-def get_buttons(chat_id, note_name):
-    try:
-        return (
-            SESSION.query(Buttons)
-            .filter(Buttons.chat_id == str(chat_id), Buttons.note_name == note_name)
-            .order_by(Buttons.id)
-            .all()
-        )
-    finally:
-        SESSION.close()
-
-
-def num_notes():
-    try:
-        return SESSION.query(Notes).count()
-    finally:
-        SESSION.close()
-
-
-def num_chats():
-    try:
-        return SESSION.query(func.count(distinct(Notes.chat_id))).scalar()
-    finally:
-        SESSION.close()
-
-
-def migrate_chat(old_chat_id, new_chat_id):
-    with NOTES_INSERTION_LOCK:
-        chat_notes = (
-            SESSION.query(Notes).filter(Notes.chat_id == str(old_chat_id)).all()
-        )
-        for note in chat_notes:
-            note.chat_id = str(new_chat_id)
-
-        with BUTTONS_INSERTION_LOCK:
-            chat_buttons = (
-                SESSION.query(Buttons).filter(Buttons.chat_id == str(old_chat_id)).all()
-            )
-            for btn in chat_buttons:
-                btn.chat_id = str(new_chat_id)
-
-        SESSION.commit()

Database/sql/rules_sql.py

@@ -1,58 +0,0 @@
-import threading
-
-from sqlalchemy import Column, String, UnicodeText, distinct, func
-
-from Database.sql import BASE, SESSION
-
-
-class Rules(BASE):
-    __tablename__ = "rules"
-    chat_id = Column(String(14), primary_key=True)
-    rules = Column(UnicodeText, default="")
-
-    def __init__(self, chat_id):
-        self.chat_id = chat_id
-
-    def __repr__(self):
-        return "<Chat {} rules: {}>".format(self.chat_id, self.rules)
-
-
-Rules.__table__.create(checkfirst=True)
-
-INSERTION_LOCK = threading.RLock()
-
-
-def set_rules(chat_id, rules_text):
-    with INSERTION_LOCK:
-        rules = SESSION.query(Rules).get(str(chat_id))
-        if not rules:
-            rules = Rules(str(chat_id))
-        rules.rules = rules_text
-
-        SESSION.add(rules)
-        SESSION.commit()
-
-
-def get_rules(chat_id):
-    rules = SESSION.query(Rules).get(str(chat_id))
-    ret = ""
-    if rules:
-        ret = rules.rules
-
-    SESSION.close()
-    return ret
-
-
-def num_chats():
-    try:
-        return SESSION.query(func.count(distinct(Rules.chat_id))).scalar()
-    finally:
-        SESSION.close()
-
-
-def migrate_chat(old_chat_id, new_chat_id):
-    with INSERTION_LOCK:
-        chat = SESSION.query(Rules).get(str(old_chat_id))
-        if chat:
-            chat.chat_id = str(new_chat_id)
-        SESSION.commit()

Database/sql/userinfo_sql.py

@@ -1,76 +0,0 @@
-import threading
-
-from sqlalchemy import BigInteger, Column, UnicodeText
-
-from Database.sql import BASE, SESSION
-
-
-class UserInfo(BASE):
-    __tablename__ = "userinfo"
-    user_id = Column(BigInteger, primary_key=True)
-    info = Column(UnicodeText)
-
-    def __init__(self, user_id, info):
-        self.user_id = user_id
-        self.info = info
-
-    def __repr__(self):
-        return "<User info %d>" % self.user_id
-
-
-class UserBio(BASE):
-    __tablename__ = "userbio"
-    user_id = Column(BigInteger, primary_key=True)
-    bio = Column(UnicodeText)
-
-    def __init__(self, user_id, bio):
-        self.user_id = user_id
-        self.bio = bio
-
-    def __repr__(self):
-        return "<User info %d>" % self.user_id
-
-
-UserInfo.__table__.create(checkfirst=True)
-UserBio.__table__.create(checkfirst=True)
-
-INSERTION_LOCK = threading.RLock()
-
-
-def get_user_me_info(user_id):
-    userinfo = SESSION.query(UserInfo).get(user_id)
-    SESSION.close()
-    if userinfo:
-        return userinfo.info
-    return None
-
-
-def set_user_me_info(user_id, info):
-    with INSERTION_LOCK:
-        userinfo = SESSION.query(UserInfo).get(user_id)
-        if userinfo:
-            userinfo.info = info
-        else:
-            userinfo = UserInfo(user_id, info)
-        SESSION.add(userinfo)
-        SESSION.commit()
-
-
-def get_user_bio(user_id):
-    userbio = SESSION.query(UserBio).get(user_id)
-    SESSION.close()
-    if userbio:
-        return userbio.bio
-    return None
-
-
-def set_user_bio(user_id, bio):
-    with INSERTION_LOCK:
-        userbio = SESSION.query(UserBio).get(user_id)
-        if userbio:
-            userbio.bio = bio
-        else:
-            userbio = UserBio(user_id, bio)
-
-        SESSION.add(userbio)
-        SESSION.commit()

Database/sql/users_sql.py

@@ -1,235 +0,0 @@
-import threading
-
-from sqlalchemy import (
-    BigInteger,
-    Column,
-    ForeignKey,
-    Integer,
-    String,
-    UnicodeText,
-    UniqueConstraint,
-    func,
-)
-
-from Database.sql import BASE, SESSION
-from Mikobot import dispatcher
-
-
-class Users(BASE):
-    __tablename__ = "users"
-    user_id = Column(BigInteger, primary_key=True)
-    username = Column(UnicodeText)
-
-    def __init__(self, user_id, username=None):
-        self.user_id = user_id
-        self.username = username
-
-    def __repr__(self):
-        return "<User {} ({})>".format(self.username, self.user_id)
-
-
-class Chats(BASE):
-    __tablename__ = "chats"
-    chat_id = Column(String(14), primary_key=True)
-    chat_name = Column(UnicodeText, nullable=False)
-
-    def __init__(self, chat_id, chat_name):
-        self.chat_id = str(chat_id)
-        self.chat_name = chat_name
-
-    def __repr__(self):
-        return "<Chat {} ({})>".format(self.chat_name, self.chat_id)
-
-
-class ChatMembers(BASE):
-    __tablename__ = "chat_members"
-    priv_chat_id = Column(Integer, primary_key=True)
-    # NOTE: Use dual primary key instead of private primary key?
-    chat = Column(
-        String(14),
-        ForeignKey("chats.chat_id", onupdate="CASCADE", ondelete="CASCADE"),
-        nullable=False,
-    )
-    user = Column(
-        BigInteger,
-        ForeignKey("users.user_id", onupdate="CASCADE", ondelete="CASCADE"),
-        nullable=False,
-    )
-    __table_args__ = (UniqueConstraint("chat", "user", name="_chat_members_uc"),)
-
-    def __init__(self, chat, user):
-        self.chat = chat
-        self.user = user
-
-    def __repr__(self):
-        return "<Chat user {} ({}) in chat {} ({})>".format(
-            self.user.username,
-            self.user.user_id,
-            self.chat.chat_name,
-            self.chat.chat_id,
-        )
-
-
-Users.__table__.create(checkfirst=True)
-Chats.__table__.create(checkfirst=True)
-ChatMembers.__table__.create(checkfirst=True)
-
-INSERTION_LOCK = threading.RLock()
-
-
-def ensure_bot_in_db():
-    with INSERTION_LOCK:
-        bot = Users(dispatcher.bot.id, dispatcher.bot.username)
-        SESSION.merge(bot)
-        SESSION.commit()
-
-
-def update_user(user_id, username, chat_id=None, chat_name=None):
-    with INSERTION_LOCK:
-        user = SESSION.query(Users).get(user_id)
-        if not user:
-            user = Users(user_id, username)
-            SESSION.add(user)
-            SESSION.flush()
-        else:
-            user.username = username
-
-        if not chat_id or not chat_name:
-            SESSION.commit()
-            return
-
-        chat = SESSION.query(Chats).get(str(chat_id))
-        if not chat:
-            chat = Chats(str(chat_id), chat_name)
-            SESSION.add(chat)
-            SESSION.flush()
-
-        else:
-            chat.chat_name = chat_name
-
-        member = (
-            SESSION.query(ChatMembers)
-            .filter(ChatMembers.chat == chat.chat_id, ChatMembers.user == user.user_id)
-            .first()
-        )
-        if not member:
-            chat_member = ChatMembers(chat.chat_id, user.user_id)
-            SESSION.add(chat_member)
-
-        SESSION.commit()
-
-
-def get_userid_by_name(username):
-    try:
-        return (
-            SESSION.query(Users)
-            .filter(func.lower(Users.username) == username.lower())
-            .all()
-        )
-    finally:
-        SESSION.close()
-
-
-def get_name_by_userid(user_id):
-    try:
-        return SESSION.query(Users).get(Users.user_id == int(user_id)).first()
-    finally:
-        SESSION.close()
-
-
-def get_chat_members(chat_id):
-    try:
-        return SESSION.query(ChatMembers).filter(ChatMembers.chat == str(chat_id)).all()
-    finally:
-        SESSION.close()
-
-
-def get_all_chats():
-    try:
-        return SESSION.query(Chats).all()
-    finally:
-        SESSION.close()
-
-
-def get_all_users():
-    try:
-        return SESSION.query(Users).all()
-    finally:
-        SESSION.close()
-
-
-def get_user_num_chats(user_id):
-    try:
-        return (
-            SESSION.query(ChatMembers).filter(ChatMembers.user == int(user_id)).count()
-        )
-    finally:
-        SESSION.close()
-
-
-def get_user_com_chats(user_id):
-    try:
-        chat_members = (
-            SESSION.query(ChatMembers).filter(ChatMembers.user == int(user_id)).all()
-        )
-        return [i.chat for i in chat_members]
-    finally:
-        SESSION.close()
-
-
-def num_chats():
-    try:
-        return SESSION.query(Chats).count()
-    finally:
-        SESSION.close()
-
-
-def num_users():
-    try:
-        return SESSION.query(Users).count()
-    finally:
-        SESSION.close()
-
-
-def migrate_chat(old_chat_id, new_chat_id):
-    with INSERTION_LOCK:
-        chat = SESSION.query(Chats).get(str(old_chat_id))
-        if chat:
-            chat.chat_id = str(new_chat_id)
-        SESSION.commit()
-
-        chat_members = (
-            SESSION.query(ChatMembers)
-            .filter(ChatMembers.chat == str(old_chat_id))
-            .all()
-        )
-        for member in chat_members:
-            member.chat = str(new_chat_id)
-        SESSION.commit()
-
-
-ensure_bot_in_db()
-
-
-def del_user(user_id):
-    with INSERTION_LOCK:
-        curr = SESSION.query(Users).get(user_id)
-        if curr:
-            SESSION.delete(curr)
-            SESSION.commit()
-            return True
-
-        ChatMembers.query.filter(ChatMembers.user == user_id).delete()
-        SESSION.commit()
-        SESSION.close()
-    return False
-
-
-def rem_chat(chat_id):
-    with INSERTION_LOCK:
-        chat = SESSION.query(Chats).get(str(chat_id))
-        if chat:
-            SESSION.delete(chat)
-            SESSION.commit()
-        else:
-            SESSION.close()

Database/sql/warns_sql.py

@@ -1,327 +0,0 @@
-import threading
-
-from sqlalchemy import (
-    BigInteger,
-    Boolean,
-    Column,
-    Integer,
-    String,
-    UnicodeText,
-    distinct,
-    func,
-)
-from sqlalchemy.dialects import postgresql
-
-from Database.sql import BASE, SESSION
-
-
-class Warns(BASE):
-    __tablename__ = "warns"
-
-    user_id = Column(BigInteger, primary_key=True)
-    chat_id = Column(String(14), primary_key=True)
-    num_warns = Column(Integer, default=0)
-    reasons = Column(postgresql.ARRAY(UnicodeText))
-
-    def __init__(self, user_id, chat_id):
-        self.user_id = user_id
-        self.chat_id = str(chat_id)
-        self.num_warns = 0
-        self.reasons = []
-
-    def __repr__(self):
-        return "<{} warns for {} in {} for reasons {}>".format(
-            self.num_warns,
-            self.user_id,
-            self.chat_id,
-            self.reasons,
-        )
-
-
-class WarnFilters(BASE):
-    __tablename__ = "warn_filters"
-    chat_id = Column(String(14), primary_key=True)
-    keyword = Column(UnicodeText, primary_key=True, nullable=False)
-    reply = Column(UnicodeText, nullable=False)
-
-    def __init__(self, chat_id, keyword, reply):
-        self.chat_id = str(chat_id)  # ensure string
-        self.keyword = keyword
-        self.reply = reply
-
-    def __repr__(self):
-        return "<Permissions for %s>" % self.chat_id
-
-    def __eq__(self, other):
-        return bool(
-            isinstance(other, WarnFilters)
-            and self.chat_id == other.chat_id
-            and self.keyword == other.keyword,
-        )
-
-
-class WarnSettings(BASE):
-    __tablename__ = "warn_settings"
-    chat_id = Column(String(14), primary_key=True)
-    warn_limit = Column(Integer, default=3)
-    soft_warn = Column(Boolean, default=False)
-
-    def __init__(self, chat_id, warn_limit=3, soft_warn=False):
-        self.chat_id = str(chat_id)
-        self.warn_limit = warn_limit
-        self.soft_warn = soft_warn
-
-    def __repr__(self):
-        return "<{} has {} possible warns.>".format(self.chat_id, self.warn_limit)
-
-
-Warns.__table__.create(checkfirst=True)
-WarnFilters.__table__.create(checkfirst=True)
-WarnSettings.__table__.create(checkfirst=True)
-
-WARN_INSERTION_LOCK = threading.RLock()
-WARN_FILTER_INSERTION_LOCK = threading.RLock()
-WARN_SETTINGS_LOCK = threading.RLock()
-
-WARN_FILTERS = {}
-
-
-def warn_user(user_id, chat_id, reason=None):
-    with WARN_INSERTION_LOCK:
-        warned_user = SESSION.query(Warns).get((user_id, str(chat_id)))
-        if not warned_user:
-            warned_user = Warns(user_id, str(chat_id))
-
-        warned_user.num_warns += 1
-        if reason:
-            warned_user.reasons = warned_user.reasons + [
-                reason,
-            ]  # TODO:: double check this wizardry
-
-        reasons = warned_user.reasons
-        num = warned_user.num_warns
-
-        SESSION.add(warned_user)
-        SESSION.commit()
-
-        return num, reasons
-
-
-def remove_warn(user_id, chat_id):
-    with WARN_INSERTION_LOCK:
-        removed = False
-        warned_user = SESSION.query(Warns).get((user_id, str(chat_id)))
-
-        if warned_user and warned_user.num_warns > 0:
-            warned_user.num_warns -= 1
-            warned_user.reasons = warned_user.reasons[:-1]
-            SESSION.add(warned_user)
-            SESSION.commit()
-            removed = True
-
-        SESSION.close()
-        return removed
-
-
-def reset_warns(user_id, chat_id):
-    with WARN_INSERTION_LOCK:
-        warned_user = SESSION.query(Warns).get((user_id, str(chat_id)))
-        if warned_user:
-            warned_user.num_warns = 0
-            warned_user.reasons = []
-
-            SESSION.add(warned_user)
-            SESSION.commit()
-        SESSION.close()
-
-
-def get_warns(user_id, chat_id):
-    try:
-        user = SESSION.query(Warns).get((user_id, str(chat_id)))
-        if not user:
-            return None
-        reasons = user.reasons
-        num = user.num_warns
-        return num, reasons
-    finally:
-        SESSION.close()
-
-
-def add_warn_filter(chat_id, keyword, reply):
-    with WARN_FILTER_INSERTION_LOCK:
-        warn_filt = WarnFilters(str(chat_id), keyword, reply)
-
-        if keyword not in WARN_FILTERS.get(str(chat_id), []):
-            WARN_FILTERS[str(chat_id)] = sorted(
-                WARN_FILTERS.get(str(chat_id), []) + [keyword],
-                key=lambda x: (-len(x), x),
-            )
-
-        SESSION.merge(warn_filt)  # merge to avoid duplicate key issues
-        SESSION.commit()
-
-
-def remove_warn_filter(chat_id, keyword):
-    with WARN_FILTER_INSERTION_LOCK:
-        warn_filt = SESSION.query(WarnFilters).get((str(chat_id), keyword))
-        if warn_filt:
-            if keyword in WARN_FILTERS.get(str(chat_id), []):  # sanity check
-                WARN_FILTERS.get(str(chat_id), []).remove(keyword)
-
-            SESSION.delete(warn_filt)
-            SESSION.commit()
-            return True
-        SESSION.close()
-        return False
-
-
-def get_chat_warn_triggers(chat_id):
-    return WARN_FILTERS.get(str(chat_id), set())
-
-
-def get_chat_warn_filters(chat_id):
-    try:
-        return (
-            SESSION.query(WarnFilters).filter(WarnFilters.chat_id == str(chat_id)).all()
-        )
-    finally:
-        SESSION.close()
-
-
-def get_warn_filter(chat_id, keyword):
-    try:
-        return SESSION.query(WarnFilters).get((str(chat_id), keyword))
-    finally:
-        SESSION.close()
-
-
-def set_warn_limit(chat_id, warn_limit):
-    with WARN_SETTINGS_LOCK:
-        curr_setting = SESSION.query(WarnSettings).get(str(chat_id))
-        if not curr_setting:
-            curr_setting = WarnSettings(chat_id, warn_limit=warn_limit)
-
-        curr_setting.warn_limit = warn_limit
-
-        SESSION.add(curr_setting)
-        SESSION.commit()
-
-
-def set_warn_strength(chat_id, soft_warn):
-    with WARN_SETTINGS_LOCK:
-        curr_setting = SESSION.query(WarnSettings).get(str(chat_id))
-        if not curr_setting:
-            curr_setting = WarnSettings(chat_id, soft_warn=soft_warn)
-
-        curr_setting.soft_warn = soft_warn
-
-        SESSION.add(curr_setting)
-        SESSION.commit()
-
-
-def get_warn_setting(chat_id):
-    try:
-        setting = SESSION.query(WarnSettings).get(str(chat_id))
-        if setting:
-            return setting.warn_limit, setting.soft_warn
-        else:
-            return 3, False
-
-    finally:
-        SESSION.close()
-
-
-def num_warns():
-    try:
-        return SESSION.query(func.sum(Warns.num_warns)).scalar() or 0
-    finally:
-        SESSION.close()
-
-
-def num_warn_chats():
-    try:
-        return SESSION.query(func.count(distinct(Warns.chat_id))).scalar()
-    finally:
-        SESSION.close()
-
-
-def num_warn_filters():
-    try:
-        return SESSION.query(WarnFilters).count()
-    finally:
-        SESSION.close()
-
-
-def num_warn_chat_filters(chat_id):
-    try:
-        return (
-            SESSION.query(WarnFilters.chat_id)
-            .filter(WarnFilters.chat_id == str(chat_id))
-            .count()
-        )
-    finally:
-        SESSION.close()
-
-
-def num_warn_filter_chats():
-    try:
-        return SESSION.query(func.count(distinct(WarnFilters.chat_id))).scalar()
-    finally:
-        SESSION.close()
-
-
-def __load_chat_warn_filters():
-    global WARN_FILTERS
-    try:
-        chats = SESSION.query(WarnFilters.chat_id).distinct().all()
-        for (chat_id,) in chats:  # remove tuple by ( ,)
-            WARN_FILTERS[chat_id] = []
-
-        all_filters = SESSION.query(WarnFilters).all()
-        for x in all_filters:
-            WARN_FILTERS[x.chat_id] += [x.keyword]
-
-        WARN_FILTERS = {
-            x: sorted(set(y), key=lambda i: (-len(i), i))
-            for x, y in WARN_FILTERS.items()
-        }
-
-    finally:
-        SESSION.close()
-
-
-def migrate_chat(old_chat_id, new_chat_id):
-    with WARN_INSERTION_LOCK:
-        chat_notes = (
-            SESSION.query(Warns).filter(Warns.chat_id == str(old_chat_id)).all()
-        )
-        for note in chat_notes:
-            note.chat_id = str(new_chat_id)
-        SESSION.commit()
-
-    with WARN_FILTER_INSERTION_LOCK:
-        chat_filters = (
-            SESSION.query(WarnFilters)
-            .filter(WarnFilters.chat_id == str(old_chat_id))
-            .all()
-        )
-        for filt in chat_filters:
-            filt.chat_id = str(new_chat_id)
-        SESSION.commit()
-        old_warn_filt = WARN_FILTERS.get(str(old_chat_id))
-        if old_warn_filt is not None:
-            WARN_FILTERS[str(new_chat_id)] = old_warn_filt
-            del WARN_FILTERS[str(old_chat_id)]
-
-    with WARN_SETTINGS_LOCK:
-        chat_settings = (
-            SESSION.query(WarnSettings)
-            .filter(WarnSettings.chat_id == str(old_chat_id))
-            .all()
-        )
-        for setting in chat_settings:
-            setting.chat_id = str(new_chat_id)
-        SESSION.commit()
-
-
-__load_chat_warn_filters()

Database/sql/welcome_sql.py

@@ -1,428 +0,0 @@
-import random
-import threading
-from typing import Union
-
-from sqlalchemy import BigInteger, Boolean, Column, Integer, String, UnicodeText
-
-from Database.sql import BASE, SESSION
-from Mikobot.plugins.helper_funcs.msg_types import Types
-
-DEFAULT_WELCOME = "Hey {first}, how are you?"
-DEFAULT_GOODBYE = "Nice knowing you!"
-
-DEFAULT_WELCOME_MESSAGES = [
-    "{first} is here!",  # Discord welcome messages copied
-    "Ready player {first}",
-    "Welcome bro {first}",
-]
-
-DEFAULT_GOODBYE_MESSAGES = [
-    "{first} will be missed.",
-    "{first} when back ?",
-]
-# Line 111 to 152 are references from https://bindingofisaac.fandom.com/wiki/Fortune_Telling_Machine
-
-
-class Welcome(BASE):
-    __tablename__ = "welcome_pref"
-    chat_id = Column(String(14), primary_key=True)
-    should_welcome = Column(Boolean, default=True)
-    should_goodbye = Column(Boolean, default=True)
-    custom_content = Column(UnicodeText, default=None)
-
-    custom_welcome = Column(
-        UnicodeText,
-        default=random.choice(DEFAULT_WELCOME_MESSAGES),
-    )
-    welcome_type = Column(Integer, default=Types.TEXT.value)
-
-    custom_leave = Column(UnicodeText, default=random.choice(DEFAULT_GOODBYE_MESSAGES))
-    leave_type = Column(Integer, default=Types.TEXT.value)
-
-    clean_welcome = Column(BigInteger)
-
-    def __init__(self, chat_id, should_welcome=True, should_goodbye=True):
-        self.chat_id = chat_id
-        self.should_welcome = should_welcome
-        self.should_goodbye = should_goodbye
-
-    def __repr__(self):
-        return "<Chat {} should Welcome new users: {}>".format(
-            self.chat_id,
-            self.should_welcome,
-        )
-
-
-class WelcomeButtons(BASE):
-    __tablename__ = "welcome_urls"
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    chat_id = Column(String(14), primary_key=True)
-    name = Column(UnicodeText, nullable=False)
-    url = Column(UnicodeText, nullable=False)
-    same_line = Column(Boolean, default=False)
-
-    def __init__(self, chat_id, name, url, same_line=False):
-        self.chat_id = str(chat_id)
-        self.name = name
-        self.url = url
-        self.same_line = same_line
-
-
-class GoodbyeButtons(BASE):
-    __tablename__ = "leave_urls"
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    chat_id = Column(String(14), primary_key=True)
-    name = Column(UnicodeText, nullable=False)
-    url = Column(UnicodeText, nullable=False)
-    same_line = Column(Boolean, default=False)
-
-    def __init__(self, chat_id, name, url, same_line=False):
-        self.chat_id = str(chat_id)
-        self.name = name
-        self.url = url
-        self.same_line = same_line
-
-
-class WelcomeMute(BASE):
-    __tablename__ = "welcome_mutes"
-    chat_id = Column(String(14), primary_key=True)
-    welcomemutes = Column(UnicodeText, default=False)
-
-    def __init__(self, chat_id, welcomemutes):
-        self.chat_id = str(chat_id)  # ensure string
-        self.welcomemutes = welcomemutes
-
-
-class WelcomeMuteUsers(BASE):
-    __tablename__ = "human_checks"
-    user_id = Column(BigInteger, primary_key=True)
-    chat_id = Column(String(14), primary_key=True)
-    human_check = Column(Boolean)
-
-    def __init__(self, user_id, chat_id, human_check):
-        self.user_id = user_id  # ensure string
-        self.chat_id = str(chat_id)
-        self.human_check = human_check
-
-
-class CleanServiceSetting(BASE):
-    __tablename__ = "clean_service"
-    chat_id = Column(String(14), primary_key=True)
-    clean_service = Column(Boolean, default=True)
-
-    def __init__(self, chat_id):
-        self.chat_id = str(chat_id)
-
-    def __repr__(self):
-        return "<Chat used clean service ({})>".format(self.chat_id)
-
-
-Welcome.__table__.create(checkfirst=True)
-WelcomeButtons.__table__.create(checkfirst=True)
-GoodbyeButtons.__table__.create(checkfirst=True)
-WelcomeMute.__table__.create(checkfirst=True)
-WelcomeMuteUsers.__table__.create(checkfirst=True)
-CleanServiceSetting.__table__.create(checkfirst=True)
-
-INSERTION_LOCK = threading.RLock()
-WELC_BTN_LOCK = threading.RLock()
-LEAVE_BTN_LOCK = threading.RLock()
-WM_LOCK = threading.RLock()
-CS_LOCK = threading.RLock()
-
-
-def welcome_mutes(chat_id):
-    try:
-        welcomemutes = SESSION.query(WelcomeMute).get(str(chat_id))
-        if welcomemutes:
-            return welcomemutes.welcomemutes
-        return False
-    finally:
-        SESSION.close()
-
-
-def set_welcome_mutes(chat_id, welcomemutes):
-    with WM_LOCK:
-        prev = SESSION.query(WelcomeMute).get((str(chat_id)))
-        if prev:
-            SESSION.delete(prev)
-        welcome_m = WelcomeMute(str(chat_id), welcomemutes)
-        SESSION.add(welcome_m)
-        SESSION.commit()
-
-
-def set_human_checks(user_id, chat_id):
-    with INSERTION_LOCK:
-        human_check = SESSION.query(WelcomeMuteUsers).get((user_id, str(chat_id)))
-        if not human_check:
-            human_check = WelcomeMuteUsers(user_id, str(chat_id), True)
-
-        else:
-            human_check.human_check = True
-
-        SESSION.add(human_check)
-        SESSION.commit()
-
-        return human_check
-
-
-def get_human_checks(user_id, chat_id):
-    try:
-        human_check = SESSION.query(WelcomeMuteUsers).get((user_id, str(chat_id)))
-        if not human_check:
-            return None
-        human_check = human_check.human_check
-        return human_check
-    finally:
-        SESSION.close()
-
-
-def get_welc_mutes_pref(chat_id):
-    welcomemutes = SESSION.query(WelcomeMute).get(str(chat_id))
-    SESSION.close()
-
-    if welcomemutes:
-        return welcomemutes.welcomemutes
-
-    return False
-
-
-def get_welc_pref(chat_id):
-    welc = SESSION.query(Welcome).get(str(chat_id))
-    SESSION.close()
-    if welc:
-        return (
-            welc.should_welcome,
-            welc.custom_welcome,
-            welc.custom_content,
-            welc.welcome_type,
-        )
-
-    else:
-        # Welcome by default.
-        return True, DEFAULT_WELCOME, None, Types.TEXT
-
-
-def get_gdbye_pref(chat_id):
-    welc = SESSION.query(Welcome).get(str(chat_id))
-    SESSION.close()
-    if welc:
-        return welc.should_goodbye, welc.custom_leave, welc.leave_type
-    else:
-        # Welcome by default.
-        return True, DEFAULT_GOODBYE, Types.TEXT
-
-
-def set_clean_welcome(chat_id, clean_welcome):
-    with INSERTION_LOCK:
-        curr = SESSION.query(Welcome).get(str(chat_id))
-        if not curr:
-            curr = Welcome(str(chat_id))
-
-        curr.clean_welcome = int(clean_welcome)
-
-        SESSION.add(curr)
-        SESSION.commit()
-
-
-def get_clean_pref(chat_id):
-    welc = SESSION.query(Welcome).get(str(chat_id))
-    SESSION.close()
-
-    if welc:
-        return welc.clean_welcome
-
-    return False
-
-
-def set_welc_preference(chat_id, should_welcome):
-    with INSERTION_LOCK:
-        curr = SESSION.query(Welcome).get(str(chat_id))
-        if not curr:
-            curr = Welcome(str(chat_id), should_welcome=should_welcome)
-        else:
-            curr.should_welcome = should_welcome
-
-        SESSION.add(curr)
-        SESSION.commit()
-
-
-def set_gdbye_preference(chat_id, should_goodbye):
-    with INSERTION_LOCK:
-        curr = SESSION.query(Welcome).get(str(chat_id))
-        if not curr:
-            curr = Welcome(str(chat_id), should_goodbye=should_goodbye)
-        else:
-            curr.should_goodbye = should_goodbye
-
-        SESSION.add(curr)
-        SESSION.commit()
-
-
-def set_custom_welcome(
-    chat_id,
-    custom_content,
-    custom_welcome,
-    welcome_type,
-    buttons=None,
-):
-    if buttons is None:
-        buttons = []
-
-    with INSERTION_LOCK:
-        welcome_settings = SESSION.query(Welcome).get(str(chat_id))
-        if not welcome_settings:
-            welcome_settings = Welcome(str(chat_id), True)
-
-        if custom_welcome or custom_content:
-            welcome_settings.custom_content = custom_content
-            welcome_settings.custom_welcome = custom_welcome
-            welcome_settings.welcome_type = welcome_type.value
-
-        else:
-            welcome_settings.custom_welcome = DEFAULT_WELCOME
-            welcome_settings.welcome_type = Types.TEXT.value
-
-        SESSION.add(welcome_settings)
-
-        with WELC_BTN_LOCK:
-            prev_buttons = (
-                SESSION.query(WelcomeButtons)
-                .filter(WelcomeButtons.chat_id == str(chat_id))
-                .all()
-            )
-            for btn in prev_buttons:
-                SESSION.delete(btn)
-
-            for b_name, url, same_line in buttons:
-                button = WelcomeButtons(chat_id, b_name, url, same_line)
-                SESSION.add(button)
-
-        SESSION.commit()
-
-
-def get_custom_welcome(chat_id):
-    welcome_settings = SESSION.query(Welcome).get(str(chat_id))
-    ret = DEFAULT_WELCOME
-    if welcome_settings and welcome_settings.custom_welcome:
-        ret = welcome_settings.custom_welcome
-
-    SESSION.close()
-    return ret
-
-
-def set_custom_gdbye(chat_id, custom_goodbye, goodbye_type, buttons=None):
-    if buttons is None:
-        buttons = []
-
-    with INSERTION_LOCK:
-        welcome_settings = SESSION.query(Welcome).get(str(chat_id))
-        if not welcome_settings:
-            welcome_settings = Welcome(str(chat_id), True)
-
-        if custom_goodbye:
-            welcome_settings.custom_leave = custom_goodbye
-            welcome_settings.leave_type = goodbye_type.value
-
-        else:
-            welcome_settings.custom_leave = DEFAULT_GOODBYE
-            welcome_settings.leave_type = Types.TEXT.value
-
-        SESSION.add(welcome_settings)
-
-        with LEAVE_BTN_LOCK:
-            prev_buttons = (
-                SESSION.query(GoodbyeButtons)
-                .filter(GoodbyeButtons.chat_id == str(chat_id))
-                .all()
-            )
-            for btn in prev_buttons:
-                SESSION.delete(btn)
-
-            for b_name, url, same_line in buttons:
-                button = GoodbyeButtons(chat_id, b_name, url, same_line)
-                SESSION.add(button)
-
-        SESSION.commit()
-
-
-def get_custom_gdbye(chat_id):
-    welcome_settings = SESSION.query(Welcome).get(str(chat_id))
-    ret = DEFAULT_GOODBYE
-    if welcome_settings and welcome_settings.custom_leave:
-        ret = welcome_settings.custom_leave
-
-    SESSION.close()
-    return ret
-
-
-def get_welc_buttons(chat_id):
-    try:
-        return (
-            SESSION.query(WelcomeButtons)
-            .filter(WelcomeButtons.chat_id == str(chat_id))
-            .order_by(WelcomeButtons.id)
-            .all()
-        )
-    finally:
-        SESSION.close()
-
-
-def get_gdbye_buttons(chat_id):
-    try:
-        return (
-            SESSION.query(GoodbyeButtons)
-            .filter(GoodbyeButtons.chat_id == str(chat_id))
-            .order_by(GoodbyeButtons.id)
-            .all()
-        )
-    finally:
-        SESSION.close()
-
-
-def clean_service(chat_id: Union[str, int]) -> bool:
-    try:
-        chat_setting = SESSION.query(CleanServiceSetting).get(str(chat_id))
-        if chat_setting:
-            return chat_setting.clean_service
-        return False
-    finally:
-        SESSION.close()
-
-
-def set_clean_service(chat_id: Union[int, str], setting: bool):
-    with CS_LOCK:
-        chat_setting = SESSION.query(CleanServiceSetting).get(str(chat_id))
-        if not chat_setting:
-            chat_setting = CleanServiceSetting(chat_id)
-
-        chat_setting.clean_service = setting
-        SESSION.add(chat_setting)
-        SESSION.commit()
-
-
-def migrate_chat(old_chat_id, new_chat_id):
-    with INSERTION_LOCK:
-        chat = SESSION.query(Welcome).get(str(old_chat_id))
-        if chat:
-            chat.chat_id = str(new_chat_id)
-
-        with WELC_BTN_LOCK:
-            chat_buttons = (
-                SESSION.query(WelcomeButtons)
-                .filter(WelcomeButtons.chat_id == str(old_chat_id))
-                .all()
-            )
-            for btn in chat_buttons:
-                btn.chat_id = str(new_chat_id)
-
-        with LEAVE_BTN_LOCK:
-            chat_buttons = (
-                SESSION.query(GoodbyeButtons)
-                .filter(GoodbyeButtons.chat_id == str(old_chat_id))
-                .all()
-            )
-            for btn in chat_buttons:
-                btn.chat_id = str(new_chat_id)
-
-        SESSION.commit()