Upload main.py

main.py

@@ -47,7 +47,7 @@ from typing_extensions import Annotated
 from typing import Annotated, Union
 from typing import Optional, List, Dict, Any
 
-from pydantic import BaseModel
+from pydantic import BaseModel, EmailStr
 from base64 import b64decode as kc
 from base64 import b64decode
 from random import choice
@@ -59,6 +59,7 @@ from serpapi import GoogleSearch
 
 from fastapi import FastAPI, UploadFile, File, Response, Request
 from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from fastapi.security import APIKeyHeader
 from fastapi import Depends, HTTPException, status
 from fastapi.openapi.utils import get_openapi
 from fastapi.responses import StreamingResponse, JSONResponse, FileResponse
@@ -67,6 +68,11 @@ from fastapi import Request, Header
 from fastapi import Body, Query
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
+from fastapi import FastAPI, HTTPException
+
+from cryptography.fernet import Fernet
+from motor.motor_asyncio import AsyncIOMotorClient
+from datetime import datetime, timedelta
 
 from starlette.responses import RedirectResponse
 from starlette.staticfiles import StaticFiles
@@ -139,9 +145,9 @@ COOKIE_BARD_TOKEN = os.environ["COOKIE_BARD_TOKEN"]
 MONITOR_API_KEYS = os.environ["MONITOR_API_KEYS"]
 PICSART_API_KEY = os.environ["PICSART_API_KEY"]
 
-client_mongo = MongoClient(MONGO_URL)
-db = client_mongo["tiktokbot"]
-collection = db["users"]
+client = AsyncIOMotorClient(MONGO_URL)
+db = client['tiktokbot']
+collection = db['users']
 
 trans = SyncTranslator()
 
@@ -191,8 +197,8 @@ class FedBans(BaseModel):
 class GetsaFedBans(BaseModel):
     user_id: int
 
-def get_all_api_keys():
-    user = collection.find({})
+async def get_all_api_keys():
+    user = await collection.find({})
     api_keys = []
     for x in user:
         api_key = x.get("ryuzaki_api_key")
@@ -200,8 +206,8 @@ def get_all_api_keys():
             api_keys.append(api_key)
     return api_keys
 
-def get_all_fedbans_api_keys():
-    user = collection.find({})
+async def get_all_fedbans_api_keys():
+    user = await collection.find({})
     api_keys = []
     for x in user:
         api_key = x.get("fedbans_api_key")
@@ -209,8 +215,8 @@ def get_all_fedbans_api_keys():
             api_keys.append(api_key)
     return api_keys
 
-def validate_api_key(api_key: str = Header(...)):
-    USERS_API_KEYS = get_all_api_keys()
+async def validate_api_key(api_key: str = Header(...)):
+    USERS_API_KEYS = await get_all_api_keys()
     if api_key not in USERS_API_KEYS:
         raise HTTPException(status_code=401, detail="Invalid API key")
 
@@ -218,8 +224,8 @@ def validate_api_key_only_devs(api_key: str = Header(...)):
     if api_key not in ONLY_DEVELOPER_API_KEYS:
         raise HTTPException(status_code=401, detail="Invalid API key")
 
-def validate_api_key_fedbans(api_key: str = Header(...)):
-    USERS_API_KEYS = get_all_fedbans_api_keys()
+async def validate_api_key_fedbans(api_key: str = Header(...)):
+    USERS_API_KEYS = await get_all_fedbans_api_keys()
     if api_key not in USERS_API_KEYS:
         raise HTTPException(status_code=401, detail="Invalid API key")
 
@@ -227,6 +233,50 @@ def secs_to_mins(secs: int) -> str:
     mins, secs = divmod(secs, 60)
     return f"{mins}:{secs}"
 
+api_key_header = APIKeyHeader(name="api_key", auto_error=False)
+
+async def validate_api_key_porno(api_key: Optional[str] = Depends(api_key_header)) -> str:
+    if api_key is None:
+        raise HTTPException(status_code=403, detail="API key required")
+    user = await collection.find_one({"username": api_key, "blocked": False})
+    if not user:
+        raise HTTPException(status_code=403, detail="Invalid or blocked API key")
+    return api_key
+
+class RegistrationModel(BaseModel):
+    gmail: EmailStr
+    api_key: str
+    expiration_days: int = 3
+
+key = Fernet.generate_key()
+cipher_suite = Fernet(key)
+
+def encrypt_key(api_key: str) -> str:
+    encrypted_key = cipher_suite.encrypt(api_key.encode())
+    return encrypted_key.decode()
+
+@app.get("/some-endpoint")
+async def some_endpoint(api_key: str = Depends(validate_api_key_porno)):
+    return {"message": "Access granted"}
+
+@app.post("/register")
+async def register_user(data: RegistrationModel):
+    encrypted_key = encrypt_key(data.api_key)
+    current_time = datetime.utcnow()
+    expiration_time = current_time + timedelta(days=data.expiration_days)
+    result = await collection.insert_one({
+        "username": data.api_key,
+        "gmail": data.gmail,
+        "key": encrypted_key,
+        "blocked": False,
+        "created_at": current_time,
+        "expires_at": expiration_time
+    })
+    if result.inserted_id:
+        return {"message": f"User {data.api_key} registered successfully"}
+    else:
+        raise HTTPException(status_code=500, detail="Registration failed")
+
 @app.get("/akeno/youtube-search", response_model=SuccessResponse, responses={422: {"model": SuccessResponse}})
 async def youtube_search(payload: YouTubeSearch):
     try:
@@ -573,7 +623,7 @@ async def pinterestv2(query: str):
         )
 
 @app.get("/akeno/pornpics", response_model=SuccessResponse, responses={422: {"model": SuccessResponse}})
-async def pornpics(query: str):
+async def pornpics(query: str, api_key: str = Depends(validate_api_key_porno)):
     try:
         response = await search_porn_images(query)
         return SuccessResponse(
@@ -587,7 +637,7 @@ async def pornpics(query: str):
         )
 
 @app.get("/akeno/pornowhite", response_model=SuccessResponse, responses={422: {"model": SuccessResponse}})
-async def pornowhite_(query: str):
+async def pornowhite_(query: str, api_key: str = Depends(validate_api_key_porno)):
     try:
         response = search_pornwhite_videos(query)
         return SuccessResponse(
@@ -615,7 +665,7 @@ async def happymods_(q: str):
         )
 
 @app.get("/akeno/hentai", response_model=SuccessResponse, responses={422: {"model": SuccessResponse}})
-async def hentai_():
+async def hentai_(api_key: str = Depends(validate_api_key_porno)):
     try:
         response = await HentaiAnime()
         return SuccessResponse(
@@ -725,7 +775,7 @@ async def tiktokdl_(link: str):
         )
 
 @app.get("/akeno/xnxxsearch", response_model=SuccessResponse, responses={422: {"model": SuccessResponse}})
-async def xnxx_search(query: str, quality: str):
+async def xnxx_search(query: str, quality: str, api_key: str = Depends(validate_api_key_porno)):
     data_dict = {
         "720p": search_filters.SearchingQuality.X_720p,
         "1080p": search_filters.SearchingQuality.X_1080p_plus
@@ -771,7 +821,7 @@ async def xnxx_search(query: str, quality: str):
 
 
 @app.get("/akeno/xnxx-dl", response_model=SuccessResponse, responses={422: {"model": SuccessResponse}})
-async def xnxx_download(link: str):
+async def xnxx_download(link: str, api_key: str = Depends(validate_api_key_porno)):
     try:
         x = xnxx_client()
         response = x.get_video(link)
@@ -852,7 +902,7 @@ RAMDOM_STATUS = [
     "spammer",
 ]
 
-def remove_sibyl_system_banned(user_id):
+async def remove_sibyl_system_banned(user_id):
     update_doc = {
         "sibyl_ban": None,
         "reason_sibyl": None,
@@ -860,9 +910,9 @@ def remove_sibyl_system_banned(user_id):
         "date_joined_sib": None,
         "sibyl_userid": None
     }
-    return collection.update_one({"user_id": user_id}, {"$unset": update_doc}, upsert=True)
+    return await collection.update_one({"user_id": user_id}, {"$unset": update_doc}, upsert=True)
 
-def new_user_spammers(
+async def new_user_spammers(
     user_id,
     hashtag,
     reason,
@@ -876,9 +926,9 @@ def new_user_spammers(
         "date_joined": date_joined,
         "is_banned": is_banned
     }
-    return collection.update_one({"user_id": user_id}, {"$set": update_doc}, upsert=True)
+    return await collection.update_one({"user_id": user_id}, {"$set": update_doc}, upsert=True)
 
-def new_sibyl_system_banned(user_id, name, reason, date_joined):
+async def new_sibyl_system_banned(user_id, name, reason, date_joined):
     update_doc = {
         "sibyl_ban": name,
         "reason_sibyl": reason,
@@ -886,14 +936,14 @@ def new_sibyl_system_banned(user_id, name, reason, date_joined):
         "date_joined_sib": date_joined,
         "sibyl_userid": user_id
     }
-    return collection.update_one({"user_id": user_id}, {"$set": update_doc}, upsert=True)
+    return await collection.update_one({"user_id": user_id}, {"$set": update_doc}, upsert=True)
 
-def cybersecuritydb(user_id, mongo_url):
+async def cybersecuritydb(user_id, mongo_url):
     update_doc = {"mongodb": mongo_url}
-    return collection.update_one({"user_id": user_id}, {"$set": update_doc}, upsert=True)
+    return await collection.update_one({"user_id": user_id}, {"$set": update_doc}, upsert=True)
 
-def get_sibyl_system_banned(user_id):
-    user = collection.find_one({"user_id": user_id})
+async def get_sibyl_system_banned(user_id):
+    user = await collection.find_one({"user_id": user_id})
     if user:
         sibyl_name = user.get("sibyl_ban")
         reason = user.get("reason_sibyl")
@@ -904,8 +954,8 @@ def get_sibyl_system_banned(user_id):
     else:
         return None
 
-def get_fedbans_(user_id):
-    user = collection.find_one({"user_id": user_id})
+async def get_fedbans_(user_id):
+    user = await collection.find_one({"user_id": user_id})
     if user:
         user_id = user.get("user_id")
         hashtag = user.get("hashtag")
@@ -922,10 +972,10 @@ def get_fedbans_(user_id):
     else:
         return None
 
-def get_all_banned():
+async def get_all_banned():
     banned_users = []
 
-    users = collection.find({})
+    users = await collection.find({})
 
     for user_id in users:
         reason = user_id.get("reason_sibyl")
@@ -933,7 +983,7 @@ def get_all_banned():
         banned_users.append({"user_id": user_id, "reason": reason})
     return banned_users
 
-def new_profile_clone(
+async def new_profile_clone(
     user_id,
     first_name,
     last_name=None,
@@ -946,10 +996,10 @@ def new_profile_clone(
         "profile_id": profile_id,
         "bio": bio
     }
-    collection.update_one({"user_id": user_id}, {"$set": update_doc}, upsert=True)
+    await collection.update_one({"user_id": user_id}, {"$set": update_doc}, upsert=True)
 
-def get_profile_clone(user_id):
-    user = collection.find_one({"user_id": user_id})
+async def get_profile_clone(user_id):
+    user = await collection.find_one({"user_id": user_id})
     if user:
         first_name = user.get("first_name")
         last_name = user.get("last_name")
@@ -959,7 +1009,7 @@ def get_profile_clone(user_id):
     else:
         return None
 
-def new_verify_otp(
+async def new_verify_otp(
     user_id,
     otp_code,
     ip_addres,
@@ -971,11 +1021,10 @@ def new_verify_otp(
         "ip_addres": ip_addres,
         "auth_status": auth_status,
     }
-    collection.update_one({"user_id": user_id}, {"$set": update_doc}, upsert=True)
+    await collection.update_one({"user_id": user_id}, {"$set": update_doc}, upsert=True)
 
-
-def get_stored_otp(user_id: int):
-    user = collection.find_one({"user_id": user_id})
+async def get_stored_otp(user_id: int):
+    user = await collection.find_one({"user_id": user_id})
     if user and "otp_code" in user:
         return user["otp_code"]
     return None       
@@ -990,10 +1039,10 @@ class OTPCallbackPayload(BaseModel):
     user_id: int
 
 @app.get("/api/get-verify", response_model=SuccessResponse, responses={422: {"model": SuccessResponse}})
-def get_verify_otp(user_id: int, request: Request):
+async def get_verify_otp(user_id: int, request: Request):
     try:
         client_host = request.client.host
-        get_otp_code = get_stored_otp(user_id)
+        get_otp_code = await get_stored_otp(user_id)
         if get_otp_code:
             return SuccessResponse(
                 status="True",
@@ -1019,11 +1068,11 @@ def get_verify_otp(user_id: int, request: Request):
         )
         
 @app.post("/api/verify", response_model=SuccessResponse, responses={422: {"model": SuccessResponse}})
-def verify_otp(payload: OTPCallbackPayload, request: Request):
+async def verify_otp(payload: OTPCallbackPayload, request: Request):
     try:
         client_host = request.client.host
         otp = generate_otp()
-        new_verify_otp(
+        await new_verify_otp(
             payload.user_id,
             otp,
             ip_addres=client_host,
@@ -1050,12 +1099,12 @@ def verify_otp(payload: OTPCallbackPayload, request: Request):
         )
 
 @app.post("/ryuzaki/profile-clone", response_model=SuccessResponse, responses={422: {"model": SuccessResponse}})
-def profile_clone(
+async def profile_clone(
     item: ProfileClone,
     api_key: None = Depends(validate_api_key)
 ):
     try:
-        new_profile_clone(
+        await new_profile_clone(
             user_id=item.user_id,
             first_name=item.first_name,
             last_name=item.last_name,
@@ -1076,12 +1125,12 @@ def profile_clone(
         return SuccessResponse(status="False", randydev={"message": "Internal server error."})
 
 @app.get("/ryuzaki/get-profile-clone", response_model=SuccessResponse, responses={422: {"model": SuccessResponse}})
-def get_profile_(
+async def get_profile_(
     item: GetProfileClone,
     api_key: None = Depends(validate_api_key)
 ):
     try:
-        response = get_profile_clone(item.user_id)
+        response = await get_profile_clone(item.user_id)
         if response[0]:
             return SuccessResponse(
                 status="True",
@@ -1102,8 +1151,8 @@ def get_profile_(
         return SuccessResponse(status="False", randydev={"message": "Internal server error."})
 
 @app.get("/ryuzaki/getbanlist")
-def sibyl_get_all_banlist():
-    banned_users = get_all_banned()
+async def sibyl_get_all_banlist():
+    banned_users = await get_all_banned()
     return {
         "status": "True",
         "randydev": {
@@ -1121,15 +1170,15 @@ def blacklist_words():
         return {"status": "false", "message": f"Internal server error: {str(e)}"}
 
 @app.delete("/ryuzaki/sibyldel", response_model=SuccessResponse, responses={422: {"model": SuccessResponse}})
-def sibyl_system_delete(
+async def sibyl_system_delete(
     item: SibylSystemDel,
     api_key: None = Depends(validate_api_key_only_devs)
 ):
     try:
-        _, _, _, _, sibyl_user_id = get_sibyl_system_banned(item.user_id)
+        _, _, _, _, sibyl_user_id = await get_sibyl_system_banned(item.user_id)
 
         if sibyl_user_id:
-            remove_sibyl_system_banned(item.user_id)
+            await remove_sibyl_system_banned(item.user_id)
             return SuccessResponse(
                 status="True",
                 randydev={"message": f"Successfully removed {item.user_id} from the Sibyl ban list"}
@@ -1143,8 +1192,8 @@ def sibyl_system_delete(
         return SuccessResponse(status="False", randydev={"message": "Internal server error."})
 
 @app.get("/user/get-fedban", response_model=SuccessResponse, responses={422: {"model": SuccessResponse}})
-def getfedbans_(payload: GetsaFedBans, api_key: str = Depends(validate_api_key_fedbans)):
-    users_bans = get_fedbans_(payload.user_id)
+async def getfedbans_(payload: GetsaFedBans, api_key: str = Depends(validate_api_key_fedbans)):
+    users_bans = await get_fedbans_(payload.user_id)
     try:
         if users_bans[3] == True:
             return SuccessResponse(
@@ -1180,7 +1229,7 @@ def getfedbans_(payload: GetsaFedBans, api_key: str = Depends(validate_api_key_f
         ) 
 
 @app.post("/user/fedban", response_model=SuccessResponse, responses={422: {"model": SuccessResponse}})
-def fedbans_(payload: FedBans, api_key: str = Depends(validate_api_key_fedbans)):
+async def fedbans_(payload: FedBans, api_key: str = Depends(validate_api_key_fedbans)):
     if payload.user_id == 1191668125:
         return SuccessResponse(status="False", randydev={"message": "Only Developer."})
 
@@ -1188,7 +1237,7 @@ def fedbans_(payload: FedBans, api_key: str = Depends(validate_api_key_fedbans))
     if not payload.hashtag.startswith("#"):
         return SuccessResponse(status="False", randydev={"message": "Invalid hashtag."})
     try:
-        new_user_spammers(
+        await new_user_spammers(
             user_id=payload.user_id,
             hashtag=payload.hashtag,
             reason=payload.reason,
@@ -1220,9 +1269,8 @@ def fedbans_(payload: FedBans, api_key: str = Depends(validate_api_key_fedbans))
             }
         )
 
-
 @app.post("/ryuzaki/sibylban", response_model=SuccessResponse, responses={422: {"model": SuccessResponse}})
-def sibyl_system_ban(
+async def sibyl_system_ban(
     item: SibylSystemBan,
     api_key: None = Depends(validate_api_key)
 ):
@@ -1232,11 +1280,11 @@ def sibyl_system_ban(
     try:
         date_joined = str(dt.now())
         sibyl_ban = random.choice(RAMDOM_STATUS)
-        _, _, is_banned, _, sibyl_user_id = get_sibyl_system_banned(item.user_id)
+        _, _, is_banned, _, sibyl_user_id = await get_sibyl_system_banned(item.user_id)
 
         if sibyl_user_id is not None and is_banned:
             return SuccessResponse(status="False", randydev={"message": "User is already banned."})
-        new_sibyl_system_banned(item.user_id, sibyl_ban, item.reason, date_joined)
+        await new_sibyl_system_banned(item.user_id, sibyl_ban, item.reason, date_joined)
         return SuccessResponse(
             status="True",
             randydev={
@@ -1251,11 +1299,11 @@ def sibyl_system_ban(
         return SuccessResponse(status="False", randydev={"message": "Internal server error."})
 
 @app.get("/ryuzaki/sibyl", response_model=SuccessResponse, responses={422: {"model": SuccessResponse}})
-def sibyl_system(
+async def sibyl_system(
     item: SibylSystem,
     api_key: None = Depends(validate_api_key)
 ):
-    sibyl_result = get_sibyl_system_banned(item.user_id)
+    sibyl_result = await get_sibyl_system_banned(item.user_id)
     if sibyl_result:
         sibyl_name, reason, is_banned, date_joined, sibyl_user_id = sibyl_result
         return SuccessResponse(
@@ -1697,7 +1745,7 @@ def gemini_pro(item: GeminiPro):
                 mongo_url=item.mongo_url,
                 user_id=item.user_id
             )
-            cybersecuritydb(item.user_id, item.mongo_url)
+            await cybersecuritydb(item.user_id, item.mongo_url)
             answer, gemini_chat = geni._GeminiLatest__get_response_gemini(item.query)
             return SuccessResponse(
                 status="True",