uploading

Dockerfile

@@ -0,0 +1,38 @@
+# Use Python 3.11 slim image
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    git \
+    curl \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the entire application
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p /app/logs
+
+# Expose port
+EXPOSE 8080
+
+# Set environment variables
+ENV PYTHONPATH=/app
+ENV PORT=8080
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8080/ || exit 1
+
+# Run the application
+CMD ["python", "-m", "OneApi"] 

OneApi/__init__.py

@@ -0,0 +1,50 @@
+from motor.motor_asyncio import AsyncIOMotorClient
+from pymongo import MongoClient
+import logging
+from variables import *
+import os
+from quart import Quart
+from pyrogram import *
+from variables import *
+import asyncio
+
+logging.basicConfig(
+  format="[OneApi] %(name)s - %(levelname)s - %(message)s",
+  handlers=[logging.FileHandler("log.txt"), logging.StreamHandler()],
+  level=logging.INFO,
+)
+
+MONGO_DB_URI = os.environ.get("MONGO_DB_URL") or VAR_MONGO_DB_URI
+API_ID = os.environ.get("API_ID") or VAR_API_ID
+API_HASH = os.environ.get("API_HASH") or VAR_API_HASH
+HANDLER = ["/"]
+TOKEN = os.environ.get("TOKEN") or VAR_TOKEN
+MY_VERSION = 0.1
+DEVS = os.environ.get("DEVS") or VAR_DEVS
+# _______________________________________
+if not API_ID or not API_HASH or not TOKEN or not MONGO_DB_URI:
+  raise ValueError("Bro thought he can run anything lol, i mean you forgot some vars put on variables.py")
+  exit()
+# _-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_-_+_|
+if len(TOKEN) > 50: bot = Client("OneApi", session_string=TOKEN, api_id=API_ID, api_hash=API_HASH, plugins=dict(root="OneApi/pyro"))
+else: bot = Client("OneApi", bot_token=TOKEN, api_id=API_ID, api_hash=API_HASH, plugins=dict(root="OneApi/pyro"))
+# ———— R U N ——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
+async def run(command):
+  try:
+    process = await asyncio.create_subprocess_shell(
+      command,
+      stdout=asyncio.subprocess.PIPE,
+      stderr=asyncio.subprocess.PIPE,
+      start_new_session=True
+    )
+    stdout, stderr = await process.communicate()
+    if stdout:
+      return stdout.decode().strip()
+    if stderr:
+      return stderr.decode().strip()
+  except Exception as e:
+    logging.error(f"Failed to run command '{command}': {e}")
+    return False
+# _______________________________________________________________
+DATABASE = AsyncIOMotorClient(MONGO_DB_URI)["OneApi"]
+app = Quart(__name__)

OneApi/__main__.py

@@ -0,0 +1,42 @@
+from quart_cors import cors
+from quart import *
+import asyncio
+import os
+from . import *
+
+# BLUEPRINTS _____________________
+from .api.exists import exists_bp
+from .api.create_user import create_user_bp
+from .api.get_projects import get_projects_bp
+from .api.create_project import create_project_bp 
+from .api.delete_project import delete_project_bp
+from .api.user_info import user_info_bp
+from .api.get_repos import get_repos_bp
+from .api.delete_user import delete_user_bp
+from .api.disconnect_git import disconnect_git_bp
+from .api.set_repo import set_repo_bp
+from .api.project_info import project_info_bp
+from .api.host import host_bp
+
+app.register_blueprint(exists_bp)
+app.register_blueprint(create_user_bp)
+app.register_blueprint(get_projects_bp)
+app.register_blueprint(create_project_bp)
+app.register_blueprint(delete_project_bp)
+app.register_blueprint(user_info_bp)
+app.register_blueprint(get_repos_bp)
+app.register_blueprint(delete_user_bp)
+app.register_blueprint(disconnect_git_bp)
+app.register_blueprint(set_repo_bp)
+app.register_blueprint(project_info_bp)
+app.register_blueprint(host_bp)
+# ---------------------------------
+
+app = cors(app, allow_origin="*")
+
+@app.route('/')
+async def home():
+    return jsonify({'success': 'server online'}), 200
+
+if __name__ == '__main__':
+    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))

OneApi/api/create_project.py

@@ -0,0 +1,22 @@
+from ..database import *
+from quart import *
+from .. import *
+
+user = user()
+create_project_bp = Blueprint('create_project', __name__)
+
+@app.route('/create_project/', methods=['POST'])
+async def create_project():
+  data = await request.get_json()
+  if not data or not 'user_id' in data and not 'name' in data and not 'plan' in data:
+    return jsonify({'error': 'missing user_id or name'}), 400
+  user_id = int(data.get('user_id'))
+  name = data.get('name')
+  plan = data.get('plan')
+  mano = await user.create_project(name, user_id, plan)
+  if mano == 'ok':
+    return jsonify({'message': 'Successfully created'}), 200
+  elif 'Error' in mano:
+    return jsonify({'error': mano}), 400
+  else:
+    return jsonify({'message': mano}), 400

OneApi/api/create_user.py

@@ -0,0 +1,22 @@
+from ..database import *
+from quart import *
+from .. import *
+
+user = user()
+create_user_bp = Blueprint('create_user', __name__)
+
+@app.route('/create_user/', methods=['POST'])
+async def create_user():
+  data = await request.get_json()
+  if not data or not 'user_id' in data and not 'name' in data: return jsonify({'error': 'missing user_id & name'}), 400
+  user_id = int(data.get('user_id'))
+  name = data.get('name')
+  d = await user.create(name, user_id)
+  if d == 'exists': 
+    return jsonify({'message': "user exists"}), 400
+  elif 'Error' in str(d): 
+    return jsonify({'error': d}), 400
+  elif d =='ok':
+    return jsonify({'message': 'done'}), 200
+  elif d == "Not connected":
+    return jsonify({'message': 'The user is not connected with GitHub app.'}), 400

OneApi/api/delete_project.py

@@ -0,0 +1,21 @@
+from ..database import *
+from quart import *
+from .. import *
+
+user = user()
+delete_project_bp = Blueprint('delete_project', __name__)
+
+@app.route('/delete_project/', methods=['POST'])
+async def delete_project():
+  data = await request.get_json()
+  if not data or not 'user_id' in data and not 'project_id' in data:
+    return jsonify({'error': 'missing user_id or project_id'}), 400
+  user_id = int(data.get('user_id'))
+  project_id = int(data.get('project_id'))
+  mano = await user.delete_project(user_id, project_id)
+  if mano == 'Project not found' or mano == 'not exists':
+    return jsonify({'message': mano}), 404
+  elif 'Error' in mano:
+    return jsonify({'error': mano}), 400
+  elif 'ok' in mano:
+    return jsonify({'message': mano}), 200

OneApi/api/delete_user.py

@@ -0,0 +1,17 @@
+from ..database import *
+from quart import *
+from .. import *
+
+user = user()
+delete_user_bp = Blueprint('delete_user', __name__)
+
+@app.route('/delete_user/', methods=['POST'])
+async def delete_user():
+  data = await request.get_json()
+  if not data or not 'user_id' in data: return jsonify({'error': 'missing user_id'}), 400
+  user_id = int(data.get('user_id'))
+  d = await user.delete_user(user_id)
+  if d is True:
+    return jsonify({"message": "Successfully deleted user!"}), 200
+  elif "Error" in d:
+    return jsonify({"error": d}), 400

OneApi/api/disconnect_git.py

@@ -0,0 +1,18 @@
+from ..database import *
+from quart import *
+from .. import *
+import logging 
+
+user = user()
+disconnect_git_bp = Blueprint('disconnect_git', __name__)
+
+@app.route('/disconnect_git/', methods=['POST'])
+async def disconnect_git():
+  data = await request.get_json()
+  if not data or not 'user_id' in data: return jsonify({'error': 'missing user_id'}), 400
+  user_id = int(data.get('user_id'))
+  mano = await user.disconnect_git(user_id)
+  if mano is True:
+    return jsonify({"message": "Successfully disconnected git"}), 200
+  elif 'Error' in mano:
+    return jsonify({'error': mano}), 400

OneApi/api/exists.py

@@ -0,0 +1,19 @@
+from ..database import *
+from quart import *
+from .. import *
+import logging 
+
+user = user()
+exists_bp = Blueprint('exists', __name__)
+
+@app.route('/exists/', methods=['POST'])
+async def exists():
+  data = await request.get_json()
+  if not data or not 'user_id' in data: return jsonify({'error': 'missing user_id'}), 400
+  user_id = int(data.get('user_id'))
+  
+  d = await user.find(user_id, check=True)
+  if d: return jsonify({'message': 'user exists'}), 200
+  elif not d: return jsonify({'message': "user not found"}), 404
+  elif 'Error' in d: return jsonify({'error': d}), 400
+  else: logging.info(d)

OneApi/api/get_projects.py

@@ -0,0 +1,18 @@
+from ..database import *
+from quart import *
+from .. import *
+
+user = user()
+get_projects_bp = Blueprint('get_projects', __name__)
+
+@app.route('/get_projects/', methods=['POST'])
+async def get_projects():
+  data = await request.get_json()
+  if not data or not 'user_id' in data: return jsonify({'error': 'missing user_id'}), 400
+  user_id = int(data.get('user_id'))
+  ohk = await user.get_projects(user_id)
+  if ohk == "projects not found" or ohk == "not exists":
+    return jsonify({"message": ohk}), 404
+  elif 'Error' in ohk:
+    return jsonify({"error": ohk}), 400
+  return jsonify({"message": ohk}), 200

OneApi/api/get_repos.py

@@ -0,0 +1,21 @@
+from ..database import *
+from quart import *
+from .. import *
+
+user = user()
+get_repos_bp = Blueprint('get_repos', __name__)
+
+@app.route('/get_repos/', methods=['POST'])
+async def get_repos():
+  data = await request.get_json()
+  if not data or not 'user_id' in data: return jsonify({'error': 'missing user_id'}), 400
+  user_id = int(data.get('user_id'))
+  d = await user.get_repos(user_id)
+  if d == "not exists":
+    return jsonify({'message': 'user not exists'}), 404
+  elif d == 'failed':
+    return jsonify({'message': "Failed to get user repos"}), 400
+  elif 'Error' in d:
+    return jsonify({'error': d}), 400
+  else:
+    return jsonify({'message': d}), 200

OneApi/api/host.py

@@ -0,0 +1,22 @@
+from ..database import *
+from quart import *
+import logging 
+from .. import *
+from ..deployment.deployment import Deployment
+
+user = user()
+deploy = Deployment()
+host_bp = Blueprint('host', __name__)
+
+@app.route('/host/', methods=['POST'])
+async def host():
+  data = await request.get_json()
+  if not data or not 'user_id' in data and not 'project_id' in data: return jsonify({'error': 'missing user_id or project_id'}), 400
+  user_id = int(data.get('user_id'))
+  project_id = int(data.get('project_id'))
+
+  mm = await deploy.host(user_id, project_id)
+  logging.info(f"DEBUG HOST API 18: {mm}")
+  if mm is True:
+    return jsonify({'message': 'Successfully hosted!'}), 200
+  return jsonify({'message': mm}), 400

OneApi/api/project_info.py

@@ -0,0 +1,18 @@
+from ..database import *
+from quart import *
+from .. import *
+
+user = user()
+project_info_bp = Blueprint('project_info', __name__)
+
+@app.route('/project_info/', methods=['POST'])
+async def project_info():
+  data = await request.get_json()
+  if not data or not 'user_id' in data and not 'project_id' in data: return jsonify({'error': 'missing user_id or project_id'}), 400
+  user_id = int(data.get('user_id'))
+  project_id = int(data.get('project_id'))
+
+  mano = await user.find(f'p{user_id}{project_id}', project=True)
+  if mano:
+    return jsonify({'message': mano}), 200
+  return jsonify({'message': 'Cannot find the project!'}), 400

OneApi/api/set_repo.py

@@ -0,0 +1,21 @@
+from ..database import *
+from quart import *
+from .. import *
+
+user = user()
+set_repo_bp = Blueprint('set_repo', __name__)
+
+@app.route('/set_repo/', methods=['POST'])
+async def set_repo():
+  data = await request.get_json()
+  if not data or not 'user_id' in data and not 'project_id' in data and not 'repo_id' in data: return jsonify({'error': 'missing user_id or project_id or repo_id'}), 400
+  user_id = int(data.get('user_id'))
+  project_id = int(data.get('project_id'))
+  repo_id = int(data.get('repo_id'))
+
+  mano = await user.set_repo(user_id, project_id, repo_id)
+  if mano == 'ok':
+    return jsonify({'message': mano}), 200
+  elif 'Error' in str(mano):
+    return jsonify({'error': mano}), 400
+  return jsonify({'message': mano}), 400

OneApi/api/user_info.py

@@ -0,0 +1,16 @@
+from ..database import *
+from quart import *
+from .. import *
+
+user = user()
+user_info_bp = Blueprint('user_info', __name__)
+
+@app.route('/user_info/', methods=['POST'])
+async def user_info():
+  data = await request.get_json()
+  if not data or not 'user_id' in data: return jsonify({'error': 'missing user_id'}), 400
+  user_id = int(data.get('user_id'))
+  d = await user.user_info(user_id)
+  if d == 'not exists': return jsonify({'message': "user not found"}), 404
+  elif 'error' in d: return jsonify({'error': d}), 400
+  return jsonify({'message': d}), 200

OneApi/database/__init__.py

@@ -0,0 +1 @@
+from .user import *

OneApi/database/methods/__init__.py

@@ -0,0 +1,18 @@
+from .user_info import UserInfo
+from .get_repos import GetRepos
+from .delete_user import DeleteUser
+from .disconnect_git import DisconnectGit
+from .set_repo import SetRepo
+from .add_log import addLog
+from .get_repo import GetRepo
+
+class Methods(
+  UserInfo,
+  GetRepos,
+  DeleteUser,
+  DisconnectGit,
+  SetRepo,
+  addLog,
+  GetRepo,
+):
+  pass

OneApi/database/methods/add_log.py

@@ -0,0 +1,25 @@
+import traceback
+import logging
+
+class addLog:
+  async def add_log(self, user_id: int, project_id: int, log_text: str):
+    try:
+      db, cb = self.db, self.cb
+      user = await self.find(user_id)
+      project = await db.find_one({"_id": f"p{user_id}{project_id}"})
+      if not user: return 'not exists'
+      elif not project: return 'Project not found'
+
+      log = project.get('logs')[-10000:]
+      log += f"{self.lf}: {log_text}"
+      
+      await db.update_one(
+        {"_id": f"p{user_id}{project_id}"},
+        {"$set": {
+          "logs": log
+        }}
+      )
+      return True
+    except Exception as r:
+      logging.error(traceback.format_exc())
+      return False

OneApi/database/methods/delete_user.py

@@ -0,0 +1,25 @@
+import traceback
+import logging
+
+class DeleteUser:
+  async def delete_user(self, user_id: int):
+    try:
+      user = await self.find(user_id)
+      if not user: "not exists"
+      db, cb = self.db, self.cb
+      await db.update_one({"_id": 1}, {"$pull": {"users": user_id}})
+      await db.delete_one({"_id": user_id})
+      for x in user.get('projects'):
+        if x.get('project_id'):
+          try: await db.delete_one({"_id": f"{user_id}{int(x.get('project_id'))}"})
+          except: pass
+      try:
+        await cb.update_one({"_id": 1}, {"$pull": {"users": user_id}})
+        await cb.delete_one({"_id": user_id})
+      except Exception as e: logging.error("Error on deleting user callback data ^_^: {user_id}, {e}")
+      return True
+    except Exception as e:
+      logging.error(traceback.format_exc())
+      return f"Error: {e}"
+      
+    

OneApi/database/methods/disconnect_git.py

@@ -0,0 +1,16 @@
+import traceback
+import logging
+
+class DisconnectGit:
+  async def disconnect_git(self, user_id: int):
+    try:
+      user = await self.find(user_id, check=True)
+      if not user: "not exists"
+      db, cb = self.db, self.cb
+      await cb.update_one({"_id": 1}, {"$pull": {"users": user_id}})
+      await cb.delete_one({"_id": user_id})
+      return True
+    except Exception as e:
+      logging.error(traceback.format_exc())
+      return f"Error: {e}"
+    

OneApi/database/methods/get_repo.py

@@ -0,0 +1,21 @@
+import logging 
+import traceback 
+
+class GetRepo:
+  async def get_repo(self, user_id: int, repo_id: int):
+    try:
+      db, cb = self.db, self.cb
+      user = await self.find(user_id)
+      if not user: return 'not exists'
+      hmm = await self.get_repos(user_id)
+      
+      if not hmm: return False
+      
+      yes = False
+      for x in hmm:
+        if int(x.get('id', 0)) == int(repo_id):
+          yes = x
+          break
+      if yes: return yes
+    except: logging.error(traceback.format_exc())
+    return False

OneApi/database/methods/get_repos.py

@@ -0,0 +1,46 @@
+import traceback
+import logging
+import httpx 
+
+class GetRepos:
+  async def get_repos(self, user_id: int):
+    try:
+      db, cb = self.db, self.cb
+      user = await self.find(user_id)
+      if not user: return 'not exists'
+      installation_id = (await cb.find_one({"_id": int(user_id)})).get('installation_id', None)
+      if not installation_id: return "not exists"
+      token = await self.gen_token(installation_id)
+      url = "https://api.github.com/installation/repositories?page=1"
+      headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": "application/vnd.github+json"
+      }
+      async with httpx.AsyncClient() as mano:
+        r = await mano.get(url, headers=headers)
+        if r.status_code == 200:
+          data = r.json()
+          if not data.get("repositories"): return []
+          ily = []
+          for x in data.get("repositories"):
+            name, full_name, id = x.get('name'), x.get('full_name'), x.get('id')
+            ily.append({'name': name, 'id': id, 'full_name': full_name})
+          try: pages = list(range(2, int(str(r.headers.get('Link', ''))[126])+1))
+          except Exception as w:
+            logging.error(f"GetRepos 30: {w}")
+            pages = []
+          for x in pages:
+            url = f"https://api.github.com/installation/repositories?page={x}"
+            k = await mano.get(url, headers=headers)
+            data = k.json()
+            if k.status_code == 200 and data.get("repositories"):
+              for x in data["repositories"]:
+                name, full_name, id = x.get('name'), x.get('full_name'), x.get('id')
+                ily.append({'name': name, 'id': id, 'full_name': full_name})
+          return ily
+        else:
+          logging.info(f"Failed to get repos of user: {user_id}: {r.text}")
+          return "failed"
+    except Exception as w:
+      logging.error(traceback.format_exc())
+      return f"Error: {w}"

OneApi/database/methods/set_repo.py

@@ -0,0 +1,43 @@
+import traceback
+import logging
+
+class SetRepo:
+  async def set_repo(self, user_id: int, project_id: int, repo_id: int):
+    try:
+      db, cb = self.db, self.cb
+      user = await self.find(user_id)
+      project = await db.find_one({"_id": f"p{user_id}{project_id}"})
+      if not user: return 'not exists'
+      elif not project: return 'Project not found'
+
+      hmm = await self.get_repos(user_id)
+      if not hmm:
+        logging.info(f"Set repo 16: {hmm}")
+        return 'Repo not found'
+
+      yes = False
+      for x in hmm:
+        if int(x.get('id', 0)) == int(repo_id):
+          yes = True
+          name = x.get('name')
+          break
+      if not yes:
+        logging.info("Cannot find project")
+        return 'Repo not found'
+
+      log = project.get('logs')
+      log += f"{self.lf}: Repo linked successfully"
+
+      await db.update_one(
+        {"_id": f"p{user_id}{project_id}"},
+        {"$set": {
+          "logs": log,
+          "repo": repo_id,
+          "repo_name": name
+        }}
+      )
+      return 'ok'
+    except Exception as e:
+      logging.error(traceback.format_exc())
+      return f"Error: {e}"
+    

OneApi/database/methods/user_info.py

@@ -0,0 +1,20 @@
+import traceback
+import logging
+import httpx 
+
+class UserInfo:
+  async def user_info(self, user_id):
+    try:
+      from ..user import db
+      user = await self.find(user_id)
+      if not user: return "not exists"
+      data = {
+        "name": user.get('name'),
+        "coins": user.get('coins'),
+        "projects": len(user.get('projects')),
+        "git": user.get('git')
+      }
+      return data
+    except Exception as w:
+      logging.error(traceback.format_exc())
+      return f'Error: {w}'

OneApi/database/user.py

@@ -0,0 +1,159 @@
+from .. import DATABASE
+import logging
+import traceback 
+from .methods import *
+import httpx
+from ..others import *
+
+db = DATABASE['user_nelskk']
+
+class user(Methods):
+    def __init__(self):
+      self.db = db
+      self.cb = DATABASE['cb']
+      self.gen_token = gen_token
+      self.lf = "\n[ElevenHost]"
+    async def find(self, user_id, project=False, check=False):
+      try:
+        if project:
+          return await db.find_one({"_id": str(user_id)})
+        elif check:
+          if await db.find_one({"_id": int(user_id)}) and await self.cb.find_one({"_id": user_id}):
+            return True
+          return False
+        user = await db.find_one({"_id": int(user_id)})
+        return user
+      except Exception as w:
+        e = traceback.format_exc()
+        logging.error(e)
+        return f"Error: {w}"
+    async def create(self, name: str, user_id: int):
+      try:
+        if await self.find(user_id): return "exists"
+        if not await self.cb.find_one({"_id": user_id}): return "Not connected"
+        url = "https://api.github.com/installation/repositories"
+        installation_id = await self.cb.find_one({"_id": user_id})
+        if installation_id and installation_id.get('installation_id'):
+          token = await self.gen_token(installation_id.get('installation_id'))
+          if not token: return "Not connected"
+        else: return "Not connected"
+        
+        headers = {
+          "Authorization": f"Bearer {token}",
+          "Accept": "application/vnd.github+json"
+        }
+        
+        async with httpx.AsyncClient() as client:
+          response = await client.get(url, headers=headers)
+          if response.status_code == 200:
+            data = response.json()
+            if data["repositories"]:
+              owner = data["repositories"][0]["owner"]
+              owner = owner["login"]
+            else: owner = 'CannotFound'
+          else:
+              logging.warn(f"GitHub doesn't give 200 status code: {response.text}")
+              return "Not connected"
+        
+        await db.update_one({"_id": 1}, {"$addToSet": {"users": user_id}}, upsert=True)
+        await db.update_one(
+            {"_id": user_id},
+            {"$set": {"name": name, "coins": 0, "projects": [], 'latest_project': 0, 'git': owner}},
+            upsert=True
+        )
+        
+        return 'ok'
+      
+      except Exception as w:
+        e = traceback.format_exc()
+        logging.error(e)
+        return f"Error: {w}"
+    
+    async def get_projects(self, user_id: int):
+      try:
+        if not await self.find(user_id): return "not exists"
+        user = await self.find(user_id)
+        if user.get('projects'):
+          return user.get('projects')
+        return 'projects not found'
+      except Exception as oh:
+        e = traceback.format_exc()
+        logging.error(e)
+        return f"Error: {oh}"
+    
+    async def create_project(self, name: str, user_id: int, plan: str):
+      try:
+        user = await self.find(user_id)
+        if not user: return "not exists"
+        elif name and len(name) < 4:
+          return 'Name too short'
+        
+        name, latest_project = name[:15], int(user.get('latest_project', 0)) + 1
+        coins = user.get('coins', 0)
+        
+        if any(proj.get('name') == name for proj in user.get('projects', [])):
+          return "Name already used"
+        
+        if plan == 'free':
+          plan_price = 0
+        elif plan == 'basic':
+          plan_price = 99
+        elif plan == 'advance':
+          plan_price = 199
+        elif plan == 'pro':
+          plan_price = 269
+        else: return 'Plan not found'
+        if coins < plan_price:
+          return 'insufficient coins'
+
+        if plan_price != 0: await db.update_one({"_id": user_id}, {"$set": {'coins': coins-plan_price}})
+        
+        await db.update_one(
+          {"_id": f'p{user_id}{latest_project}'},
+          {"$set": {
+            "name": name,
+            "id": latest_project,
+            "plan": plan,
+            "ram": 10000,
+            "rom": 100000000,
+            "repo": 0,
+            "repo_name": 'Not set',
+            "apt-allowed": False,
+            "language": 'None',
+            "logs": f"[ElevenHost]: Project successfully created!"
+          }},
+          upsert=True
+        )
+        await db.update_one(
+          {"_id": user_id},
+          {"$addToSet": {
+            "projects": {
+              'name': name,
+              'project_id': latest_project
+            }
+          }}
+        )
+        await db.update_one({"_id": user_id}, {"$set": {"latest_project": latest_project}})
+        return 'ok'
+      except Exception as e:
+        logging.error(traceback.format_exc())
+        return f'Error: {e}'
+    
+    async def delete_project(self, user_id: int, project_id: int):
+      try:
+        user = await self.find(user_id)
+        if not user:
+          return "not exists"
+        if not user.get('projects'):
+          return "Project not found"
+        if not any(proj.get('project_id') == project_id for proj in user.get('projects', [])):
+          return "Project not found"
+        await db.delete_one({"_id": f"p{user_id}{project_id}"})
+        await db.update_one(
+          {"_id": user_id},
+          {"$pull": {"projects": {"project_id": project_id}}}
+        )
+        return "ok"
+      except Exception as e:
+        logging.error(traceback.format_exc())
+        return f"Error: {e}"

OneApi/deployment/__init__.py

@@ -0,0 +1,5 @@
+from .host import Host
+class Methods(
+  Host
+):
+  pass

OneApi/deployment/deployment.py

@@ -0,0 +1,9 @@
+from .. import *
+from . import Methods 
+from ..database import user
+
+class Deployment(Methods):
+  def __init__(self):
+    self.lf = "\n[ElevenHost]"
+    self.database = user()
+    self.cb = DATABASE['cb']

OneApi/deployment/host.py

@@ -0,0 +1,87 @@
+from .. import *
+import logging
+import traceback 
+import asyncio
+import aiofiles 
+import aiofiles.os
+import yaml
+
+async def check_yaml(data):
+  f = "FileFormatInvalidError:"
+  if not data.get('language'):
+    return f'{f} Project language not found in ElevenHost.yaml'
+  elif not data.get('version'):
+    return f'{f} Project language version not found in ElevenHost.yaml'
+  elif not data.get('build'):
+    return f'{f} Build not found on ElevenHost.yaml'
+  elif not data.get('packages'):
+    return f'{f} Packages not found in ElevenHost.yaml'
+  elif not data.get("start"):
+    return f'{f} start not found in ElevenHost.yaml'
+  else: return True
+
+async def create_docker(data):
+  dockerfile = f"FROM {data.get('language')}:{data.get('version')}\n\n"
+  dockerfile += ''.join([f"RUN {x}\n\n" for x in data.get('build')])
+  dockerfile += ''.join([f"RUN apt-get install {x} -y\n\n" for x in data.get('packages')])
+  dockerfile += f"COPY . /app/\n\nCMD {data.get('start')[0]}\n"
+  return dockerfile
+
+class Host:
+  async def host(self, user_id: int, project_id: int):
+    database = self.database
+    user = await database.find(user_id)
+    project = await database.find(f"p{user_id}{project_id}", project=True)
+    if not user: return 'not exists'
+    elif not project: return 'Project not found'
+    repo_id = project.get('repo', 0)
+    repo = await database.get_repo(user_id, repo_id)
+    if not repo: return "Repo not found"
+      
+    installation_id = (await self.cb.find_one({"_id": int(user_id)})).get('installation_id', None)
+    if not installation_id: return "not exists"
+    token = await database.gen_token(installation_id)
+    
+    try:
+      folder = f"deployment{user_id}"
+      await database.add_log(user_id, project_id, "Clonning repo from github...")
+      await run(f"rm -rf {folder}")
+      await run(f"mkdir {folder}")
+      ok = await run(f"cd {folder} && git clone https://x-access-token:{token}@github.com/{repo.get('full_name')}/")
+      repo_folder = f"{folder}/{repo.get('name')}"
+      
+      if not await aiofiles.os.path.isdir(repo_folder):
+        await database.add_log(user_id, project_id, f"Error on clonning repo: {ok}")
+        return 'Failed to host repo'
+      ls = await run(f"ls {repo_folder}")
+      
+      await database.add_log(
+        user_id,
+        project_id, 
+        f"Successfully clonned repo!, Files found in repo: {len(ls.split('\n')) if '\n' in ls else 0}"
+      )
+      
+      if not await aiofiles.os.path.isfile(f"{repo_folder}/ElevenHost.yaml"):
+        await database.add_log(
+        user_id,
+        project_id, 
+        f"Error:\nCannot find ElevenHost.yaml on your repo"
+        )
+        return "ElevenHost.yaml not found"
+      
+      async with aiofiles.open(f"{repo_folder}/ElevenHost.yaml", mode='r') as mano:
+        ctx = mano.read()
+      data = yaml.safe_load(ctx)
+      chk = await check_yaml(data)
+      
+      if not chk is True:
+        await database.add_log(user_id, project_id, chk)
+        return chk
+      
+      return True
+    except Exception as w:
+      logging.error(traceback.format_exc())
+      return f"Error: {w}"
+      
+      
+    

OneApi/others/__init__.py

@@ -0,0 +1 @@
+from .gen_token import gen_token

OneApi/others/gen_token.py

@@ -0,0 +1,25 @@
+import jwt
+from time import time
+import httpx
+
+with open("mano.pem", "r") as f:
+  PRIVATE_KEY = f.read()
+APP_ID = "1109508"
+
+async def gen_token(installation_id):
+    payload = {
+        "iat": int(time()),
+        "exp": int(time()) + 60,
+        "iss": APP_ID,
+    }
+    jwt_token = jwt.encode(payload, PRIVATE_KEY, algorithm="RS256")
+    url = f"https://api.github.com/app/installations/{installation_id}/access_tokens"
+    headers = {
+        "Authorization": f"Bearer {jwt_token}",
+        "Accept": "application/vnd.github+json",
+    }
+    async with httpx.AsyncClient() as client:
+        response = await client.post(url, headers=headers)
+        if response.status_code == 201:
+            return response.json().get("token")
+        return None

docker-compose.yml

@@ -0,0 +1,32 @@
+version: '3.8'
+
+services:
+  oneapi:
+    build: .
+    ports:
+      - "8080:8080"
+    environment:
+      - MONGO_DB_URL=mongodb://mongo:27017/OneApi
+      - API_ID=${API_ID:-29764570}
+      - API_HASH=${API_HASH:-7676192e491329a1b859b2184e5d7823}
+      - TOKEN=${TOKEN:-BQCDh4MAZuO8dsEXNE9pCZtV297oEptGvaTC75QL9GSgnhG8eZP4GVWQqPCzbKxyhN8iCsDX2HG72JIC_LVOYL6-aB3TcuY9eafbv2sKq-usHKOUA8lXf1RUzkaeYA1QNvjSU9hZrKCbrH6NtfuPzkFQeRCYhK-z2GDekhykPqLEHJu0hewOYtdwbC_om47iF3rUL94Wi3UOhAVzr_IZeklt8IIbL6stzR7dIce17ZbIlNGsVwZr6qMgBh-CYl4A0XlCh_iuMyRAmYHJ9nBQR-OhxuwewMDl9R8AvvHxnE3KYEbX2NGTFaOacWg5mtd4cm8OIf8ese4oC-TnspkFSmUPEQwNXwAAAAG1SBMOAQ}
+      - DEVS=${DEVS:-5965055071}
+      - PORT=8080
+    depends_on:
+      - mongo
+    volumes:
+      - ./logs:/app/logs
+    restart: unless-stopped
+
+  mongo:
+    image: mongo:6.0
+    ports:
+      - "27017:27017"
+    environment:
+      - MONGO_INITDB_DATABASE=OneApi
+    volumes:
+      - mongo_data:/data/db
+    restart: unless-stopped
+
+volumes:
+  mongo_data: 

mano.pem

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpAIBAAKCAQEA1gNfDkAFX+K/ug05GXdigs4sHrL/ZDSV2Vj4h8uZb6UXJeoe
+I6O2kjKC5Zbo2F+JwbC0nhnzhlngUadjUWXJtnkANyEPk+Hxk56qIo2akRN8KHEL
+aWpXPznwj0ZxP4s3hEwgmDc7n5Kpl9w8nYT6MAUuyB2NZ6E/dRTPU6NHDyuf0yhS
+h98A2ZXcqWHrwtVUHq/I4oEAfu3xvUhoYeODS5MrJV2oLy2crXPUb2t1/AyIl5q4
+9B3Dj4UYKZTEEDUjCZ+oueo8XDA5xCv8WYYsdYf484lf3po8f4yLBEI2i9aWGnEs
+enWsOI65MYyvXagUbzFyN0XnZNNp3T0xgvoJMwIDAQABAoIBAEywEJPOpR5i5kkJ
+C/jwKsCsmGq3wYRqw3eKxiQC9QxooA7aAcrLk1R3/SfAF9fRBE//vfkZW4Y9FoCr
+9o7oZouYeFdI5YgcYrB/HoAbNdPeo5LqTyiLDpB9dpIgr9wRSueBT/y7bgYUS+k6
+5g2b5ProIIdc75q+0TpnJpPV4lSwqWTt6IcuXadx/YdgFLtfa07z1mMwBUQi/GXZ
+kjJkpTNG22pItP1oYSY22EfuIFYkmsx2c44VT61D/Xa01ABk4pOSYZzQXePqymG5
+qI1w7SsuOFQVZIGYuiM8fBBv4Yd9MyJ4KBWG24H2TFw0XjiLmQgYBWuv15foSujv
+7+z2s6ECgYEA7TmPTShVj4DrGiSsGjgYbHTXybWdxdDnP7b+39/e2tFFax+n06sP
+1YzWWhQI40uZ0kyCLLiSS6arxhjw9swzAet2NsN+k9u72Qz/Y/XIVT8mmXBc+4I3
+2YwJU0cPx2unGjUHYx9Am+23o3KHceIFDtyAsljBiJ0CAuTbg9r+APcCgYEA5vOE
+YV23spoe6SME9XpMKLHreSWUWCeMVhkPJZIIlkCHD2m8o+sB1+MApnRBvHWHU5sC
+OOYzt7fMQM/c2aLLSVwGl7Be5XURBcBq984pxq9uolUb0OcTYPIh23ZtlV+Zi1Xr
+b/42DiWVIVFN8gmt59adPe6X3n/1pnHJwIbnZqUCgYEAyZpxPpFYpWxaYQ1pdZ7W
+otVpzfKa8tJmtK9AS+Jl8nCHHlL4vdpSypm2UTdVllVZlG+Q8ZCqQ8CRmvj3T8aa
+UrdY75GUsPO84Ok64iiu6EOS+jOT0esIq8lm428w6bmDebI3ZPXaYqnTtwRON2pu
+AgNDHE5xqzhDzVHRfG1QEGECgYBG5/L31cclbY4Z8+d82nxxbhamjjQaUKIUeQMe
+fNRoFQ2iXMtO5EMfnhFACad5DfhrYcbv4zVzrVlneKoMo5+YOUnI3px0BFoiku4E
+gOZwmsHz0v+ERr27YPumHpkMaFqC3fE35CuCcmVz4jt1GSWsbUa/kfZMmKq53Gud
+0Y1QBQKBgQCMdt81IsLWCTUQI09Y+9tq/9CqGOUhRGXwG9RCaWrqBBLWWgR8kQVK
+pYdR2MlqHpwywcOAhlOU7r0Cmbonf8cnZuFv6FMI405KExSMIUyhhrbDbYwPNEUo
+ODb/k7oa2AanEasVm8uQgoA/RSNA1zyzFZ8tkFDJ1V6CSQgzAkLAXg==
+-----END RSA PRIVATE KEY-----

requirements.txt

@@ -0,0 +1,10 @@
+quart
+motor==3.6.0
+pymongo[srv]
+kurigram
+TgCrypto
+quart-cors
+cryptography
+pyjwt
+aiofiles
+pyyaml

variables.py

@@ -0,0 +1,6 @@
+VAR_TOKEN = "8185712635:AAFqz_RmsleAbfSeVw--SGw5PaWQS3Cqan0"
+VAR_MONGO_DB_URI = "mongodb+srv://xdragxt:[email protected]/?retryWrites=true&w=majority&appName=dragtest"
+VAR_API_ID = 21188444
+VAR_API_HASH = "031ff911c40173e28290e2f44fcb4b56"
+VAR_DEVS = 7361622601 
+