110 lines
5.4 KiB
Python
110 lines
5.4 KiB
Python
from flask import send_file, Flask, request, jsonify
|
|
#from werkzeug.middleware.proxy_fix import ProxyFix # Für Einsatz in Produktion hinter einem Webserver
|
|
import sqlite3, hashlib, random, os, pathlib, jinja2
|
|
|
|
prefixes = ["B", "KB", "MB", "GB", "TB"]
|
|
|
|
app = Flask(__name__)
|
|
#app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1, x_host=1, x_prefix=1) # Für Einsatz in Produktion hinter einem Webserver
|
|
|
|
jinjaEnv = jinja2.Environment(loader=jinja2.PackageLoader("main", "pages"))
|
|
downloadTemplate = jinjaEnv.get_template("download.html")
|
|
indexTemplate = jinjaEnv.get_template("index.html")
|
|
errorTemplate = jinjaEnv.get_template("error.html")
|
|
uploadedTemplate = jinjaEnv.get_template("uploaded.html")
|
|
|
|
|
|
db = sqlite3.connect("_map.db", check_same_thread=False) # Erzeuge oder/und baue eine Verbindung auf zu der Datenbank (check_same_thread muss False sein da Flask mehrere eigene Threads verwendet)
|
|
dbCursor = db.cursor() # Keine Ahnung warum explizit ein Zeiger erzeugt werden muss, die meisten der Bibliotheken verwalten das von alleine
|
|
dbCursor.execute("CREATE TABLE IF NOT EXISTS _idToFile (id TEXT PRIMARY KEY, destination TEXT, uploadTime DATETIME, fileName TEXT);") # Selbsterklärend
|
|
|
|
# Erzeuge ein Ordner (falls dieser nicht exisitert) wo die Dateien abgelegt werden
|
|
if pathlib.Path("./data").is_dir() == False:
|
|
os.mkdir("data")
|
|
|
|
# Flask dings zeug
|
|
@app.route("/")
|
|
def mainpage():
|
|
return indexTemplate.render()
|
|
|
|
@app.route("/upload", methods = ["POST"])
|
|
def uploader():
|
|
file = request.files['file'] # Hole die Datei als FileStorage Objekt
|
|
name = file.filename.rsplit(".", 1) #
|
|
|
|
idValue = ""
|
|
idIsUnique = False
|
|
|
|
# Solange die ID nicht eindeutig ist, versuche eine neue zu erzeugen und überprüfe es (wird in 99,99% Fällen nur ein mal durchgelaufen)
|
|
while idIsUnique == False:
|
|
|
|
if idValue != "": # Ich könnte das if weglassen aber keine Ahnung ich finde das so besser
|
|
idValue = ""
|
|
|
|
# Fancy weg um eine 14-stellige ID zu erzeugen, wahrscheinlich gibt es fertige Funktionen aber wollte trotzdem eigene haben
|
|
for _ in range(14):
|
|
vArray = [""] * 3 # Fancy weg um ein Array mit der Länge 3 zu erzeugen
|
|
vArray[0] = chr(random.randint(48, 57)) # 0 - 9 in Unicode Charset
|
|
vArray[1] = chr(random.randint(65, 90)) # A - Z in Unicode Charset
|
|
vArray[2] = chr(random.randint(97, 122)) # a - z in Unicode Charset
|
|
|
|
# Aus 3 generierten Werten wähle einen aus und füge es am Ende des Strings an
|
|
selector = random.randint(0,2)
|
|
idValue += vArray[selector]
|
|
|
|
# Überprüfe ob die erstellte ID bereits existiert, falls ja, dann führe die Schleife nochmal durch
|
|
dbCursor.execute("SELECT * FROM _idToFile WHERE id=?;", (idValue,))
|
|
if dbCursor.fetchone() == None:
|
|
idIsUnique = True
|
|
|
|
if (len(name) > 1): # Dateinamen die ein Suffix besitzen
|
|
path = f"./data/{hashlib.sha256((name[0] + idValue).encode()).hexdigest()}.{name[1]}" # Wirkt wie schwarze Magie ist aber sehr simpel
|
|
else: # Dateinamen die kein Suffix besitzen
|
|
path = f"./data/{hashlib.sha256((name[0] + idValue).encode()).hexdigest()}"
|
|
|
|
file.save(path)
|
|
dbCursor.execute("INSERT INTO _idToFile VALUES (?, ?, datetime('now'), ?);", (idValue, path, file.filename,)) # Füge neuen Eintrag in die Datenbank
|
|
db.commit() # Bestätige die Transaktion damit der Eintrag tatsächlich gespeichert wird. Das beste ist ja, dass ich es nur bei INSERT tätigen muss
|
|
|
|
if request.user_agent.string != "API":
|
|
return uploadedTemplate.render(link=("/file/" + idValue))
|
|
else:
|
|
return jsonify(status=100,id=idValue)
|
|
|
|
# Nicht die eleganteste Lösung fürs Download aber ich hab kein Bock es anders zu lösen
|
|
|
|
# Das hier ist quasi das "Entry Point", es wird eineeine Seite zurück gegeben mit Infos über die Datei sowie einen Download Link
|
|
@app.route("/file/<string:identifier>")
|
|
def fileInfo(identifier):
|
|
dbCursor.execute("SELECT destination, uploadTime, filename FROM _idToFile WHERE id=?;", (identifier,)) # Hole die Infos für die Template
|
|
data = dbCursor.fetchone()
|
|
if data != None:
|
|
sizeBytes = os.path.getsize(data[0])
|
|
factor = 0 # 0 -> 1 = Kilo -> 2 = Mega -> 3 = Giga, usw..
|
|
|
|
while ((sizeBytes / 1024) > 1):
|
|
sizeBytes = sizeBytes / 1024
|
|
factor += 1
|
|
|
|
if request.user_agent.string != "API":
|
|
return downloadTemplate.render(filename=data[2], uploadDate=data[1], size=("%.2f" % sizeBytes + " " + prefixes[factor]), downloadPath=("/file/" + identifier + "/download"))
|
|
else:
|
|
return jsonify(status=100, name=data[2], size=("%.2f" % sizeBytes + " " + prefixes[factor]), uploadDate=data[1])
|
|
else:
|
|
if request.user_agent.string != "API":
|
|
return errorTemplate.render(error="keine Datei gefunden")
|
|
else:
|
|
return jsonify(status=301)
|
|
|
|
# Das Download Link
|
|
@app.route("/file/<string:identifier>/download")
|
|
def fileDownload(identifier):
|
|
dbCursor.execute("SELECT destination FROM _idToFile WHERE id=?;", (identifier,)) # Das Komma muss so bleiben sonst funktioniert """"prepared statement"""" nicht
|
|
path = dbCursor.fetchone()
|
|
if path != None:
|
|
return send_file(path[0])
|
|
else:
|
|
if request.user_agent.string != "API":
|
|
return errorTemplate.render(error="keine Datei gefunden")
|
|
else:
|
|
return jsonify(status=301) |