Upload 8 files

database/admin_group.py

@@ -0,0 +1,31 @@
+import pymongo
+from info import DATABASE_URI, DATABASE_NAME
+import logging
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.ERROR)
+
+myclient = pymongo.MongoClient(DATABASE_URI)
+mydb = myclient[DATABASE_NAME]
+
+
+async def add_admingroup(group_id, template):
+    mycol = mydb["templatedb"]
+    mydict = {"group_id": str(group_id), "template": str(template)}
+
+    try:
+        x = mycol.insert_one(mydict)
+    except Exception:
+        logger.exception('Some error occured!', exc_info=True)
+
+
+async def remove_admingroup(group_id):
+    mycol = mydb["templatedb"]
+    myquery = {"group_id": str(group_id)}
+    mycol.delete_one(myquery)
+
+
+async def get_admingroup(group_id):
+    mycol = mydb["templatedb"]
+    myquery = {"group_id": str(group_id), }
+    mydoc = mycol.find(myquery)
+    return mydoc[0]

database/connections_mdb.py

@@ -0,0 +1,133 @@
+import pymongo
+
+from info import DATABASE_URI, DATABASE_NAME
+
+import logging
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.ERROR)
+
+myclient = pymongo.MongoClient(DATABASE_URI)
+mydb = myclient[DATABASE_NAME]
+mycol = mydb['CONNECTION']
+
+
+async def add_connection(group_id, user_id):
+    query = mycol.find_one(
+        {"_id": user_id},
+        {"_id": 0, "active_group": 0}
+    )
+    if query is not None:
+        group_ids = [x["group_id"] for x in query["group_details"]]
+        if group_id in group_ids:
+            return False
+
+    group_details = {
+        "group_id": group_id
+    }
+
+    data = {
+        '_id': user_id,
+        'group_details': [group_details],
+        'active_group': group_id,
+    }
+
+    if mycol.count_documents({"_id": user_id}) == 0:
+        try:
+            mycol.insert_one(data)
+            return True
+        except Exception:
+            logger.exception('Some error occurred!', exc_info=True)
+
+    else:
+        try:
+            mycol.update_one(
+                {'_id': user_id},
+                {
+                    "$push": {"group_details": group_details},
+                    "$set": {"active_group": group_id}
+                }
+            )
+            return True
+        except Exception:
+            logger.exception('Some error occurred!', exc_info=True)
+
+
+async def active_connection(user_id):
+
+    query = mycol.find_one(
+        {"_id": user_id},
+        {"_id": 0, "group_details": 0}
+    )
+    if not query:
+        return None
+
+    group_id = query['active_group']
+    return int(group_id) if group_id != None else None
+
+
+async def all_connections(user_id):
+    query = mycol.find_one(
+        {"_id": user_id},
+        {"_id": 0, "active_group": 0}
+    )
+    if query is not None:
+        return [x["group_id"] for x in query["group_details"]]
+    else:
+        return None
+
+
+async def if_active(user_id, group_id):
+    query = mycol.find_one(
+        {"_id": user_id},
+        {"_id": 0, "group_details": 0}
+    )
+    return query is not None and query['active_group'] == group_id
+
+
+async def make_active(user_id, group_id):
+    update = mycol.update_one(
+        {'_id': user_id},
+        {"$set": {"active_group": group_id}}
+    )
+    return update.modified_count != 0
+
+
+async def make_inactive(user_id):
+    update = mycol.update_one(
+        {'_id': user_id},
+        {"$set": {"active_group": None}}
+    )
+    return update.modified_count != 0
+
+
+async def delete_connection(user_id, group_id):
+
+    try:
+        update = mycol.update_one(
+            {"_id": user_id},
+            {"$pull": {"group_details": {"group_id": group_id}}}
+        )
+        if update.modified_count == 0:
+            return False
+        query = mycol.find_one(
+            {"_id": user_id},
+            {"_id": 0}
+        )
+        if len(query["group_details"]) >= 1:
+            if query['active_group'] == group_id:
+                prvs_group_id = query["group_details"][len(
+                    query["group_details"]) - 1]["group_id"]
+
+                mycol.update_one(
+                    {'_id': user_id},
+                    {"$set": {"active_group": prvs_group_id}}
+                )
+        else:
+            mycol.update_one(
+                {'_id': user_id},
+                {"$set": {"active_group": None}}
+            )
+        return True
+    except Exception as e:
+        logger.exception(f'Some error occurred! {e}', exc_info=True)
+        return False

database/filters_mdb.py

@@ -0,0 +1,107 @@
+import pymongo
+from info import DATABASE_URI, DATABASE_NAME
+import logging
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.ERROR)
+
+myclient = pymongo.MongoClient(DATABASE_URI)
+mydb = myclient[DATABASE_NAME]
+
+
+async def add_filter(grp_id, text, reply_text, btn, file, alert):
+    mycol = mydb[str(grp_id)]
+    # mycol.create_index([('text', 'text')])
+
+    data = {
+        'text': str(text),
+        'reply': str(reply_text),
+        'btn': str(btn),
+        'file': str(file),
+        'alert': str(alert)
+    }
+
+    try:
+        mycol.update_one({'text': str(text)},  {"$set": data}, upsert=True)
+    except Exception:
+        logger.exception('Some error occured!', exc_info=True)
+
+
+async def find_filter(group_id, name):
+    mycol = mydb[str(group_id)]
+    query = mycol.find({"text": name})
+    try:
+        for file in query:
+            reply_text = file['reply']
+            btn = file['btn']
+            fileid = file['file']
+            try:
+                alert = file['alert']
+            except Exception:
+                alert = None
+        return reply_text, btn, alert, fileid
+    except Exception:
+        return None, None, None, None
+
+
+async def get_filters(group_id):
+    mycol = mydb[str(group_id)]
+    texts = []
+    query = mycol.find()
+    try:
+        texts.extend(file['text'] for file in query)
+    except Exception:
+        pass
+    return texts
+
+
+async def delete_filter(message, text, group_id):
+    mycol = mydb[str(group_id)]
+
+    myquery = {'text': text}
+    query = mycol.count_documents(myquery)
+    if query == 1:
+        mycol.delete_one(myquery)
+        await message.reply_text(
+            f"'`{text}`'  deleted. I'll not respond to that filter anymore.",
+            quote=True,
+            parse_mode="md"
+        )
+    else:
+        await message.reply_text("Couldn't find that filter!", quote=True)
+
+
+async def del_all(message, group_id, title):
+    if str(group_id) not in mydb.list_collection_names():
+        await message.edit_text(f"Nothing to remove in {title}!")
+        return
+    mycol = mydb[str(group_id)]
+    try:
+        mycol.drop()
+        await message.edit_text(f"All filters from {title} has been removed")
+    except Exception:
+        await message.edit_text("Couldn't remove all filters from group!")
+        return
+
+
+async def count_filters(group_id):
+    mycol = mydb[str(group_id)]
+
+    count = mycol.count()
+    return False if count == 0 else count
+
+
+async def filter_stats():
+    collections = mydb.list_collection_names()
+
+    if "CONNECTION" in collections:
+        collections.remove("CONNECTION")
+
+    totalcount = 0
+    for collection in collections:
+        mycol = mydb[collection]
+        count = mycol.count()
+        totalcount += count
+
+    totalcollections = len(collections)
+
+    return totalcollections, totalcount

database/ia_filterdb.py

@@ -0,0 +1,141 @@
+import logging
+from struct import pack
+import re
+import base64
+from pyrogram.file_id import FileId
+from pymongo.errors import DuplicateKeyError
+from umongo import Instance, Document, fields
+from motor.motor_asyncio import AsyncIOMotorClient
+from marshmallow.exceptions import ValidationError
+from info import DATABASE_URI, DATABASE_NAME, COLLECTION_NAME, USE_CAPTION_FILTER
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+client = AsyncIOMotorClient(DATABASE_URI)
+db = client[DATABASE_NAME]
+instance = Instance.from_db(db)
+
+
+@instance.register
+class Media(Document):
+    file_id = fields.StrField(attribute='_id')
+    file_ref = fields.StrField(allow_none=True)
+    file_name = fields.StrField(required=True)
+    file_size = fields.IntField(required=True)
+    file_type = fields.StrField(allow_none=True)
+    mime_type = fields.StrField(allow_none=True)
+    caption = fields.StrField(allow_none=True)
+
+    class Meta:
+        indexes = ('$file_name', )
+        collection_name = COLLECTION_NAME
+
+
+async def save_file(media):
+    """Save file in database"""
+
+    # TODO: Find better way to get same file_id for same media to avoid duplicates
+    file_id, file_ref = unpack_new_file_id(media.file_id)
+    file_name = re.sub(r"(_|\-|\.|\+)", " ", str(media.file_name))
+    try:
+        file = Media(
+            file_id=file_id,
+            file_ref=file_ref,
+            file_name=file_name,
+            file_size=media.file_size,
+            file_type=media.file_type,
+            mime_type=media.mime_type,
+            caption=media.caption.html if media.caption else None,
+        )
+    except ValidationError:
+        logger.exception('Error occurred while saving file in database')
+        return False, 2
+    else:
+        try:
+            await file.commit()
+        except DuplicateKeyError:
+            logger.warning(
+                f'{getattr(media, "file_name", "NO_FILE")} is already saved in database'
+            )
+
+            return False, 0
+        else:
+            logger.info(
+                f'{getattr(media, "file_name", "NO_FILE")} is saved to database')
+            return True, 1
+
+
+async def get_search_results(query, file_type=None, max_results=10, offset=0, filter=False):
+    # sourcery skip: avoid-builtin-shadow
+    """For given query return (results, next_offset)"""
+    query = query.strip()
+    if not query:
+        raw_pattern = '.'
+    elif ' ' not in query:
+        raw_pattern = '(\b|[\.\+\-_])' + query + '(\b|[\.\+\-_])'
+    else:
+        raw_pattern = query.replace(' ', '.*[\s\.\+\-_]')
+    try:
+        regex = re.compile(raw_pattern, flags=re.IGNORECASE)
+    except Exception:
+        return []
+    if USE_CAPTION_FILTER:
+        filter = {'$or': [{'file_name': regex}, {'caption': regex}]}
+    else:
+        filter = {'file_name': regex}
+    if file_type:
+        filter['file_type'] = file_type
+    total_results = await Media.count_documents(filter)
+    next_offset = offset + max_results
+    if next_offset > total_results:
+        next_offset = ''
+    cursor = Media.find(filter)
+    cursor.sort('$natural', -1)
+    cursor.skip(offset).limit(max_results)
+    files = await cursor.to_list(length=max_results)
+    return files, next_offset, total_results
+
+
+async def get_file_details(query):  # sourcery skip: avoid-builtin-shadow
+    filter = {'file_id': query}
+    cursor = Media.find(filter)
+    return await cursor.to_list(length=1)
+
+
+def encode_file_id(s: bytes) -> str:
+    r = b""
+    n = 0
+
+    for i in s + bytes([22]) + bytes([4]):
+        if i == 0:
+            n += 1
+        else:
+            if n:
+                r += b"\x00" + bytes([n])
+                n = 0
+
+            r += bytes([i])
+
+    return base64.urlsafe_b64encode(r).decode().rstrip("=")
+
+
+def encode_file_ref(file_ref: bytes) -> str:
+    return base64.urlsafe_b64encode(file_ref).decode().rstrip("=")
+
+
+def unpack_new_file_id(new_file_id):
+    """Return file_id, file_ref"""
+    decoded = FileId.decode(new_file_id)
+    file_id = encode_file_id(
+        pack(
+            "<iiqq",
+            int(decoded.file_type),
+            decoded.dc_id,
+            decoded.media_id,
+            decoded.access_hash
+        )
+    )
+    file_ref = encode_file_ref(decoded.file_reference)
+    return file_id, file_ref

database/notification.py

@@ -0,0 +1,47 @@
+import pymongo
+from info import DATABASE_URI, DATABASE_NAME
+import logging
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.ERROR)
+
+myclient = pymongo.MongoClient(DATABASE_URI)
+mydb = myclient[DATABASE_NAME]
+
+
+async def add_notification(userId, stats):
+    mycol = mydb["notification"]
+    mydict = {"userId": str(userId), "stats": str(stats)}
+
+    try:
+        mycol.insert_one(mydict)
+    except Exception:
+        logger.exception('Some error occured!', exc_info=True)
+
+
+async def update_notification(userId, stats):
+    mycol = mydb["notification"]
+    filter = {'userId': str(userId)}
+    newvalues = {"$set": {"stats": str(stats)}}
+    try:
+        mycol.update_one(filter, newvalues)
+    except Exception:
+        logger.exception('Some error occured!', exc_info=True)
+
+
+async def remove_notification(userId):
+    mycol = mydb["notification"]
+    myquery = {'userId': str(userId)}
+    mycol.delete_one(myquery)
+
+
+async def find_allusers():
+    mycol = mydb["notification"]
+    return [x["userId"] for x in mycol.find()]
+
+
+async def find_notification(userId):
+    mycol = mydb["notification"]
+    myquery = {"userId": str(userId)}
+    mydoc = mycol.find(myquery)
+    for x in mydoc:
+        return x

database/quickdb.py

@@ -0,0 +1,100 @@
+import pymongo
+from info import DATABASE_URI, DATABASE_NAME
+import logging
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.ERROR)
+
+myclient = pymongo.MongoClient(DATABASE_URI)
+mydb = myclient[DATABASE_NAME]
+
+
+async def add_inst_filter(fileid, links):
+    mycol = mydb["quickdb"]
+    mydict = {"fileid": str(fileid), "links": str(links)}
+
+    try:
+        x = mycol.insert_one(mydict)
+    except:
+        logger.exception('Some error occured!', exc_info=True)
+
+
+async def remove_inst(fileid):
+    mycol = mydb["quickdb"]
+    myquery = {"fileid": str(fileid)}
+    mycol.delete_one(myquery)
+
+
+async def get_ids(fileid):
+    mycol = mydb["quickdb"]
+    myquery = {"fileid": str(fileid)}
+    mydoc = mycol.find(myquery)
+    for x in mydoc:
+        return x
+
+
+async def get(id):
+    mycol = mydb["quickdb"]
+    for x in mycol.find():
+        return x
+
+
+async def add_sent_files(userid, fileid):
+    mycol = mydb["sentfiledb"]
+    mydict = {"fileid": str(fileid), "userid": str(userid)}
+
+    try:
+        x = mycol.insert_one(mydict)
+    except:
+        logger.exception('Some error occured!', exc_info=True)
+
+
+async def count_sent_files():
+    mycol = mydb["sentfiledb"]
+    return mycol.count()
+
+
+async def add_verification(user_id, stats, file_id, updat_time):
+    mycol = mydb["verification"]
+    mydict = {"userId": str(user_id), "stats": str(
+        stats), "file": str(file_id), "updat_time": str(updat_time)}
+
+    try:
+        x = mycol.insert_one(mydict)
+    except Exception:
+        logger.exception('Some error occured!', exc_info=True)
+
+
+async def remove_verification(user_id):
+    mycol = mydb["verification"]
+    myquery = {"userId": str(user_id)}
+    mycol.delete_one(myquery)
+
+
+async def get_verification(user_id):
+    mycol = mydb["verification"]
+    myquery = {"userId": str(user_id)}
+    mydoc = mycol.find(myquery)
+    for user_dic in mydoc:
+        return user_dic
+
+
+async def add_update_msg(total_users, files):
+    mycol = mydb["updatemsg"]
+    mydict = {"totalUsers": str(
+        total_users), "files": str(files)}
+
+    try:
+        x = mycol.insert_one(mydict)
+    except Exception:
+        logger.exception('Some error occured!', exc_info=True)
+
+
+async def remove_update_msg():
+    mycol = mydb["updatemsg"]
+    mycol.delete_many({})
+
+
+async def get_update_msg():
+    mycol = mydb["updatemsg"]
+    for x in mycol.find():
+        return x

database/tvseriesfilters.py

@@ -0,0 +1,54 @@
+import pymongo
+from info import DATABASE_URI, DATABASE_NAME
+import logging
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.ERROR)
+
+myclient = pymongo.MongoClient(DATABASE_URI)
+mydb = myclient[DATABASE_NAME]
+
+
+async def add_tvseries_filter(name, language, quality, seasonlink):
+    mycol = mydb["tvseries"]
+    mydict = {"name": str(name), "language": str(
+        language), "quality": str(quality), "seasonlink": str(seasonlink)}
+
+    try:
+        mycol.insert_one(mydict)
+    except Exception:
+        logger.exception('Some error occured!', exc_info=True)
+
+
+async def update_tvseries_filter(name, language, quality, seasonlink):
+    mycol = mydb["tvseries"]
+    filter = {'name': str(name)}
+    newvalues = {"$set": {"language": str(language), "quality": str(
+        quality), "seasonlink": str(seasonlink)}}
+
+    try:
+        mycol.update_one(filter, newvalues)
+    except Exception:
+        logger.exception('Some error occured!', exc_info=True)
+
+
+async def remove_tvseries(name):
+    mycol = mydb["tvseries"]
+    myquery = {'name': str(name)}
+    mycol.delete_one(myquery)
+
+
+async def getlinks():
+    mycol = mydb["tvseries"]
+    return list(mycol.find())
+
+
+async def find_tvseries_filter(name):
+    mycol = mydb["tvseries"]
+    return list(mycol.find({'name': {'$regex': f'^{name}'}}))
+
+
+async def find_tvseries_by_first(letter):
+    mycol = mydb["tvseries"]
+    return list(mycol.find({'name': {'$regex': f'^{letter}'}}))
+
+# https://www.w3schools.com/python/python_mongodb_query.asp

database/users_chats_db.py

@@ -0,0 +1,122 @@
+# https://github.com/odysseusmax/animated-lamp/blob/master/bot/database/database.py
+import motor.motor_asyncio
+from info import DATABASE_NAME, DATABASE_URI, IMDB, IMDB_TEMPLATE, MELCOW_NEW_USERS, P_TTI_SHOW_OFF, SINGLE_BUTTON, SPELL_CHECK_REPLY, PROTECT_CONTENT
+
+
+class Database:
+
+    def __init__(self, uri, database_name):
+        self._client = motor.motor_asyncio.AsyncIOMotorClient(uri)
+        self.db = self._client[database_name]
+        self.col = self.db.users
+        self.grp = self.db.groups
+
+    def new_user(self, id, name):
+        return dict(
+            id=id,
+            name=name,
+            ban_status=dict(
+                is_banned=False,
+                ban_reason="",
+            ),
+        )
+
+    def new_group(self, id, title):
+        return dict(
+            id=id,
+            title=title,
+            chat_status=dict(
+                is_disabled=False,
+                reason="",
+            ),
+        )
+
+    async def add_user(self, id, name):
+        user = self.new_user(id, name)
+        await self.col.insert_one(user)
+
+    async def is_user_exist(self, id):
+        user = await self.col.find_one({'id': int(id)})
+        return bool(user)
+
+    async def total_users_count(self):
+        return await self.col.count_documents({})
+
+    async def remove_ban(self, id):
+        ban_status = dict(
+            is_banned=False,
+            ban_reason=''
+        )
+        await self.col.update_one({'id': id}, {'$set': {'ban_status': ban_status}})
+
+    async def ban_user(self, user_id, ban_reason="No Reason"):
+        ban_status = dict(
+            is_banned=True,
+            ban_reason=ban_reason
+        )
+        await self.col.update_one({'id': user_id}, {'$set': {'ban_status': ban_status}})
+
+    async def get_ban_status(self, id):
+        default = dict(
+            is_banned=False,
+            ban_reason=''
+        )
+        user = await self.col.find_one({'id': int(id)})
+        return user.get('ban_status', default) if user else default
+
+    async def get_all_users(self):
+        return self.col.find({})
+
+    async def delete_user(self, user_id):
+        await self.col.delete_many({'id': int(user_id)})
+
+    async def get_banned(self):
+        users = self.col.find({'ban_status.is_banned': True})
+        chats = self.grp.find({'chat_status.is_disabled': True})
+        b_chats = [chat['id'] async for chat in chats]
+        b_users = [user['id'] async for user in users]
+        return b_users, b_chats
+
+    async def add_chat(self, chat, title):
+        chat = self.new_group(chat, title)
+        await self.grp.insert_one(chat)
+
+    async def get_chat(self, chat):
+        chat = await self.grp.find_one({'id': int(chat)})
+        return chat.get('chat_status') if chat else False
+
+    async def re_enable_chat(self, id):
+        chat_status = dict(
+            is_disabled=False,
+            reason="",
+        )
+        await self.grp.update_one({'id': int(id)}, {'$set': {'chat_status': chat_status}})
+
+    async def update_settings(self, id, settings):
+        await self.grp.update_one({'id': int(id)}, {'$set': {'settings': settings}})
+
+    async def get_settings(self, id):
+        default = {'button': SINGLE_BUTTON, 'botpm': P_TTI_SHOW_OFF, 'file_secure': PROTECT_CONTENT,
+                   'imdb': IMDB, 'spell_check': SPELL_CHECK_REPLY, 'welcome': MELCOW_NEW_USERS, 'template': IMDB_TEMPLATE}
+
+        chat = await self.grp.find_one({'id': int(id)})
+        return chat.get('settings', default) if chat else default
+
+    async def disable_chat(self, chat, reason="No Reason"):
+        chat_status = dict(
+            is_disabled=True,
+            reason=reason,
+        )
+        await self.grp.update_one({'id': int(chat)}, {'$set': {'chat_status': chat_status}})
+
+    async def total_chat_count(self):
+        return await self.grp.count_documents({})
+
+    async def get_all_chats(self):
+        return self.grp.find({})
+
+    async def get_db_size(self):
+        return (await self.db.command("dbstats"))['dataSize']
+
+
+db = Database(DATABASE_URI, DATABASE_NAME)