1483 lines
54 KiB
Python
1483 lines
54 KiB
Python
from PIL import Image
|
|
import matplotlib
|
|
matplotlib.use('Agg')
|
|
import matplotlib.pyplot as plt
|
|
from io import BytesIO
|
|
import matplotlib.dates as mdates
|
|
from flask import Flask, request, render_template, redirect, url_for, session, jsonify, Response, send_file
|
|
from flask_socketio import SocketIO, join_room, leave_room, emit
|
|
from pymongo import MongoClient
|
|
from bson.objectid import ObjectId
|
|
import uuid
|
|
import datetime
|
|
from flask_wtf.csrf import CSRFProtect
|
|
from werkzeug.security import generate_password_hash, check_password_hash
|
|
import subprocess
|
|
import signal
|
|
import threading
|
|
import psutil
|
|
import time
|
|
import json
|
|
import requests
|
|
import os
|
|
from datetime import datetime, timedelta
|
|
|
|
app = Flask(__name__, static_folder='/var/www/admin_website/static', template_folder='/var/www/admin_website/templates')
|
|
app.secret_key = os.urandom(24)
|
|
socketio = SocketIO(app, cors_allowed_origins="*", async_mode="threading")
|
|
|
|
csrf = CSRFProtect(app)
|
|
|
|
client = MongoClient("mongodb+srv://MrSniff:5169Galaxy@chainsaw.d0shx.mongodb.net/")
|
|
MONGO_URI = "mongodb+srv://MrSniff:5169Galaxy@chainsaw.d0shx.mongodb.net/"
|
|
db = client["moonlab"]
|
|
collection = db["anti_cheat"]
|
|
accounts_collection = db["website_accounts"]
|
|
delete_requests_collection = db["delete_requests"]
|
|
logs_collection = db["logs"]
|
|
user_ages_collection = db["user_ages"]
|
|
projects_collection = db["projects"]
|
|
changelogs_collection = db["changelogs"]
|
|
appointments_collection = db["appointments"]
|
|
scpsl_playerdata_collection = db["scpsl-playerdata"]
|
|
|
|
ETS2_DB_NAME = "ets2_license_db"
|
|
ETS2_COLLECTION_NAME = "licenses"
|
|
ets2_db = client[ETS2_DB_NAME]
|
|
ets2_licenses = ets2_db[ETS2_COLLECTION_NAME]
|
|
|
|
SCP_SL_API_URL = "https://api.scplist.kr/api/servers/85734"
|
|
|
|
app.config.update(
|
|
SESSION_COOKIE_HTTPONLY=True,
|
|
SESSION_COOKIE_SECURE=True,
|
|
SESSION_COOKIE_SAMESITE='Lax',
|
|
REMEMBER_COOKIE_HTTPONLY=True,
|
|
REMEMBER_COOKIE_SECURE=True,
|
|
REMEMBER_COOKIE_SAMESITE='Lax'
|
|
)
|
|
|
|
if accounts_collection.count_documents({}) == 0:
|
|
accounts_collection.insert_one({
|
|
"username": "Admin",
|
|
"display_name": "Admin",
|
|
"password": generate_password_hash("1812"),
|
|
"permissions": ["user_management", "permission_management", "delete_requests", "logs", "create_license_key",
|
|
"view_license_keys", "create_event_feedback", "view_event_feedback", "verify_age",
|
|
"project_manager", "ip_checker", "changelogs"]
|
|
})
|
|
|
|
|
|
def generate_license_key():
|
|
return str(uuid.uuid4())
|
|
|
|
|
|
def add_license_key_to_db(license_key):
|
|
if collection.find_one({"license_key": license_key}):
|
|
return False
|
|
else:
|
|
collection.insert_one({"license_key": license_key, "status": "unused"})
|
|
return True
|
|
|
|
|
|
def add_log(message):
|
|
logs_collection.insert_one({"timestamp": datetime.now(), "message": message})
|
|
|
|
|
|
def stream_logs(process):
|
|
def generate():
|
|
for line in iter(process.stdout.readline, b''):
|
|
yield line.decode('utf-8')
|
|
|
|
return Response(generate(), mimetype='text/plain')
|
|
|
|
|
|
def load_bot_config():
|
|
try:
|
|
with open("bot_config.json", "r") as file:
|
|
return json.load(file)
|
|
except FileNotFoundError:
|
|
return {}
|
|
|
|
|
|
def save_bot_config(config):
|
|
with open("bot_config.json", "w") as file:
|
|
json.dump(config, file, indent=4)
|
|
|
|
|
|
bot_config = load_bot_config()
|
|
|
|
|
|
@app.route("/website.py", methods=["GET"])
|
|
def deny_access():
|
|
return "Access denied", 403
|
|
|
|
|
|
@app.route("/", methods=["GET", "POST"])
|
|
def login():
|
|
error = None
|
|
if request.method == "POST":
|
|
username = request.form["username"]
|
|
password = request.form["password"]
|
|
remember_me = "remember_me" in request.form
|
|
|
|
user = accounts_collection.find_one({"username": username})
|
|
if user and check_password_hash(user["password"], password):
|
|
session["user_id"] = str(user["_id"])
|
|
session["username"] = user["username"]
|
|
session["display_name"] = user.get("display_name", user["username"])
|
|
session["permissions"] = user.get("permissions", [])
|
|
add_log(f"{username} hat sich eingeloggt")
|
|
|
|
if remember_me:
|
|
session.permanent = True
|
|
|
|
return redirect(url_for("dashboard"))
|
|
else:
|
|
error = "Du hast ein(en) falsches Passwort/Benutzernamen eingegeben"
|
|
return render_template("login.html", error=error)
|
|
|
|
|
|
@app.route("/dashboard")
|
|
def dashboard():
|
|
if "username" not in session:
|
|
return redirect(url_for("login"))
|
|
|
|
user = accounts_collection.find_one({"_id": ObjectId(session["user_id"])})
|
|
if not user:
|
|
return redirect(url_for("login"))
|
|
|
|
session["permissions"] = user.get("permissions", [])
|
|
|
|
if "Style" not in user:
|
|
accounts_collection.update_one({"_id": ObjectId(session["user_id"])}, {"$set": {"Style": "lightmode"}})
|
|
session["theme"] = "lightmode"
|
|
else:
|
|
session["theme"] = user["Style"]
|
|
|
|
if session["theme"] == "darkmode":
|
|
return render_template("dashboard_dark.html")
|
|
else:
|
|
return render_template("dashboard_light.html")
|
|
|
|
|
|
@app.route('/view_changelogs', methods=['GET'])
|
|
def view_changelogs():
|
|
if "username" not in session:
|
|
return redirect(url_for("login"))
|
|
changelogs = [
|
|
{"text": changelog["text"], "timestamp": changelog["timestamp"]}
|
|
for changelog in changelogs_collection.find().sort("timestamp", -1)
|
|
]
|
|
return render_template("view_changelogs.html", changelogs=changelogs)
|
|
|
|
|
|
@app.route("/user_management", methods=["GET", "POST"])
|
|
def user_management():
|
|
if "username" not in session or "user_management" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
users = accounts_collection.find()
|
|
return render_template("user_management.html", users=users)
|
|
|
|
|
|
@app.route("/add_user", methods=["POST"])
|
|
def add_user():
|
|
if "username" not in session or "user_management" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
new_username = request.form["username"]
|
|
new_display_name = request.form["display_name"]
|
|
new_password = request.form["password"]
|
|
new_permissions = request.form.getlist("permissions")
|
|
|
|
if accounts_collection.find_one({"username": new_username}):
|
|
return "Benutzername existiert bereits", 400
|
|
|
|
accounts_collection.insert_one({
|
|
"username": new_username,
|
|
"display_name": new_display_name,
|
|
"password": generate_password_hash(new_password),
|
|
"permissions": new_permissions
|
|
})
|
|
add_log(f"{session['username']} created or modified user {new_username}")
|
|
return redirect(url_for("user_management"))
|
|
|
|
|
|
@app.route("/change_permissions/<user_id>", methods=["POST"])
|
|
def change_permissions(user_id):
|
|
if "username" not in session or "permission_management" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
|
|
user = accounts_collection.find_one({"_id": ObjectId(user_id)})
|
|
if not user:
|
|
return "User not found", 404
|
|
|
|
if "remove_permission" in request.form:
|
|
permission_to_remove = request.form["remove_permission"]
|
|
accounts_collection.update_one({"_id": ObjectId(user_id)}, {"$pull": {"permissions": permission_to_remove}})
|
|
add_log(f"{session['username']} removed permission {permission_to_remove} from user {user['username']}")
|
|
|
|
if "add_permission" in request.form:
|
|
permission_to_add = request.form["add_permission"]
|
|
accounts_collection.update_one({"_id": ObjectId(user_id)}, {"$addToSet": {"permissions": permission_to_add}})
|
|
add_log(f"{session['username']} added permission {permission_to_add} to user {user['username']}")
|
|
|
|
if str(user["_id"]) == session.get("user_id"):
|
|
updated_user = accounts_collection.find_one({"_id": ObjectId(user_id)})
|
|
session["permissions"] = updated_user.get("permissions", [])
|
|
|
|
return redirect(url_for("user_management"))
|
|
|
|
|
|
@app.route("/delete_user/<user_id>", methods=["POST"])
|
|
def delete_user(user_id):
|
|
if "username" not in session or "user_management" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
user = accounts_collection.find_one({"_id": ObjectId(user_id)})
|
|
if user:
|
|
accounts_collection.delete_one({"_id": ObjectId(user_id)})
|
|
add_log(f"{session['username']} deleted user {user['username']}")
|
|
return redirect(url_for("user_management"))
|
|
|
|
|
|
UPLOAD_FOLDER = "/var/www/admin_website/static/pfps"
|
|
ALLOWED_EXTENSIONS = {"png", "jpg", "jpeg"}
|
|
|
|
|
|
def allowed_file(filename):
|
|
return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
|
|
|
|
|
|
@app.route("/edit_user/<user_id>", methods=["GET", "POST"])
|
|
def edit_user(user_id):
|
|
if "username" not in session:
|
|
return redirect(url_for("login"))
|
|
|
|
user = accounts_collection.find_one({"_id": ObjectId(user_id)})
|
|
|
|
if "permission_management" not in session["permissions"] and session["user_id"] != str(user["_id"]):
|
|
return "Access denied", 403
|
|
|
|
if request.method == "POST":
|
|
new_display_name = request.form.get("display_name")
|
|
new_password = request.form.get("password")
|
|
profile_pic = request.files.get("pfp")
|
|
|
|
update_data = {"display_name": new_display_name}
|
|
|
|
pfp_uploaded = False
|
|
pfp_url = None
|
|
|
|
if new_password:
|
|
update_data["password"] = generate_password_hash(new_password, method='scrypt')
|
|
|
|
if profile_pic and profile_pic.filename != "":
|
|
ext = profile_pic.filename.rsplit('.', 1)[-1].lower()
|
|
|
|
if ext in ["png", "jpg", "jpeg"]:
|
|
filename = f"{user_id}.png"
|
|
upload_folder = "/var/www/admin_website/static/pfps"
|
|
os.makedirs(upload_folder, exist_ok=True)
|
|
save_path = os.path.join(upload_folder, filename)
|
|
try:
|
|
img = Image.open(profile_pic.stream)
|
|
if img.mode == 'RGBA' or (img.mode == 'P' and 'transparency' in img.info):
|
|
img.save(save_path, "PNG")
|
|
else:
|
|
img = img.convert("RGB")
|
|
img.save(save_path, "PNG")
|
|
website_data = user.get("website_accounts", {})
|
|
website_data["pfp_last_updated"] = int(time.time())
|
|
website_data["pfp_filename"] = filename
|
|
update_data["website_accounts"] = website_data
|
|
pfp_uploaded = True
|
|
pfp_url = f"/static/pfps/{filename}"
|
|
except Exception as e:
|
|
print(f"Fehler beim Speichern oder Konvertieren des Profilbildes: {e}")
|
|
else:
|
|
print(f"Unerlaubter Dateityp für Profilbild: {ext}")
|
|
|
|
accounts_collection.update_one({"_id": ObjectId(user_id)}, {"$set": update_data})
|
|
|
|
if user_id == session.get("user_id"):
|
|
session["display_name"] = new_display_name
|
|
if pfp_uploaded:
|
|
session["pfp_last_updated"] = update_data["website_accounts"]["pfp_last_updated"]
|
|
|
|
if pfp_uploaded:
|
|
return jsonify({"success": True, "message": "Profilbild erfolgreich aktualisiert!", "pfp_url": pfp_url})
|
|
else:
|
|
return jsonify({"success": True, "message": "Profil erfolgreich aktualisiert!", "pfp_url": None})
|
|
|
|
return render_template("edit_user.html", user=user)
|
|
|
|
|
|
@app.route('/get_data', methods=['GET'])
|
|
def get_data():
|
|
if "username" not in session:
|
|
return redirect(url_for("login"))
|
|
data = collection.find()
|
|
result = []
|
|
for doc in data:
|
|
if 'ingame_name' in doc and doc['ingame_name']:
|
|
doc['_id'] = str(doc['_id'])
|
|
result.append(doc)
|
|
return render_template("get_data.html", data=result)
|
|
|
|
|
|
@app.route('/license=<license_key>', methods=['GET'])
|
|
def view_license(license_key):
|
|
if "username" not in session:
|
|
return redirect(url_for("login"))
|
|
license_data = collection.find_one({"license_key": license_key})
|
|
if license_data:
|
|
license_data['_id'] = str(license_data['_id'])
|
|
return render_template("view_license.html", license_data=license_data)
|
|
else:
|
|
return "Lizenzschlüssel nicht gefunden", 404
|
|
|
|
|
|
@app.route('/delete_license/<license_key>', methods=['POST'])
|
|
def delete_license(license_key):
|
|
if "username" not in session:
|
|
return redirect(url_for("login"))
|
|
collection.delete_one({"license_key": license_key})
|
|
add_log(f"{session['username']} hat Lizenzschlüssel {license_key} gelöscht")
|
|
return redirect(url_for("get_data"))
|
|
|
|
|
|
@app.route('/request_delete_license/<license_key>', methods=['POST'])
|
|
def request_delete_license(license_key):
|
|
if "username" not in session:
|
|
return redirect(url_for("login"))
|
|
delete_requests_collection.insert_one({"license_key": license_key, "username": session["username"]})
|
|
add_log(f"{session['username']} hat eine Delete-Request für Lizenzschlüssel {license_key} gestellt")
|
|
return redirect(url_for("get_data"))
|
|
|
|
|
|
@app.route('/delete_requests', methods=['GET'])
|
|
def delete_requests():
|
|
if "username" not in session or "delete_requests" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
delete_requests = list(delete_requests_collection.find())
|
|
return render_template("delete_request.html", delete_requests=delete_requests)
|
|
|
|
|
|
@app.route('/approve_delete_request/<request_id>', methods=['POST'])
|
|
def approve_delete_request(request_id):
|
|
if "username" not in session or "delete_requests" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
request = delete_requests_collection.find_one({"_id": ObjectId(request_id)})
|
|
if request:
|
|
collection.delete_one({"license_key": request["license_key"]})
|
|
delete_requests_collection.delete_one({"_id": ObjectId(request_id)})
|
|
add_log(f"{session['username']} hat die Delete-Request für Lizenzschlüssel {request['license_key']} genehmigt")
|
|
return redirect(url_for("delete_requests"))
|
|
|
|
|
|
@app.route('/deny_delete_request/<request_id>', methods=['POST'])
|
|
def deny_delete_request(request_id):
|
|
if "username" not in session or "delete_requests" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
delete_requests_collection.delete_one({"_id": ObjectId(request_id)})
|
|
add_log(f"{session['username']} hat die Delete-Request für Lizenzschlüssel {request_id} abgelehnt")
|
|
return redirect(url_for("delete_requests"))
|
|
|
|
|
|
@app.route('/add_data', methods=['POST'])
|
|
def add_data():
|
|
if "username" not in session:
|
|
return redirect(url_for("login"))
|
|
|
|
new_data = request.get_json()
|
|
|
|
result = collection.insert_one(new_data)
|
|
|
|
return jsonify({"message": "Daten erfolgreich hinzugefügt", "inserted_id": str(result.inserted_id)})
|
|
|
|
|
|
@app.route('/create_license_key', methods=['GET', 'POST'])
|
|
def create_license_key():
|
|
if "username" not in session or "create_license_key" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
if request.method == "POST":
|
|
license_key = generate_license_key()
|
|
if add_license_key_to_db(license_key):
|
|
add_log(f"{session['username']} hat Lizenzschlüssel {license_key} erstellt")
|
|
return render_template("create_license_key.html", license_key=license_key)
|
|
else:
|
|
return render_template("create_license_key.html", error="Fehler beim Erstellen des Lizenzschlüssels")
|
|
return render_template("create_license_key.html")
|
|
|
|
|
|
@app.route('/database_entries', methods=['GET'])
|
|
def database_entries():
|
|
if "username" not in session:
|
|
return redirect(url_for("login"))
|
|
data = collection.find()
|
|
result = []
|
|
for doc in data:
|
|
doc['_id'] = str(doc['_id'])
|
|
result.append(doc)
|
|
return render_template("view_license.html", data=result)
|
|
|
|
|
|
@app.route('/license_keys', methods=['GET'])
|
|
def license_keys():
|
|
if "username" not in session:
|
|
return redirect(url_for("login"))
|
|
return render_template("license_keys.html")
|
|
|
|
|
|
@app.route('/search_license_key', methods=['GET'])
|
|
def search_license_key():
|
|
license_key = request.args.get('license_key')
|
|
license_data = collection.find_one({"license_key": license_key})
|
|
if license_data:
|
|
return jsonify({"found": True})
|
|
else:
|
|
return jsonify({"found": False})
|
|
|
|
|
|
@app.route('/logs', methods=['GET'])
|
|
def logs():
|
|
if "username" not in session or "logs" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
logs = list(logs_collection.find().sort("timestamp", -1))
|
|
return render_template("logs.html", logs=logs)
|
|
|
|
|
|
@app.route('/event_feedback', methods=['GET', 'POST'])
|
|
def event_feedback():
|
|
if "username" not in session or "create_event_feedback" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
if request.method == "POST":
|
|
event_name = request.form["event_name"]
|
|
if event_name == "Anderes":
|
|
event_name = request.form["other_event_name"]
|
|
event_progress = request.form["event_progress"]
|
|
if event_progress == "Anderes":
|
|
event_progress = request.form["other_event_progress"]
|
|
event_end = request.form["event_end"]
|
|
if event_end == "Anderes":
|
|
event_end = request.form["other_event_end"]
|
|
community_feedback = request.form["community_feedback"]
|
|
if community_feedback == "Anderes":
|
|
community_feedback = request.form["other_community_feedback"]
|
|
improvement_suggestions = request.form["improvement_suggestions"]
|
|
feedback_data = {
|
|
"event_name": event_name,
|
|
"event_progress": event_progress,
|
|
"event_end": event_end,
|
|
"community_feedback": community_feedback,
|
|
"improvement_suggestions": improvement_suggestions,
|
|
"timestamp": datetime.now(),
|
|
"username": session["username"]
|
|
}
|
|
db.event_feedback.insert_one(feedback_data)
|
|
add_log(f"{session['username']} hat Feedback für das Event {event_name} abgegeben")
|
|
return redirect(url_for("dashboard"))
|
|
return render_template("event_feedback.html")
|
|
|
|
|
|
@app.route('/event=<event_id>', methods=['GET'])
|
|
def view_event_feedback(event_id):
|
|
if "username" not in session:
|
|
return redirect(url_for("login"))
|
|
feedback = db.event_feedback.find_one({"_id": ObjectId(event_id)})
|
|
if feedback:
|
|
feedback['_id'] = str(feedback['_id'])
|
|
return render_template("view_event_feedback.html", feedback=feedback)
|
|
else:
|
|
return "Event-Feedback nicht gefunden", 404
|
|
|
|
|
|
@app.route('/view_event_feedbacks', methods=['GET'])
|
|
def view_event_feedbacks():
|
|
if "username" not in session or "view_event_feedback" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
feedbacks = list(db.event_feedback.find().sort("timestamp", -1))
|
|
return render_template("view_event_feedbacks.html", feedbacks=feedbacks)
|
|
|
|
|
|
@app.route("/events", methods=["GET", "POST"])
|
|
@csrf.exempt
|
|
def events():
|
|
if "username" not in session:
|
|
return redirect(url_for("login"))
|
|
|
|
if request.method == "POST":
|
|
event_name = request.form["event_name"]
|
|
community_feedback = request.form["community_feedback"]
|
|
players = int(request.form["players"])
|
|
time = request.form["time"]
|
|
weekday = request.form["weekday"]
|
|
top = 1 if community_feedback == "top" else 0
|
|
flop = 1 if community_feedback == "flop" else 0
|
|
etwas = 1 if community_feedback == "etwas" else 0
|
|
rating = top - flop + etwas
|
|
|
|
event = db.events.find_one({"name": event_name, "time": time, "weekday": weekday})
|
|
if event:
|
|
db.events.update_one(
|
|
{"_id": event["_id"]},
|
|
{"$inc": {"top": top, "flop": flop, "etwas": etwas, "rating": rating}}
|
|
)
|
|
add_log(f"{session['username']} updated event {event_name} with rating {rating}")
|
|
else:
|
|
db.events.insert_one({
|
|
"name": event_name,
|
|
"players": players,
|
|
"time": time,
|
|
"weekday": weekday,
|
|
"top": top,
|
|
"flop": flop,
|
|
"etwas": etwas,
|
|
"rating": rating,
|
|
"timestamp": datetime.now()
|
|
})
|
|
add_log(f"{session['username']} added event {event_name} with rating {rating}")
|
|
|
|
events = list(db.events.find().sort("timestamp", -1))
|
|
best_event = None
|
|
best_events = None
|
|
if request.args.get("calculate_best"):
|
|
current_players = int(request.args.get("current_players"))
|
|
current_time = request.args.get("current_time")
|
|
current_weekday = request.args.get("current_weekday")
|
|
event_type = request.args.get("event_type", None)
|
|
best_events = calculate_best_events(current_players, current_time, current_weekday, event_type)
|
|
if best_events:
|
|
best_event = best_events[0]
|
|
|
|
return render_template("events.html", events=events, best_event=best_event)
|
|
|
|
|
|
def calculate_best_events(current_players, current_time, current_weekday, event_type=None):
|
|
events = list(db.events.find())
|
|
scored_events = []
|
|
for event in events:
|
|
similarity_score = 0
|
|
similarity_score -= abs(event['players'] - current_players) * 0.5
|
|
if event['weekday'] != current_weekday:
|
|
similarity_score -= 1
|
|
similarity_score -= abs(int(event['time'].split(':')[0]) - int(current_time.split(':')[0])) * 0.2
|
|
similarity_score += (event['rating'] * 1.0)
|
|
if event_type and event.get('type') == event_type:
|
|
similarity_score += 0.1
|
|
scored_events.append((similarity_score, event))
|
|
scored_events.sort(reverse=True, key=lambda x: x[0])
|
|
return [e for _, e in scored_events[:5]]
|
|
|
|
|
|
@app.route("/dc_bots", methods=["GET"])
|
|
def dc_bots():
|
|
if "username" not in session or "discord_bots" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
bots = list(db.dc_bots.find())
|
|
return render_template("dc_bots.html", bots=bots)
|
|
|
|
|
|
@app.route("/add_dc_bot", methods=["POST"])
|
|
def add_dc_bot():
|
|
if "username" not in session or "discord_bots" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
bot_name = request.form["bot_name"]
|
|
bot_directory = request.form["bot_directory"]
|
|
db.dc_bots.insert_one({"name": bot_name, "directory": bot_directory})
|
|
add_log(f"{session['username']} added bot {bot_name}")
|
|
return redirect(url_for("dc_bots"))
|
|
|
|
|
|
@app.route("/upload_bot_version/<bot_name>", methods=["POST"])
|
|
def upload_bot_version(bot_name):
|
|
if "username" not in session or "discord_bots" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
|
|
bot = db.dc_bots.find_one({"name": bot_name})
|
|
if not bot:
|
|
return f"Bot {bot_name} nicht gefunden", 404
|
|
|
|
if "bot_file" not in request.files:
|
|
return "Keine Datei hochgeladen", 400
|
|
|
|
bot_file = request.files["bot_file"]
|
|
if bot_file.filename == "":
|
|
return "Keine Datei ausgewählt", 400
|
|
|
|
version = bot.get("version", "1.0")
|
|
major, minor = map(int, version.split("."))
|
|
new_version = f"{major}.{minor + 1}"
|
|
|
|
base_directory_name = bot['directory'].rsplit('_v', 1)[0] if '_v' in bot['directory'] else bot['directory']
|
|
bot_directory_with_version = f"{base_directory_name}_v{new_version}"
|
|
|
|
os.makedirs(bot_directory_with_version, exist_ok=True)
|
|
bot_file.save(os.path.join(bot_directory_with_version, bot_file.filename))
|
|
|
|
db.dc_bots.update_one({"name": bot_name},
|
|
{"$set": {"directory": bot_directory_with_version, "version": new_version}})
|
|
add_log(f"{session['username']} uploaded new version {new_version} for bot {bot_name}")
|
|
|
|
return redirect(url_for("dc_bots"))
|
|
|
|
|
|
@app.route("/revert_bot_version/<bot_name>/<version>", methods=["POST"])
|
|
def revert_bot_version(bot_name, version):
|
|
if "username" not in session or "discord_bots" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
|
|
bot = db.dc_bots.find_one({"name": bot_name})
|
|
if not bot:
|
|
return f"Bot {bot_name} nicht gefunden", 404
|
|
|
|
base_directory_name = bot['directory'].rsplit('_v', 1)[0] if '_v' in bot['directory'] else bot['directory']
|
|
bot_directory = f"{base_directory_name}_v{version}"
|
|
|
|
if not os.path.exists(bot_directory):
|
|
return f"Version {version} für Bot {bot_name} nicht gefunden", 404
|
|
|
|
db.dc_bots.update_one({"name": bot_name}, {"$set": {"directory": bot_directory, "version": version}})
|
|
add_log(f"{session['username']} reverted bot {bot_name} to version {version}")
|
|
|
|
return redirect(url_for("dc_bots"))
|
|
|
|
|
|
def initialize_bot_versions():
|
|
bots = db.dc_bots.find({"version": {"$exists": False}})
|
|
for bot in bots:
|
|
db.dc_bots.update_one({"_id": bot["_id"]}, {"$set": {"version": "1.0"}})
|
|
add_log(f"Initialized version 1.0 for bot {bot['name']}")
|
|
|
|
|
|
initialize_bot_versions()
|
|
|
|
if db.events.count_documents({}) == 0:
|
|
db.events.insert_one({
|
|
"name": "Sample Event",
|
|
"top": 0,
|
|
"flop": 0,
|
|
"rating": 0,
|
|
"timestamp": datetime.now()
|
|
})
|
|
|
|
|
|
def save_logs_to_file(process, log_file_path):
|
|
try:
|
|
with open(log_file_path, "w") as log_file:
|
|
while True:
|
|
output = process.stdout.readline()
|
|
error = process.stderr.readline()
|
|
|
|
if output:
|
|
log_file.write(repr(output) + "\n")
|
|
log_file.flush()
|
|
print(output, end="")
|
|
if error:
|
|
log_file.write("[ERROR] " + repr(error) + "\n")
|
|
log_file.flush()
|
|
print("[ERROR] " + error, end="")
|
|
|
|
if process.poll() is not None:
|
|
for line in process.stdout.readlines():
|
|
log_file.write(repr(line) + "\n")
|
|
for line in process.stderr.readlines():
|
|
log_file.write("[ERROR] " + repr(line) + "\n")
|
|
break
|
|
|
|
time.sleep(0.5)
|
|
except Exception as e:
|
|
print(f"Fehler beim Speichern der Logs: {str(e)}")
|
|
|
|
|
|
@app.route("/turn_on_bot/<bot_name>", methods=["POST"])
|
|
def turn_on_bot(bot_name):
|
|
if "username" not in session or "discord_bots" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
|
|
bot = db.dc_bots.find_one({"name": bot_name})
|
|
if bot:
|
|
if "pid" in bot and psutil.pid_exists(bot["pid"]):
|
|
add_log(f"Bot {bot_name} is already running with PID {bot['pid']}")
|
|
return f"Bot {bot_name} läuft bereits.", 400
|
|
|
|
bot_directory = bot["directory"]
|
|
try:
|
|
command = ["python", bot_directory]
|
|
|
|
process = subprocess.Popen(
|
|
command,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE,
|
|
text=True
|
|
)
|
|
|
|
log_file_path = f"/tmp/{bot_name}_log.txt"
|
|
db.dc_bots.update_one({"name": bot_name}, {
|
|
"$set": {
|
|
"pid": process.pid,
|
|
"log_file": log_file_path
|
|
}
|
|
})
|
|
|
|
threading.Thread(target=save_logs_to_file, args=(process, log_file_path)).start()
|
|
|
|
bot_config[bot_name] = {"status": "on", "pid": process.pid}
|
|
save_bot_config(bot_config)
|
|
|
|
add_log(f"{session['username']} turned on {bot_name}")
|
|
except Exception as e:
|
|
add_log(f"Error starting bot {bot_name}: {str(e)}")
|
|
return f"Fehler beim Starten des Bots {bot_name}: {str(e)}", 500
|
|
else:
|
|
return f"Bot {bot_name} nicht gefunden", 404
|
|
|
|
return redirect(url_for("dc_bots"))
|
|
|
|
|
|
@app.route("/turn_off_bot/<bot_name>", methods=["POST"])
|
|
def turn_off_bot(bot_name):
|
|
if "username" not in session or "discord_bots" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
|
|
bot = db.dc_bots.find_one({"name": bot_name})
|
|
if bot and "pid" in bot:
|
|
try:
|
|
pid = bot["pid"]
|
|
|
|
if psutil.pid_exists(pid):
|
|
os.kill(pid, signal.SIGTERM)
|
|
db.dc_bots.update_one({"name": bot_name}, {"$unset": {"pid": ""}})
|
|
|
|
bot_config[bot_name] = {"status": "off"}
|
|
save_bot_config(bot_config)
|
|
|
|
add_log(f"{session['username']} turned off {bot_name}")
|
|
else:
|
|
add_log(f"Process for bot {bot_name} does not exist")
|
|
db.dc_bots.update_one({"name": bot_name}, {"$unset": {"pid": ""}})
|
|
except Exception as e:
|
|
add_log(f"Error stopping bot {bot_name}: {str(e)}")
|
|
return f"Fehler beim Stoppen des Bots {bot_name}: {str(e)}", 500
|
|
else:
|
|
return f"Bot {bot_name} nicht gefunden oder kein aktiver Prozess vorhanden", 404
|
|
|
|
return redirect(url_for("dc_bots"))
|
|
|
|
|
|
@app.route("/turn_on_all_bots", methods=["POST"])
|
|
def turn_on_all_bots():
|
|
if "username" not in session or "discord_bots" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
|
|
bots = list(db.dc_bots.find())
|
|
for bot in bots:
|
|
if "pid" not in bot or not psutil.pid_exists(bot["pid"]):
|
|
bot_directory = bot["directory"]
|
|
try:
|
|
command = ["python", bot_directory]
|
|
process = subprocess.Popen(
|
|
command,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE,
|
|
text=True
|
|
)
|
|
log_file_path = f"/tmp/{bot['name']}_log.txt"
|
|
db.dc_bots.update_one({"name": bot["name"]}, {
|
|
"$set": {
|
|
"pid": process.pid,
|
|
"log_file": log_file_path
|
|
}
|
|
})
|
|
threading.Thread(target=save_logs_to_file, args=(process, log_file_path)).start()
|
|
|
|
bot_config[bot["name"]] = {"status": "on", "pid": process.pid}
|
|
save_bot_config(bot_config)
|
|
|
|
add_log(f"{session['username']} turned on {bot['name']}")
|
|
except Exception as e:
|
|
add_log(f"Error starting bot {bot['name']}: {str(e)}")
|
|
|
|
return redirect(url_for("dc_bots"))
|
|
|
|
|
|
@app.route("/turn_off_all_bots", methods=["POST"])
|
|
def turn_off_all_bots():
|
|
if "username" not in session or "discord_bots" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
|
|
bots = list(db.dc_bots.find())
|
|
for bot in bots:
|
|
if "pid" in bot:
|
|
try:
|
|
pid = bot["pid"]
|
|
if psutil.pid_exists(pid):
|
|
os.kill(pid, signal.SIGTERM)
|
|
db.dc_bots.update_one({"name": bot["name"]}, {"$unset": {"pid": ""}})
|
|
|
|
bot_config[bot["name"]] = {"status": "off"}
|
|
save_bot_config(bot_config)
|
|
|
|
add_log(f"{session['username']} turned off {bot['name']}")
|
|
else:
|
|
add_log(f"Process for bot {bot['name']} does not exist")
|
|
db.dc_bots.update_one({"name": bot["name"]}, {"$unset": {"pid": ""}})
|
|
except Exception as e:
|
|
add_log(f"Error stopping bot {bot['name']}: {str(e)}")
|
|
|
|
return redirect(url_for("dc_bots"))
|
|
|
|
|
|
@app.route("/bot_logs/<bot_name>", methods=["GET"])
|
|
def bot_logs(bot_name):
|
|
if "username" not in session or "discord_bots" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
|
|
bot = db.dc_bots.find_one({"name": bot_name})
|
|
if bot and "log_file" in bot:
|
|
log_file_path = bot["log_file"]
|
|
|
|
try:
|
|
with open(log_file_path, "r") as log_file:
|
|
logs = log_file.readlines()
|
|
except FileNotFoundError:
|
|
logs = ["Keine Logs gefunden."]
|
|
|
|
return render_template("bot_logs.html", bot_name=bot_name, logs=logs)
|
|
else:
|
|
return f"Logs für Bot {bot_name} nicht gefunden", 404
|
|
|
|
|
|
def start_bots_on_server_start():
|
|
for bot_name, config in bot_config.items():
|
|
if config["status"] == "on":
|
|
bot = db.dc_bots.find_one({"name": bot_name})
|
|
if bot:
|
|
if "pid" in bot and psutil.pid_exists(bot["pid"]):
|
|
add_log(f"Bot {bot_name} is already running with PID {bot['pid']}")
|
|
continue
|
|
|
|
bot_directory = bot["directory"]
|
|
try:
|
|
command = ["python", bot_directory]
|
|
process = subprocess.Popen(
|
|
command,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE,
|
|
text=True
|
|
)
|
|
log_file_path = f"/tmp/{bot_name}_log.txt"
|
|
db.dc_bots.update_one({"name": bot_name}, {
|
|
"$set": {
|
|
"pid": process.pid,
|
|
"log_file": log_file_path
|
|
}
|
|
})
|
|
threading.Thread(target=save_logs_to_file, args=(process, log_file_path)).start()
|
|
|
|
bot_config[bot_name] = {"status": "on", "pid": process.pid}
|
|
save_bot_config(bot_config)
|
|
|
|
add_log(f"Bot {bot_name} automatically started on server start")
|
|
except Exception as e:
|
|
add_log(f"Error starting bot {bot_name} on server start: {str(e)}")
|
|
|
|
|
|
start_bots_on_server_start()
|
|
|
|
|
|
@app.route('/logout')
|
|
def logout():
|
|
add_log(f"{session['username']} hat sich ausgeloggt")
|
|
session.pop("username", None)
|
|
session.pop("permissions", None)
|
|
session.pop("user_id", None)
|
|
return redirect(url_for("login"))
|
|
|
|
|
|
@app.route('/toggle-theme', methods=['POST'])
|
|
@csrf.exempt
|
|
def toggle_theme():
|
|
if "username" not in session:
|
|
return "Unauthorized", 401
|
|
|
|
user = accounts_collection.find_one({"_id": ObjectId(session["user_id"])})
|
|
if not user:
|
|
return "User not found", 404
|
|
|
|
current_theme = user.get("Style", "lightmode")
|
|
new_theme = "darkmode" if current_theme == "lightmode" else "lightmode"
|
|
|
|
accounts_collection.update_one({"_id": ObjectId(session["user_id"])}, {"$set": {"Style": new_theme}})
|
|
session["theme"] = new_theme
|
|
|
|
return "", 204
|
|
|
|
|
|
@app.route("/ip_checker", methods=["GET", "POST"])
|
|
def ip_checker():
|
|
if "username" not in session or "ip_checker" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
|
|
import ipaddress
|
|
|
|
ip_data = None
|
|
error = None
|
|
similar_ips = []
|
|
is_cheater_network = False
|
|
similar_cheater_ips = []
|
|
|
|
if request.method == "POST":
|
|
ip_address = request.form.get("ip_address")
|
|
is_cheater = request.form.get("is_cheater") == "yes"
|
|
steam_id = request.form.get("steam_id") if is_cheater else None
|
|
|
|
if not ip_address:
|
|
error = "Bitte eine IP-Adresse eingeben."
|
|
elif is_cheater and not steam_id:
|
|
error = "SteamID ist erforderlich, wenn die IP als Cheater markiert wird."
|
|
else:
|
|
try:
|
|
api_key = "015ada9472664329affb2f26d7036d47"
|
|
response = requests.get(f"https://vpnapi.io/api/{ip_address}?key={api_key}")
|
|
if response.status_code == 200:
|
|
ip_data = response.json()
|
|
|
|
if "security" not in ip_data or not isinstance(ip_data["security"], dict):
|
|
ip_data["security"] = {}
|
|
if "location" not in ip_data or not isinstance(ip_data["location"], dict):
|
|
ip_data["location"] = {}
|
|
if "network" not in ip_data or not isinstance(ip_data["network"], dict):
|
|
ip_data["network"] = {}
|
|
|
|
checked_network = None
|
|
if "network" in ip_data and "network" in ip_data["network"]:
|
|
cidr = str(ip_data["network"]["network"]).replace(" ", "")
|
|
try:
|
|
checked_network = ipaddress.ip_network(cidr, strict=False)
|
|
except Exception:
|
|
checked_network = None
|
|
|
|
cheater_ips = list(db.ip_infos.find({"is_cheater": True}))
|
|
for cheater in cheater_ips:
|
|
cheater_data = cheater.get("data", {})
|
|
cheater_network = None
|
|
if "network" in cheater_data and "network" in cheater_data["network"]:
|
|
cheater_cidr = str(cheater_data["network"]["network"]).replace(" ", "")
|
|
try:
|
|
cheater_network = ipaddress.ip_network(cheater_cidr, strict=False)
|
|
except Exception:
|
|
cheater_network = None
|
|
cheater_ip = cheater.get("ip")
|
|
if cheater_network and checked_network:
|
|
if checked_network.overlaps(cheater_network):
|
|
is_cheater_network = True
|
|
similar_cheater_ips.append(cheater)
|
|
if cheater_ip and checked_network:
|
|
try:
|
|
if ipaddress.ip_address(cheater_ip) in checked_network:
|
|
is_cheater_network = True
|
|
similar_cheater_ips.append(cheater)
|
|
except Exception:
|
|
pass
|
|
|
|
similar_ips = list(db.ip_infos.find({
|
|
"$or": [
|
|
{"ip": ip_address},
|
|
{"data.location.city": ip_data["location"].get("city")},
|
|
{"data.network.autonomous_system_number": ip_data["network"].get(
|
|
"autonomous_system_number")}
|
|
]
|
|
}))
|
|
|
|
db.ip_infos.insert_one({
|
|
"ip": ip_address,
|
|
"is_cheater": is_cheater,
|
|
"steam_id": steam_id,
|
|
"data": ip_data,
|
|
"added_by": session["username"],
|
|
"timestamp": datetime.now()
|
|
})
|
|
else:
|
|
error = "Fehler beim Abrufen der IP-Daten."
|
|
except Exception as e:
|
|
error = f"Fehler: {str(e)}"
|
|
|
|
return render_template(
|
|
"ip_checker.html",
|
|
ip_data=ip_data,
|
|
error=error,
|
|
similar_ips=similar_ips,
|
|
is_cheater_network=is_cheater_network,
|
|
similar_cheater_ips=similar_cheater_ips
|
|
)
|
|
|
|
|
|
@app.route('/add-changelog', methods=['GET', 'POST'])
|
|
def add_changelog():
|
|
if 'changelogs' not in session.get('permissions', []):
|
|
return "Unauthorized", 403
|
|
|
|
if request.method == 'POST':
|
|
changelog_text = request.form.get('changelog')
|
|
if changelog_text:
|
|
changelogs_collection.insert_one({
|
|
'text': changelog_text,
|
|
'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
|
})
|
|
return redirect(url_for('dashboard'))
|
|
|
|
return render_template('add_changelog.html')
|
|
|
|
|
|
@app.route("/appointments", methods=["GET", "POST"])
|
|
def appointments():
|
|
if "username" not in session or "appointments" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
|
|
if request.method == "POST":
|
|
title = request.form["title"]
|
|
start_date = request.form["start_date"]
|
|
end_date = request.form["end_date"]
|
|
description = request.form.get("description", "")
|
|
|
|
appointments_collection.insert_one({
|
|
"username": session["username"],
|
|
"title": title,
|
|
"start_date": start_date,
|
|
"end_date": end_date,
|
|
"description": description,
|
|
"created_at": datetime.now()
|
|
})
|
|
|
|
add_log(f"{session['username']} hat einen neuen Termin erstellt: {title}")
|
|
|
|
return redirect(url_for("appointments"))
|
|
|
|
user_appointments = list(appointments_collection.find({"username": session["username"]}).sort("start_date", 1))
|
|
|
|
return render_template("appointments.html", appointments=user_appointments)
|
|
|
|
|
|
@app.route("/delete_appointment/<appointment_id>", methods=["POST"])
|
|
def delete_appointment(appointment_id):
|
|
if "username" not in session or "appointments" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
|
|
appointment = appointments_collection.find_one({"_id": ObjectId(appointment_id), "username": session["username"]})
|
|
if appointment:
|
|
appointments_collection.delete_one({"_id": ObjectId(appointment_id)})
|
|
add_log(f"{session['username']} hat den Termin '{appointment['title']}' gelöscht")
|
|
|
|
return redirect(url_for("appointments"))
|
|
|
|
|
|
@app.route("/edit_appointment/<appointment_id>", methods=["GET", "POST"])
|
|
def edit_appointment(appointment_id):
|
|
if "username" not in session or "appointments" not in session["permissions"]:
|
|
return redirect(url_for("login"))
|
|
|
|
appointment = appointments_collection.find_one({"_id": ObjectId(appointment_id), "username": session["username"]})
|
|
if not appointment:
|
|
return "Termin nicht gefunden", 404
|
|
|
|
if request.method == "POST":
|
|
title = request.form["title"]
|
|
start_date = request.form["start_date"]
|
|
end_date = request.form["end_date"]
|
|
description = request.form.get("description", "")
|
|
|
|
appointments_collection.update_one(
|
|
{"_id": ObjectId(appointment_id)},
|
|
{"$set": {
|
|
"title": title,
|
|
"start_date": start_date,
|
|
"end_date": end_date,
|
|
"description": description
|
|
}}
|
|
)
|
|
|
|
add_log(f"{session['username']} hat den Termin '{title}' bearbeitet")
|
|
|
|
return redirect(url_for("appointments"))
|
|
|
|
return render_template("edit_appointment.html", appointment=appointment)
|
|
|
|
|
|
@app.route("/pcmachwas", methods=["GET", "POST"])
|
|
def pcmachwas():
|
|
return render_template("stinker.html")
|
|
|
|
|
|
@app.route("/settings", methods=["GET"])
|
|
def settings():
|
|
if "username" not in session:
|
|
return redirect(url_for("login"))
|
|
|
|
return redirect(url_for("edit_user", user_id=session["user_id"]))
|
|
|
|
|
|
@app.route("/ets2_map_cracked")
|
|
def ets2_map_cracked():
|
|
scs_dir = "/var/www/admin_website/static/ets2_map_cracked"
|
|
if not os.path.isdir(scs_dir):
|
|
return f"Verzeichnis nicht gefunden oder keine Rechte: {scs_dir}", 404
|
|
try:
|
|
files = [
|
|
f for f in os.listdir(scs_dir)
|
|
if f.endswith(".scs") and os.path.isfile(os.path.join(scs_dir, f))
|
|
]
|
|
except Exception as e:
|
|
return f"Fehler beim Lesen des Verzeichnisses: {e}", 500
|
|
if not files:
|
|
return "Keine .scs Dateien gefunden.", 404
|
|
links = "".join(
|
|
f'<a href="/download_ets2_map_cracked/{fname}" download id="dl_{i}" style="display:none"></a>'
|
|
for i, fname in enumerate(files)
|
|
)
|
|
js = f"""
|
|
<script>
|
|
const files = {files!r};
|
|
let idx = 0;
|
|
function downloadNext() {{
|
|
if(idx >= files.length) return;
|
|
document.getElementById('dl_' + idx).click();
|
|
idx++;
|
|
setTimeout(downloadNext, 1000);
|
|
}}
|
|
window.onload = downloadNext;
|
|
</script>
|
|
"""
|
|
return f"<h2>ETS2 Maps Cracked Downloads</h2>{links}{js}<p>Downloads werden automatisch gestartet...</p>"
|
|
|
|
|
|
@app.route("/download_ets2_map_cracked/<filename>")
|
|
def download_ets2_map_cracked(filename):
|
|
scs_dir = "/var/www/admin_website/static/ets2_map_cracked"
|
|
file_path = os.path.join(scs_dir, filename)
|
|
if os.path.isfile(file_path) and filename.endswith(".scs"):
|
|
return send_file(file_path, as_attachment=True)
|
|
return "Datei nicht gefunden.", 404
|
|
|
|
|
|
# wallpaper
|
|
@app.route("/wallpaper")
|
|
def wallpaper():
|
|
return render_template("wallpaper.html")
|
|
|
|
|
|
# NEUE PROXY-ROUTE für die SCP:SL API
|
|
@app.route('/api/scpsl_proxy')
|
|
def scpsl_proxy():
|
|
try:
|
|
response = requests.get(SCP_SL_API_URL, timeout=5)
|
|
response.raise_for_status()
|
|
return jsonify(response.json())
|
|
except requests.exceptions.Timeout:
|
|
return jsonify({"error": "Request timed out"}), 504
|
|
except requests.exceptions.ConnectionError:
|
|
return jsonify({"error": "Connection error"}), 503
|
|
except requests.exceptions.RequestException as e:
|
|
return jsonify({"error": f"Failed to fetch data: {e}"}), 500
|
|
|
|
|
|
def fetch_and_store_player_count():
|
|
with app.app_context():
|
|
try:
|
|
response = requests.get(SCP_SL_API_URL, timeout=5)
|
|
response.raise_for_status()
|
|
data = response.json()
|
|
players_str_full = data.get('players', '0/0')
|
|
current_players = 0
|
|
if '/' in players_str_full:
|
|
try:
|
|
current_players = int(players_str_full.split('/')[0])
|
|
except ValueError:
|
|
current_players = 0
|
|
else:
|
|
try:
|
|
current_players = int(players_str_full)
|
|
except ValueError:
|
|
current_players = 0
|
|
scpsl_playerdata_collection.insert_one({
|
|
"timestamp": datetime.utcnow(),
|
|
"players": current_players
|
|
})
|
|
scpsl_playerdata_collection.create_index("timestamp")
|
|
except requests.exceptions.RequestException as e:
|
|
print(f"Error fetching player count: {e}")
|
|
except Exception as e:
|
|
print(f"Unexpected error fetching/storing to MongoDB: {e}")
|
|
|
|
|
|
def background_task():
|
|
while True:
|
|
fetch_and_store_player_count()
|
|
time.sleep(60)
|
|
|
|
|
|
threading.Thread(target=background_task, daemon=True).start()
|
|
|
|
|
|
@app.route('/api/player_history')
|
|
def player_history_api():
|
|
graph_data = []
|
|
one_day_ago = datetime.utcnow() - timedelta(hours=24)
|
|
history_cursor = scpsl_playerdata_collection.find(
|
|
{"timestamp": {"$gte": one_day_ago}},
|
|
{"_id": 0, "timestamp": 1, "players": 1}
|
|
).sort("timestamp", 1)
|
|
|
|
zero_start = None
|
|
for doc in history_cursor:
|
|
t = doc["timestamp"]
|
|
p = doc["players"]
|
|
if p == 0:
|
|
if zero_start is None:
|
|
zero_start = t
|
|
continue
|
|
else:
|
|
if zero_start is not None:
|
|
duration = (t - zero_start).total_seconds()
|
|
if duration > 20:
|
|
graph_data.append({
|
|
"time": zero_start.isoformat() + "Z",
|
|
"players": 0
|
|
})
|
|
graph_data.append({
|
|
"time": t.isoformat() + "Z",
|
|
"players": p
|
|
})
|
|
zero_start = None
|
|
graph_data.append({
|
|
"time": t.isoformat() + "Z",
|
|
"players": p
|
|
})
|
|
if zero_start is not None:
|
|
last_time = datetime.utcnow()
|
|
duration = (last_time - zero_start).total_seconds()
|
|
if duration > 20:
|
|
graph_data.append({
|
|
"time": zero_start.isoformat() + "Z",
|
|
"players": 0
|
|
})
|
|
graph_data.append({
|
|
"time": last_time.isoformat() + "Z",
|
|
"players": 0
|
|
})
|
|
return jsonify(graph_data)
|
|
|
|
|
|
@app.route('/player_history_graph')
|
|
def player_history_graph():
|
|
html = """
|
|
<html>
|
|
<head><title>SCP:SL Player Count (Letzte 24h)</title></head>
|
|
<body style="background:#1a1a1a;">
|
|
<img id="player_graph" src="/player_history_graph_img" style="width:90vw;max-width:1200px;border:2px solid #444;">
|
|
<script>
|
|
setInterval(function() {
|
|
var img = document.getElementById('player_graph');
|
|
img.src = '/player_history_graph_img?ts=' + new Date().getTime();
|
|
}, 10000);
|
|
</script>
|
|
</body>
|
|
</html>
|
|
"""
|
|
return html
|
|
|
|
|
|
@app.route('/player_history_graph_img')
|
|
def player_history_graph_img():
|
|
one_day_ago = datetime.utcnow() - timedelta(hours=24)
|
|
history_cursor = scpsl_playerdata_collection.find(
|
|
{"timestamp": {"$gte": one_day_ago}},
|
|
{"_id": 0, "timestamp": 1, "players": 1}
|
|
).sort("timestamp", 1)
|
|
zero_start = None
|
|
filtered_times = []
|
|
filtered_players = []
|
|
for doc in history_cursor:
|
|
t = doc["timestamp"]
|
|
p = doc["players"]
|
|
if p == 0:
|
|
if zero_start is None:
|
|
zero_start = t
|
|
continue
|
|
else:
|
|
if zero_start is not None:
|
|
duration = (t - zero_start).total_seconds()
|
|
if duration > 20:
|
|
filtered_times.append(zero_start)
|
|
filtered_players.append(0)
|
|
filtered_times.append(t)
|
|
filtered_players.append(p)
|
|
zero_start = None
|
|
filtered_times.append(t)
|
|
filtered_players.append(p)
|
|
if zero_start is not None:
|
|
last_time = datetime.utcnow()
|
|
duration = (last_time - zero_start).total_seconds()
|
|
if duration > 20:
|
|
filtered_times.append(zero_start)
|
|
filtered_players.append(0)
|
|
filtered_times.append(last_time)
|
|
filtered_players.append(0)
|
|
fig, ax = plt.subplots(figsize=(10, 6))
|
|
if not filtered_times:
|
|
ax.text(0.5, 0.5, 'No player data available for the last 24 hours.',
|
|
horizontalalignment='center', verticalalignment='center', transform=ax.transAxes, fontsize=12, color='red')
|
|
ax.set_ylim(bottom=0, top=36)
|
|
else:
|
|
ax.plot(filtered_times, filtered_players, color='lime', linewidth=2)
|
|
max_players_in_history = max(filtered_players) if filtered_players else 0
|
|
if max_players_in_history > 0:
|
|
ax.set_ylim(bottom=0, top=max_players_in_history + 5)
|
|
else:
|
|
ax.set_ylim(bottom=0, top=36)
|
|
ax.set_title('SCP:SL Player Count (Letzte 24h)', color='white')
|
|
ax.set_xlabel('Zeit', color='white')
|
|
ax.set_ylabel('Spieleranzahl', color='white')
|
|
ax.set_facecolor('#1a1a1a')
|
|
fig.patch.set_facecolor('#1a1a1a')
|
|
ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
|
|
ax.xaxis.set_major_locator(mdates.HourLocator(interval=3))
|
|
fig.autofmt_xdate()
|
|
ax.tick_params(axis='x', colors='white')
|
|
ax.tick_params(axis='y', colors='white')
|
|
ax.yaxis.set_major_locator(plt.MaxNLocator(integer=True))
|
|
ax.grid(True, linestyle='--', alpha=0.5, color='#444444')
|
|
ax.spines['bottom'].set_color('white')
|
|
ax.spines['top'].set_color('white')
|
|
ax.spines['left'].set_color('white')
|
|
ax.spines['right'].set_color('white')
|
|
buffer = BytesIO()
|
|
plt.savefig(buffer, format='png', bbox_inches='tight', dpi=100)
|
|
buffer.seek(0)
|
|
plt.close(fig)
|
|
return send_file(buffer, mimetype='image/png')
|
|
|
|
|
|
# Voice-Channel Übersicht
|
|
@app.route("/vcs")
|
|
def vcs_overview():
|
|
# Beispiel: Channels können dynamisch sein, hier statisch
|
|
channels = [
|
|
{"id": "talk1", "name": "Teamtalk"},
|
|
{"id": "talk2", "name": "Privat"},
|
|
{"id": "talk3", "name": "Privat 2"}
|
|
]
|
|
return render_template("schisscord.html", channels=channels)
|
|
|
|
|
|
# Voice-Channel Join
|
|
@app.route("/join/<channel_id>")
|
|
def join_vc(channel_id):
|
|
if "username" not in session:
|
|
return redirect(url_for("login"))
|
|
return render_template("vc_room.html", channel_id=channel_id, username=session["username"])
|
|
|
|
|
|
# SocketIO: Nutzer tritt Channel bei
|
|
@socketio.on("join_channel")
|
|
def handle_join_channel(data):
|
|
channel = data.get("channel")
|
|
username = data.get("username")
|
|
join_room(channel)
|
|
emit("user_joined", {"username": username}, room=channel)
|
|
|
|
|
|
@socketio.on("leave_channel")
|
|
def handle_leave_channel(data):
|
|
channel = data.get("channel")
|
|
username = data.get("username")
|
|
leave_room(channel)
|
|
emit("user_left", {"username": username}, room=channel)
|
|
|
|
|
|
@socketio.on("signal")
|
|
def handle_signal(data):
|
|
channel = data.get("channel")
|
|
signal_data = data.get("signal")
|
|
sender = data.get("username")
|
|
emit("signal", {"signal": signal_data, "username": sender}, room=channel, include_self=False)
|
|
|
|
|
|
MONGO_URI = "mongodb+srv://MrSniff:5169Galaxy@chainsaw.d0shx.mongodb.net/"
|
|
client = MongoClient(MONGO_URI)
|
|
ETS2_DB_NAME = "ets2_license_db"
|
|
ETS2_COLLECTION_NAME = "licenses"
|
|
ets2_db = client[ETS2_DB_NAME]
|
|
ets2_licenses = ets2_db[ETS2_COLLECTION_NAME]
|
|
print(f"[DEBUG] Using DB: {ETS2_DB_NAME}, Collection: {ETS2_COLLECTION_NAME}")
|
|
|
|
# --- DLC Folder ---
|
|
DLC_FOLDER = "/var/www/admin_website/static/ets2_dlcs"
|
|
|
|
# --- License Check Endpoint ---
|
|
@app.route("/checklicense", methods=["GET"])
|
|
def check_license():
|
|
key = request.args.get("key")
|
|
user = request.args.get("user")
|
|
print(f"[DEBUG] /checklicense called with key='{key}' user='{user}'")
|
|
|
|
if not key or not user:
|
|
print("[DEBUG] Missing key or user")
|
|
return "invalid", 400
|
|
|
|
entry = ets2_licenses.find_one({"license_key": key})
|
|
print(f"[DEBUG] MongoDB entry found: {entry}")
|
|
|
|
if entry:
|
|
if not entry.get("windows_user"):
|
|
ets2_licenses.update_one({"license_key": key}, {"$set": {"windows_user": user}})
|
|
print(f"[DEBUG] Key '{key}' registered to user '{user}'")
|
|
return "valid"
|
|
elif entry["windows_user"] == user:
|
|
print(f"[DEBUG] Key '{key}' valid for user '{user}'")
|
|
return "valid"
|
|
else:
|
|
print(f"[DEBUG] Key '{key}' already used by another user '{entry['windows_user']}'")
|
|
return "invalid_user"
|
|
else:
|
|
print(f"[DEBUG] Key '{key}' not found in database")
|
|
return "invalid"
|
|
|
|
# --- DLC Download Endpoint ---
|
|
@app.route("/download", methods=["GET"])
|
|
def download_dlc():
|
|
key = request.headers.get("License-Key")
|
|
user = request.headers.get("Windows-User")
|
|
dlc_type = request.args.get("type", "all") # "all_map_dlcs" oder "all_dlcs"
|
|
print(f"[DEBUG] /download called with key='{key}', user='{user}', type='{dlc_type}'")
|
|
|
|
if not key or not user:
|
|
print("[DEBUG] Missing headers")
|
|
return "missing_headers", 400
|
|
|
|
entry = ets2_licenses.find_one({"license_key": key})
|
|
print(f"[DEBUG] MongoDB entry for download: {entry}")
|
|
|
|
if not entry or entry.get("windows_user") != user:
|
|
print(f"[DEBUG] Unauthorized access for key '{key}' user '{user}'")
|
|
return "unauthorized", 403
|
|
|
|
# Bestimme die Datei basierend auf DLC Typ
|
|
if dlc_type == "all_map_dlcs":
|
|
file_name = "all_map_dlcs.zip"
|
|
else:
|
|
file_name = "all_dlcs.zip"
|
|
|
|
file_path = os.path.join(DLC_FOLDER, file_name)
|
|
if not os.path.exists(file_path):
|
|
print(f"[DEBUG] File not found at {file_path}")
|
|
return "not_found", 404
|
|
|
|
print(f"[DEBUG] Sending file {file_path} to user '{user}'")
|
|
return send_file(file_path, as_attachment=True)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
print("[DEBUG] Starting ETS2 DLC Server")
|
|
print(f"[DEBUG] Using DB: {ETS2_DB_NAME}, Collection: {ETS2_COLLECTION_NAME}")
|
|
socketio.run(app, debug=True, host='0.0.0.0', port=5000)
|