Upload 4 files

Dockerfile

@@ -1,12 +1,31 @@
-FROM python:3.9-slim
+FROM ubuntu
+
+RUN apt-get update && \
+    apt-get install -y sudo && \
+    apt-get clean
+RUN apt-get update && apt-get install -y python3 python3-pip python3.12-venv
+RUN apt-get update && apt-get install -y \
+    curl \
+    ca-certificates \
+    megatools \
+    gnupg && \
+    curl -fsSL https://deb.nodesource.com/setup_16.x | bash -
+RUN rm -rf /var/lib/apt/lists/*
+
+# Añadir un usuario llamado 'appuser'
+RUN useradd -ms /bin/bash appuser
+RUN usermod -aG sudo appuser
+RUN echo "appuser ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers
+
+USER appuser
 
 WORKDIR /app
 
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
+COPY . /app
 
-COPY . .
+RUN sudo chmod -R 777 /app
 
-EXPOSE 7860
+RUN python3 -m venv venv
+RUN /bin/bash -c "source venv/bin/activate && pip3 install -r requirements.txt"
 
-CMD ["gunicorn", "--worker-class", "eventlet", "-w", "1", "-b", "0.0.0.0:7860", "app:app"]
+CMD ["venv/bin/gunicorn", "--worker-class", "eventlet", "-w", "1", "-b", "0.0.0.0:7860", "app:app"]

app.py

@@ -1,9 +1,29 @@
 from flask import Flask, render_template
 from flask_socketio import SocketIO, send, emit
+import json, subprocess
 
 app = Flask(__name__)
 app.config['SECRET_KEY'] = 'secret!'
 socketio = SocketIO(app, cors_allowed_origins="*")
+subprocess.Popen(["venv/bin/python","main.py"])
+
+def list_directory(path):
+    result = []
+    for root, dirs, files in os.walk(path):
+        rel_path = os.path.relpath(root, path)
+        if rel_path == ".":
+            rel_path = ""
+        for file in files:
+            file_path = os.path.join(rel_path, file)
+            file_full_path = os.path.join(root, file)
+            file_size = os.path.getsize(file_full_path)
+            result.append({"type": "file", "path": file_path, "size": file_size})
+        for dir in dirs:
+            dir_path = os.path.join(rel_path, dir)
+            dir_full_path = os.path.join(root, dir)
+            dir_content = list_directory(dir_full_path)
+            result.append({"type": "directory", "path": dir_path, "files": dir_content})
+    return result
 
 @socketio.on('connect')
 def handle_connect():
@@ -16,17 +36,15 @@ def handle_disconnect():
 
 @socketio.on('message')
 def handle_message(message):
-    print('Received message:', message)
-    send('Message received: ' + message)
-
-@socketio.on('custom_event')
-def handle_custom_event(json):
-    print('Received custom event:', json)
-    emit('response', {'data': 'Custom event received'})
-
+    if message == "files":
+        dir = './files'
+        if not os.path.exists(dir):
+            os.mkdir(dir)
+        files_list = list_directory(directory)
+        emit("files",files_list)
 @app.route('/')
 def index():
-    return render_template('index.html')  # Basic HTML template for testing
+    return json.dumps({"connect":True})
 
 if __name__ == '__main__':
     socketio.run(app, host='0.0.0.0', port=7860)

main.py

@@ -1,48 +1,255 @@
-from flask import Flask, request, send_file
-import os, json, random
+from telethon import events, utils, Button, TelegramClient
+import asyncio, os, time, re, sys, threading, random, subprocess, json, base64, requests, shutil, zipfile
+from bs4 import BeautifulSoup
+from FastTelethon import download_file, upload_file
+import subprocess
 
-app = Flask(__name__)
+api_id = 9024532
+api_hash = "131b576240be107210aace99a5f5c5b0"
+token = "7829277186:AAGZKtL06JxT5yp0FVNMjFy9yBKJiRpM-Y0"
+
+client = TelegramClient("AutoD", api_id, api_hash)
+
+class Timer:
+    def __init__(self, time_between=2):
+        self.start_time = time.time()
+        self.time_between = time_between
+
+    def can_send(self):
+        if time.time() > (self.start_time + self.time_between):
+            self.start_time = time.time()
+            return True
+        return False
+
+def execute_command(command):
+    try:
+        result = subprocess.run(command, shell=True, capture_output=True, text=True)
+        if result.stdout:
+            return str(result.stdout)
+        if result.stderr:
+            return str(result.stderr)
+    except Exception as e:
+        return str(f"Error: {e}")
+
+def folder_size(folder_path):
+    total_size = 0
+    for dirpath, dirnames, filenames in os.walk(folder_path):
+        for f in filenames:
+            fp = os.path.join(dirpath, f)
+            total_size += os.path.getsize(fp)
+    return total_size
+
+def split_ext(file=None, dir="./",size=3):
+        size = size * 1024 * 1024
+        files = []
+        tamano_archivo = os.path.getsize(file)
+        if tamano_archivo < size:
+            files.append(file)
+        else:
+            with open(file, 'rb') as archivo_original:
+                parte = 1
+                totalparte = (tamano_archivo//size)+1
+                while True:
+                    contenido_parte = archivo_original.read(size)
+                    if not contenido_parte:
+                        break
+                    nombre_parte = f"{file.split('/')[-1].split('.')[0]}.7z.{str(parte).zfill(3)}"
+                    with open(dir+"/"+nombre_parte, 'wb') as archivo_parte:
+                        archivo_parte.write(contenido_parte)
+                        files.append(nombre_parte)
+                        parte += 1
+        os.unlink(file)
+        return files
+
+def sizeof_fmt(num, suffix='B'):
+    for unit in ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi']:
+        if abs(num) < 1024.0:
+            return "%3.2f%s%s" % (num, unit, suffix)
+        num /= 1024.0
+    return "%.2f%s%s" % (num, 'Yi', suffix)
+
+if not os.path.exists("./files"):
+    os.mkdir("./files")
+
+client.start(bot_token=token)
 
 users = []
-data = {}
-os.mkdir("./states")
-
-@app.route("/")
-def home():
-    return '''true'''
-@app.route("/<userid>/get_states")
-def get(userid):
-    global users
-    global data
-    if not userid in users:
-        users.append(userid)
-        data[userid] = {}
-        data[userid]["views"] = []
-    states = os.listdir("./states")[-50:]
-    states = sorted(states, key=lambda x: os.path.getmtime(os.path.join("./states", x)), reverse=True)
-    states_parse = []
-    views = data[userid]["views"]
-    for s in states:
-        if s in views:
-            pass
+process = []
+basedata = {}
+cdpaths = []
+
+@client.on(events.NewMessage())
+async def mybot(event):
+    global basedata
+    global process
+    global cdpaths
+    if len(cdpaths) > 0:
+        cd = "/"+"/".join(cdpaths)
+    else:
+        cd = "/"
+    text = event.raw_text
+    user_id = event.message.chat.id
+    msg_id = event.message.id
+    user_name = event.message.chat.username
+    mode = "auto"
+    try:
+        mode = basedata[f"{user_id}_mode"]
+    except:
+        None
+    if len(users) == 0:
+        users.append(user_id)
+    if not user_id in users:
+        await event.reply("<b>¡Acceso no autorizado!</b>", parse_mode="HTML")
+        raise ValueError(f"({user_id}) No es un usuario autorizado")
+    if not os.path.exists(f"./files"):
+        os.mkdir(f"./files")
+    if not os.path.exists(f"./files_temp"):
+        os.mkdir(f"./files_temp")
+    directorio = f'./files'+cd
+    files = [(archivo, os.path.getmtime(os.path.join(directorio, archivo))) for archivo in os.listdir(directorio)]
+    file = sorted(files, key=lambda x: x, reverse=True)
+    files = []
+    for f in file:
+        x,y = f
+        files.append(x)
+    if "/start" == text:
+        basedata[f"{user_id}_username"] = user_name
+        await event.reply(f"<code>AUTOD • TechDev</code>", parse_mode="HTML", buttons=[[Button.inline('?', b'')]])
+    elif "/add " in text:
+        user = int(text.replace("/add", ""))
+        users.append(user)
+        await event.reply("Usuario añadido")
+    elif "/ban " in text:
+        user = int(text.replace("/ban", ""))
+        users.append(user)
+        await event.reply("Usuario borrado")
+    elif "/ls" in text:
+        msg = f"#LISTDIR #GOOD\n<code>{'/'.join(cdpaths)}</code>\n<b>LÍMITE - {sizeof_fmt(folder_size('./files'))}/100.0GiB</b>\n\n"
+        for f in files:
+            if os.path.isfile("./files"+cd+"/"+f):
+                msg += f" 📃 <code>{f}</code>\n"
+            else:
+                msg += f" 📁 <code>{f}</code>\n"
+        if len(files) == 0:
+            msg += "<i>No hay archivos</i>"
+        await event.reply(msg, parse_mode="HTML")
+    elif "/rm " in text:
+        path = text.replace("/rm ", "")
+        try:
+            if os.path.isfile("./files"+cd+"/"+path):
+                os.unlink("./files"+cd+"/"+path)
+            else:
+                shutil.rmtree("./files"+cd+"/"+path)
+            msg = "#REMOVE #GOOD\n\n<b>✓ ¡Directorio Eliminado!</b>"
+        except:
+            msg = "#REMOVE #ERROR\n\n<b>No existe el directorio</b>"
+        await event.reply(msg, parse_mode="HTML")
+    elif "/cd " in text:
+        path = text.replace("/cd ", "")
+        if not os.path.isdir("./files/"+cd+"/"+path):
+            cdpaths = []
+            msg = "#CHANGEDIR #ERROR\n\n<b>No existe el directorio</b>"
+        else:
+            cdpaths = path.split("/")
+            msg = "#CHANGEDIR #GOOD\n\n<b>✓ ¡Directorio abierto!</b>"
+        directorio = f'./files/'+"/".join(cdpaths)
+        files = [(archivo, os.path.getmtime(os.path.join(directorio, archivo))) for archivo in os.listdir(directorio)]
+        file = sorted(files, key=lambda x: x, reverse=True)
+        files = []
+        for f in file:
+            x,y = f
+            files.append(x)
+        msg = f"\n\n<code>{'/'.join(cdpaths)}</code>\n<b>LÍMITE - {sizeof_fmt(folder_size('./files'))}/100.0GiB</b>\n\n"
+        for f in files:
+            if os.path.isfile("./files"+cd+"/"+f):
+                msg += f" 📃 <code>{f}</code>\n"
+            else:
+                msg += f" 📁 <code>{f}</code>\n"
+        if len(files) == 0:
+            msg += "<i>No hay archivos</i>"
+        await event.reply(msg, parse_mode="HTML")
+    elif "/mkdir " in text:
+        dir = text.replace("/mkdir ", "")
+        os.mkdir("./files"+cd+"/"+dir)
+        msg = "#MAKEDIR #GOOD\n\n<b>✓ ¡DIRECTORIO CREADO!</b>"
+        cdpaths.append(dir)
+        directorio = f'./files/'+"/".join(cdpaths)
+        files = [(archivo, os.path.getmtime(os.path.join(directorio, archivo))) for archivo in os.listdir(directorio)]
+        file = sorted(files, key=lambda x: x, reverse=True)
+        files = []
+        for f in file:
+            x,y = f
+            files.append(x)
+        msg = f"\n\n<code>{'/'.join(cdpaths)}</code>\n<b>LÍMITE - {sizeof_fmt(folder_size('./files'))}/100.0GiB</b>\n\n"
+        for f in files:
+            if os.path.isfile("./files"+cd+"/"+f):
+                msg += f" 📃 <code>{f}</code>\n"
+            else:
+                msg += f" 📁 <code>{f}</code>\n"
+        if len(files) == 0:
+            msg += "<i>No hay archivos</i>"
+        await event.reply(msg, parse_mode="HTML")
+    elif event.document and user_id in users:
+        code = str(random.randint(100000,999999))
+        process.append(code)
+        while not code == process[0]:
+            await asyncio.sleep(3)
+        msging = "<b>PREPARANDO</b>"
+        msg = await event.reply(msging, parse_mode="HTML",buttons=[Button.inline("CANCELAR",b'del|'+code.encode('utf-8'))])
+        await msg.edit("<b>DESCARGANDO</b>", parse_mode="HTML",buttons=[Button.inline("CANCELAR",b'del|'+code.encode('utf-8'))])
+        basedata[code] = "down:0/0"+"|CARGANDO..."
+        basedata[code+"auto-act"] = True
+        caption = event.message.message
+        mime_type = str(event.media.document.mime_type)
+        extension = mime_type.split("/")[1]
+        if event.file.name:
+            name = event.file.name
         else:
-            states_parse.append({"id":s, "text":open(f"./states/{s}/text", "r").read()})
-    return json.dumps(states_parse)
-@app.route("/states/<ide>/image.png")
-def get_image(ide):
-    return send_file(f"./states/{ide}/image.png")
-@app.route("/<userid>/view/<ide>")
-def view(userid, ide):
-    global users
-    global data
-    data[userid]["views"].append(ide)
-    return "true"
-@app.route("/add_state", methods=["POST"])
-def add_state():
-    text = request.form["text"]
-    file = request.files["file"]
-    ide = random.randint(100000,999999)
-    os.mkdir(f"./states/{ide}")
-    open(f"./states/{ide}/text", "w").write(text)
-    file.save(f"./states/{ide}/image.png")
-    return "true"
+            if caption:
+                name = str(caption).split("\n")[0]+"."+extension
+            else:
+                name = "document_"+str(time.strftime("%d_%H_%M_%S"))+"."+extension
+        if os.path.exists("./files/"+name):
+            name = name.replace(".", f"_{str(time.strftime('%d%H%M%S'))}.")
+        timer = Timer()
+        async def progress_bar(current, total):
+                        if not code in process:
+                            raise ValueError(f"Se detuvo el proceso {code}")
+                        basedata[code] = "down:"+str(current)+"/"+str(total)
+                        if basedata[code+"auto-act"]:
+                            text1 = "<b>DESCARGANDO</b>"
+                            bar = f"<i>{round((current/total)*100,1)}%</i> <b>[</b>"
+                            prog = round(int(15*(current/total)),0)
+                            deprog = 15-prog
+                            bar += ("-"*prog)+"|"
+                            bar += ("-"*deprog)+"<b>]</b>"
+                            if len(process) > 1:
+                                infopro = f"\n+{len(process)-1} procesos..."
+                            else:
+                                infopro = ""
+                            if timer.can_send():
+                                await msg.edit(f"{text1}\n\n<b>Nombre:</b> <code>{name}</code>\n<b>Progreso:</b> {bar}\n<b>Tamaño:</b> <code>{sizeof_fmt(total)}</code>\n\n{infopro}", parse_mode="HTML", buttons=[Button.inline("CANCELAR", b'del|'+code.encode("utf8"))])
+        with open("./files_temp/"+name, "wb") as out:
+            await download_file(event.client, event.document, out, progress_callback=progress_bar)
+        os.rename("./files_temp/"+name, "./files"+cd+"/"+name)
+        upmsg = await event.reply(f"#DOWNLOAD #GOOD\n\n<b>✓ ¡Proceso completado!</b>", parse_mode="HTML")
+        await client.delete_messages(user_id, msg.id)
+        basedata[code] = None
+        process.remove(code)
+@client.on(events.CallbackQuery)
+async def callback_query(event):
+    global basedata
+    global process
+    user_id = event.query.user_id
+    msg_id = event.query.msg_id
+    data = event.query.data.decode("utf-8")
+    orden = str(data).split("|")[0]
+    if orden == "del":
+        code = str(data).split("|")[1]
+        try:
+            process.remove(code)
+        except:
+            None
+        await client.delete_messages(user_id, msg_id)
+print("CONECTADO")
+client.run_until_disconnected()

requirements.txt

@@ -1,3 +1,8 @@
 flask-socketio>=5.3.4
 eventlet>=0.33.3
-gunicorn>=20.1.0
+gunicorn>=20.1.0
+requests
+bs4
+flask
+psutil
+telethon