From b11c8aceed8bbaaea7e22527b9af33941d3ca0cb Mon Sep 17 00:00:00 2001 From: admin Date: Fri, 24 Jul 2026 15:35:00 +0000 Subject: [PATCH] Upload files to "routes" --- routes/media.py | 77 ++++ routes/misc.py | 1008 ++++++++++++++++++++++++++++++++++++++++++ routes/music.py | 111 +++++ routes/nameserver.py | 551 +++++++++++++++++++++++ routes/players.py | 296 +++++++++++++ 5 files changed, 2043 insertions(+) create mode 100644 routes/media.py create mode 100644 routes/misc.py create mode 100644 routes/music.py create mode 100644 routes/nameserver.py create mode 100644 routes/players.py diff --git a/routes/media.py b/routes/media.py new file mode 100644 index 0000000..8941c69 --- /dev/null +++ b/routes/media.py @@ -0,0 +1,77 @@ + +import mimetypes +import os + +from flask import Blueprint, Response, abort + +bp = Blueprint("media", __name__) + +_PUBLIC_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "public") +_VIDEOS_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "Videos") + +_EXTRACTED_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "gamecode", "extracted") + +_VIDEO_EXTS = {".mp4", ".webm", ".mov", ".avi", ".mkv", ".m4v"} +_IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"} +_AUDIO_EXTS = {".ogg", ".wav", ".mp3", ".fsb"} +_FONT_EXTS = {".ttf", ".otf"} +_ALLOWED_EXTS = _VIDEO_EXTS | _IMAGE_EXTS | _AUDIO_EXTS | _FONT_EXTS | {".json", ".txt", ".svg", ".dll", ".shader", ".xml", ".bytes"} + + +def _serve_file(directory, filename): + path = os.path.realpath(os.path.join(directory, filename)) + if not path.startswith(os.path.realpath(directory) + os.sep): + abort(403) + safe_name = os.path.basename(path) + + if not os.path.isfile(path): + abort(404) + + ext = os.path.splitext(safe_name)[1].lower() + if ext not in _ALLOWED_EXTS: + abort(403) + + mime = mimetypes.guess_type(safe_name)[0] or "application/octet-stream" + size = os.path.getsize(path) + + def stream(): + with open(path, "rb") as f: + while True: + chunk = f.read(65536) + if not chunk: + break + yield chunk + + return Response( + stream(), + 200, + { + "Content-Type": mime, + "Content-Length": size, + "Accept-Ranges": "bytes", + "Cache-Control": "public, max-age=3600", + }, + ) + + +@bp.route("/public/", methods=["GET"]) +def serve_public(filename): + return _serve_file(_PUBLIC_DIR, filename) + + +@bp.route("/Videos/", methods=["GET"]) +def serve_video(filename): + resp = _serve_file(_VIDEOS_DIR, filename) + resp.headers["Cache-Control"] = "no-store, no-cache, must-revalidate, max-age=0" + resp.headers["CDN-Cache-Control"] = "no-store" + return resp + + +_VALID_ASSET_CATS = {"Texture2D", "Sprite", "AudioClip", "Font", "TextAsset", "Shader", "MonoBehaviour"} + +@bp.route("/assets//", methods=["GET"]) +def serve_extracted_asset(category, filename): + if category not in _VALID_ASSET_CATS: + abort(404) + asset_dir = os.path.join(_EXTRACTED_DIR, category) + return _serve_file(asset_dir, filename) diff --git a/routes/misc.py b/routes/misc.py new file mode 100644 index 0000000..884834c --- /dev/null +++ b/routes/misc.py @@ -0,0 +1,1008 @@ + +import json +import os +import re +import threading +import time +import uuid +from collections import deque +from datetime import datetime, timezone, timedelta +from flask import Blueprint, request, jsonify, Response +from urllib.parse import unquote_plus + +from core.auth import check_auth, get_current_profile_id +from core.limiter import limiter +from core.state import db, session_mgr +from core.config import base_url as _base_url +from core.profanity import is_hate_speech as _is_hate_speech + +_groups: dict = {} +_groups_lock = threading.Lock() +_groups_counter: list = [0] + +_ROYALE_TIERS = [ + (0, "Rookie", 0, 500), + (500, "Bronze", 500, 1500), + (1500, "Silver", 1500, 3500), + (3500, "Gold", 3500, 7000), + (7000, "Platinum", 7000, 12000), + (12000, "Diamond", 12000, 20000), + (20000, "Champion", 20000, 20000), +] + +def _royale_stats(xp: int) -> dict: + tier = _ROYALE_TIERS[0] + for i, t in enumerate(_ROYALE_TIERS): + if xp >= t[0]: + tier = t + else: + break + idx = _ROYALE_TIERS.index(tier) + return { + "TotalXP": xp, + "Level": idx + 1, + "RankIdx": idx, + "RankName": tier[1], + "CurrentLevelXPThreshold": tier[2], + "NextLevelXPThreshold": tier[3], + "NextLevelAcornReward": idx * 25, + } + +def _get_royale_xp(pid: int) -> int: + settings = db.get_settings(pid) + for s in settings: + if s["Key"] == "royale_xp": + try: + return int(s["Value"]) + except (ValueError, TypeError): + return 0 + return 0 + +def _build_group_dict(g: dict) -> dict: + gid = g["GroupId"] + member_pids = g.get("_member_pids", []) + return { + "GroupId": gid, + "Name": g.get("Name", ""), + "Description": g.get("Description", ""), + "CreatedAt": g.get("CreatedAt", datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")), + "ImageName": g.get("ImageName", ""), + "BanStatus": 0, + "CreatorId": g.get("CreatorId", 0), + "NumMembers": len(member_pids), + "Members": [{"GroupId": gid, "PlayerId": p, "Permissions": 0} for p in member_pids], + } + +_MEMORY_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "uploads", "memories") +os.makedirs(_MEMORY_DIR, exist_ok=True) + +def _build_slur_re(): + _PATTERNS = [ + r"n[i1!|][gq9][gq9][e3]r", + r"n[i1!|][gq9][gq9][ae3]", + r"n[i1!|][gq9][gq9][ae3][sz]", + r"f[a4][gq9][gq9][o0]t", + r"f[a4][gq9][gq9][o0]t[sz]", + r"f[a4][gq9]", + r"ch[i1][nk][gq][sz]?", + r"g[o0][o0]k[sz]?", + r"sp[i1][cks][sz]?", + r"w[e3]tb[a4][cks][gq][sz]?", + r"k[i1][ck][e3][sz]?", + r"j[e3]w[sz]?\b", + r"h[e3][e3]b[sz]?", + r"cr[a4][cks][gq][e3]r[sz]?", + r"j[i1][gq][a4]b[o0][o0]", + r"t[o0]w[e3]lh[e3][a4]d", + r"r[e3]t[a4]rd", + r"tr[a4]nn[yi1][e3]?[sz]?", + r"[sz]h[e3]m[a4][l1][e3]", + ] + combined = "|".join(r"(? None: + try: + if os.path.exists(_SANITIZE_LOG_FILE): + with open(_SANITIZE_LOG_FILE) as f: + entries = json.load(f) + for e in reversed(entries[:500]): + _sanitize_log.appendleft(e) + except Exception as e: + print(f"[Sanitize] Failed to load log: {e}") + +def _save_sanitize_log() -> None: + try: + with open(_SANITIZE_LOG_FILE, "w") as f: + json.dump(list(_sanitize_log), f) + except Exception as e: + print(f"[Sanitize] Failed to save log: {e}") + +def _is_pure(text: str) -> bool: + return _SLUR_RE.search(text) is None + +def get_sanitize_log(): + return list(_sanitize_log) + +_load_sanitize_log() + +bp = Blueprint("misc", __name__) + +@bp.route("/discord", methods=["GET"]) +def discord_redirect(): + from flask import redirect + return redirect("https://discord.gg/n43M7dCBQX", 302) + +@bp.route("/api/playerevents/v1/all", methods=["GET"]) +@check_auth +def get_all_player_events(): + events = db.get_active_events() + created = [] + for e in events: + created.append({ + "EventId": e["id"], + "Name": e["name"], + "Description": e["description"], + "StartTime": e["start_time"], + "EndTime": e["end_time"], + "PosterImageName": e["poster_image"], + "CreatorPlayerId": e["creator_player_id"], + }) + return jsonify({"Created": created, "Responses": []}) + +@bp.route("/api/playerevents/v1/", methods=["GET"]) +@check_auth +def get_player_event(event_id): + e = db.get_event(event_id) + if not e: + return Response("Not Found", 404) + return jsonify({ + "EventId": e["id"], + "Name": e["name"], + "Description": e["description"], + "StartTime": e["start_time"], + "EndTime": e["end_time"], + "PosterImageName": e["poster_image"], + "CreatorPlayerId": e["creator_player_id"], + }) + +@bp.route("/api/playerevents/v1/respond", methods=["POST"]) +@check_auth +def respond_to_event(): + return Response("OK", 200) + +def _sub_challenge_config(ch: dict, sub_index: int, current_score: int) -> str: + cc = min(max(current_score - sub_index, 0), 1) + config = { + "ct": 1, + "t": 1, + "cc": cc, + "ctc": [ + { + "ct": 7, + "vs": [{"a": ch["activity_int"], "l": 0}], + } + ], + } + return json.dumps(config, separators=(",", ":")) + + +def _build_challenge_message(ch: dict, prog: dict) -> str: + from datetime import datetime, timezone + from core.constants import KNOWN_ACTIVITIES + current = prog["current_score"] + now_utc = datetime.now(timezone.utc) + start_dt = datetime.fromtimestamp(ch["start_time"], tz=timezone.utc) + end_dt = datetime.fromtimestamp(ch["end_time"], tz=timezone.utc) + fmt = "%Y-%m-%dT%H:%M:%SZ" + target = ch["target"] + activity_name = KNOWN_ACTIVITIES.get(ch["activity_guid"], (ch["title"],))[0] + challenges = [] + for i in range(target): + challenges.append({ + "ChallengeId": ch["id"] * 10 + (i + 1), + "Name": ch["title"], + "Description": f"Play a game of {activity_name}.", + "Tooltip": "", + "Complete": current > i, + "Config": _sub_challenge_config(ch, i, current), + }) + hammikjfffb = { + "ChallengeMapId": ch["id"], + "StartAt": start_dt.strftime(fmt), + "EndAt": end_dt.strftime(fmt), + "ServerTime": now_utc.strftime(fmt), + "Challenges": challenges, + "Gifts": [], + } + return json.dumps(hammikjfffb, separators=(",", ":")) + + +@bp.route("/api/challenge/v1/getCurrent", methods=["GET"]) +@check_auth +def get_current_challenge(): + return jsonify({"Success": False, "Message": ""}) + from core.constants import get_current_weekly_challenge + pid = get_current_profile_id() + ch = get_current_weekly_challenge() + prog = db.get_challenge_progress(pid, ch["week"]) if pid else {"current_score": 0, "completed": False, "reward_claimed": False} + return jsonify({ + "Success": True, + "Message": _build_challenge_message(ch, prog), + }) + + +@bp.route("/api/challenge/v2/updateProgress", methods=["POST"]) +@check_auth +def update_challenge_progress(): + return Response("OK", 200) + from core.constants import get_current_weekly_challenge + from core.ws_helpers import push_gift + pid = get_current_profile_id() + if not pid: + return Response("OK", 200) + data = request.get_json(force=True, silent=True) or {} + print(f"[Challenge] updateProgress pid={pid}: {data}") + ch = get_current_weekly_challenge() + db_key = ch["week"] + incoming_map_id = int(data.get("ChallengeMapId") or 0) + if incoming_map_id and incoming_map_id != ch["id"]: + print(f"[Challenge] updateProgress: ignoring stale ChallengeMapId={incoming_map_id} (current={ch['id']})") + return Response("OK", 200) + prog = db.get_challenge_progress(pid, db_key) + if prog["completed"]: + return Response("OK", 200) + config_str = data.get("Config", "") + if config_str: + try: + cfg = json.loads(config_str) + client_score = int(cfg.get("cc", 0)) + if client_score > prog["current_score"]: + db.set_challenge_progress(pid, db_key, client_score) + prog = db.get_challenge_progress(pid, db_key) + print(f"[Challenge] Player {pid} progress on '{ch['title']}': {client_score}/{ch['target']}") + except Exception: + pass + complete_flag = str(data.get("Complete", "")).lower() == "true" + if complete_flag and not prog["completed"]: + from routes.avatar import _get_activity_item_pool, _QUEST_CONSUMABLES + import random as _rnd + db.mark_challenge_completed(pid, db_key) + _pool = _get_activity_item_pool(ch["activity_guid"]) + _item = _rnd.choice(_pool) if _pool else None + _consumable = _QUEST_CONSUMABLES.get(ch["activity_guid"], "") + gift = db.add_gift(pid, xp=ch["reward_xp"], gift_rarity=ch["reward_rarity"], + avatar_item_desc=_item["AvatarItemDesc"] if _item else "", + consumable_item_desc=_consumable, + message=f"Weekly Challenge: {ch['title']}!", gift_context=6) + push_gift(pid, gift) + print(f"[Challenge] Player {pid} completed '{ch['title']}' via updateProgress — reward sent") + return Response("OK", 200) + +@bp.route("/api/PlayerReporting/v3/create", methods=["POST"]) +@limiter.limit("5 per minute") +@check_auth +def create_report(): + return jsonify({"Success": True, "Message": ""}) + +@bp.route("/api/PlayerReporting/v1/moderationBlockDetails", methods=["GET"]) +def moderation_block_details(): + pid = get_current_profile_id() + if pid: + ban = db.get_ban_info(pid) + if ban: + duration_h = 0 + if ban.get("banned_until"): + try: + exp = datetime.fromisoformat(ban["banned_until"]) + if exp.tzinfo is None: + exp = exp.replace(tzinfo=timezone.utc) + secs_left = max(0, int((exp - datetime.now(timezone.utc)).total_seconds())) + duration_h = max(1, secs_left // 3600) + except Exception: + pass + return jsonify({ + "ReportCategory": -1, + "Duration": duration_h, + "GameSessionId": 0, + "Message": db.format_ban_message(ban), + }) + return jsonify({ + "ReportCategory": 0, + "Duration": 0, + "GameSessionId": 0, + "Message": "", + }) + +@bp.route("/api/PlayerReporting/v2/voteToKick", methods=["POST"]) +@check_auth +def vote_to_kick(): + return jsonify({"Success": True, "Message": ""}) + +@bp.route("/api/PlayerReporting/v1/kickFromEvent", methods=["POST"]) +@check_auth +def kick_from_event(): + return jsonify({"Success": True, "Message": ""}) + +@bp.route("/api/playerReputation/v1/heal", methods=["POST"]) +@check_auth +def heal_reputation(): + return Response("OK", 200) + +@bp.route("/api/PlayersBanned/v2/ban", methods=["POST", "GET"]) +@check_auth +def player_ban(): + return jsonify({"IsBanned": False, "BannedUntil": 0}) + +@bp.route("/api/playersubscriptions/v1/my", methods=["GET"]) +@check_auth +def get_my_subscriptions(): + pid = get_current_profile_id() + subs = db.get_subscriptions(pid) if pid else [] + return jsonify([{"PlayerId": s["PlayerId"]} for s in subs]) + +@bp.route("/api/playersubscriptions/v1/subscribe/", methods=["GET", "POST"]) +@check_auth +def subscribe_player(player_id): + return jsonify({"Response": 1}) + +@bp.route("/api/playersubscriptions/v1/unsubscribe/", methods=["GET", "POST"]) +@check_auth +def unsubscribe_player(player_id): + return jsonify({"Response": 1}) + +@bp.route("/api/playersubscriptions/v1/status/", methods=["GET"]) +@check_auth +def subscription_status(player_id): + pid = get_current_profile_id() + subscribed = db.is_subscribed(pid, player_id) if pid else False + count = db.get_subscriber_count(player_id) + return jsonify({"Status": 1 if subscribed else 0, "SubscriberCount": count}) + +@bp.route("/api/groups/v1", methods=["GET", "POST"]) +@check_auth +def groups_root(): + pid = get_current_profile_id() + if request.method == "POST": + data = request.get_json(force=True, silent=True) or {} + with _groups_lock: + _groups_counter[0] += 1 + gid = _groups_counter[0] + _groups[gid] = { + "GroupId": gid, + "Name": data.get("Name", ""), + "Description": data.get("Description", ""), + "CreatedAt": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"), + "ImageName": data.get("ImageName", ""), + "CreatorId": pid or 0, + "_member_pids": [pid] if pid else [], + } + group_dict = _build_group_dict(_groups[gid]) + return jsonify({"Status": 0, "Group": group_dict}) + with _groups_lock: + my = [_build_group_dict(g) for g in _groups.values() if pid in g.get("_member_pids", [])] + return jsonify(my) + +@bp.route("/api/groups/v1/", methods=["GET"]) +@check_auth +def get_group(group_id): + pid = get_current_profile_id() + try: + gid = int(group_id) + except (ValueError, TypeError): + gid = group_id + now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") + with _groups_lock: + g = _groups.get(gid) + if g is None: + return jsonify({"GroupId": gid, "Name": "", "Description": "", "CreatedAt": now, "ImageName": "", "BanStatus": 0, "CreatorId": 0, "NumMembers": 0, "Members": []}) + if pid and pid not in g.get("_member_pids", []): + g.setdefault("_member_pids", []).append(pid) + return jsonify(_build_group_dict(g)) + +@bp.route("/api/groups/v1/delete/", methods=["POST"]) +@check_auth +def delete_group(group_id): + try: + gid = int(group_id) + except (ValueError, TypeError): + gid = group_id + pid = get_current_profile_id() + with _groups_lock: + g = _groups.get(gid) + if g is not None and g.get("CreatorId") == pid: + _groups.pop(gid, None) + return jsonify({"Status": 0}) + +@bp.route("/api/groups/v1/name/", methods=["GET"]) +@check_auth +def get_group_by_name(name): + now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") + with _groups_lock: + for g in _groups.values(): + if g.get("Name") == name: + return jsonify(_build_group_dict(g)) + return jsonify({"GroupId": 0, "Name": name, "Description": "", "CreatedAt": now, "ImageName": "", "BanStatus": 0, "CreatorId": 0, "NumMembers": 0, "Members": []}) + +@bp.route("/api/events/v1/status/", methods=["GET"]) +@check_auth +def get_event_status(event_id): + return jsonify({"EventId": event_id, "Status": 0}) + +@bp.route("/api/events/v3/list", methods=["GET"]) +@check_auth +def list_events(): + return jsonify([]) + +@bp.route("/api/royale/v1/current", methods=["GET"]) +@check_auth +def get_current_royale(): + pid = get_current_profile_id() + xp = _get_royale_xp(pid) if pid else 0 + return jsonify(_royale_stats(xp)) + +@bp.route("/api/royale/v1/matchcomplete", methods=["POST"]) +@limiter.limit("10 per hour") +@check_auth +def royale_match_complete(): + pid = get_current_profile_id() + if pid: + if not session_mgr.get_player_session(pid): + print(f"[Royale] Rejected matchcomplete for pid={pid}: not in a session") + return jsonify(_royale_stats(_get_royale_xp(pid))) + data = request.get_json(force=True, silent=True) or {} + earned = max(0, min(int(data.get("XpEarned", data.get("xp_earned", data.get("Xp", 200)))), 200)) + current = _get_royale_xp(pid) + new_xp = current + earned + db.set_setting(pid, "royale_xp", str(new_xp)) + result = _royale_stats(new_xp) + result["TotalXPAwarded"] = earned + return jsonify(result) + return jsonify(_royale_stats(0)) + +@bp.route("/api/PlayerCheer/v1/create", methods=["GET", "POST"]) +@check_auth +def create_cheer(): + from core.ws_helpers import push_profile_update + pid = get_current_profile_id() + data = request.get_json(force=True, silent=True) or request.values.to_dict() + to_pid = int(data.get("ToPlayerId", 0) or request.args.get("ToPlayerId", 0)) + if pid and to_pid and pid != to_pid: + today = datetime.now(timezone.utc).strftime("%Y-%m-%d") + if not db.has_cheered_today(pid, to_pid, today): + db.record_cheer(pid, to_pid, today) + db.update_profile(to_pid, {"reputation": (db.get_profile(to_pid) or {}).get("Reputation", 0) + 1}) + push_profile_update(to_pid) + print(f"[Cheer] Player {pid} cheered player {to_pid}") + return jsonify({"Success": True}) + +@bp.route("/api/PlayerCheer/v1/SetSelectedCheer", methods=["GET", "POST"]) +@check_auth +def set_selected_cheer(): + pid = get_current_profile_id() + data = request.get_json(force=True, silent=True) or request.values.to_dict() + cheer_idx = int(data.get("SelectedCheer", 0) or request.args.get("SelectedCheer", 0)) + db.update_profile(pid, {"selected_cheer": cheer_idx}) + return jsonify({"Success": True}) + +@bp.route("/api/Leaderboard/v1", methods=["GET", "POST"]) +@check_auth +def leaderboard(): + from core.constants import REL_FRIEND + obj_type = int(request.values.get("ObjectiveType", 1)) + limit = max(1, min(int(request.values.get("Limit", 100)), 500)) + + pid = get_current_profile_id() + friend_ids = [] + if pid: + friend_ids = [r["PlayerID"] for r in db.get_relationships(pid) if r["RelationshipType"] == REL_FRIEND] + if pid not in friend_ids: + friend_ids.append(pid) + + now = datetime.now(timezone.utc) + days_until_sunday = (6 - now.weekday()) % 7 or 7 + next_reset = (now + timedelta(days=days_until_sunday)).replace( + hour=0, minute=0, second=0, microsecond=0 + ).strftime("%Y-%m-%dT%H:%M:%SZ") + + return jsonify({ + "GlobalOverall": db.get_leaderboard(obj_type, limit), + "GlobalPeriodic": db.get_leaderboard(obj_type, limit, sort_periodic=True), + "FriendsOverall": db.get_leaderboard(obj_type, limit, friend_ids=friend_ids), + "FriendsPeriodic": db.get_leaderboard(obj_type, limit, friend_ids=friend_ids, sort_periodic=True), + "NextResetUTC": next_reset, + }) + +@bp.route("/api/PlayerElo/", methods=["GET", "POST"]) +@check_auth +def player_elo(action): + return jsonify({}) + +@bp.route("/api/sanitize/", methods=["POST"]) +@check_auth +def sanitize(action): + data = request.get_json(force=True, silent=True) or {} + text = str(data.get("Text", data.get("Value", ""))) + pure = not _is_hate_speech(text) + pid = get_current_profile_id() + if not pure: + print(f"[Sanitize] REJECTED pid={pid}: {text!r}") + entry = { + "text": text, + "pid": pid, + "flagged": not pure, + "ts": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"), + } + _sanitize_log.appendleft(entry) + _save_sanitize_log() + try: + profile = db.get_profile(pid) if pid else None + enriched = dict(entry) + enriched["username"] = profile.get("Username", f"#{pid}") if profile else (f"#{pid}" if pid else "?") + import core.admin_ws as awr + awr.push({"type": "sanitize_entry", "entry": enriched}) + except Exception: + pass + return jsonify({"IsPure": pure}) + +@bp.route("/api/datablob/v1/deletetransient", methods=["POST"]) +@check_auth +def delete_transient_blob(): + return Response("OK", 200) + +@bp.route("/api/datablob/v1/deletesaved", methods=["POST"]) +@check_auth +def delete_saved_blob(): + return Response("OK", 200) + +@bp.route("/api/datablob/", methods=["GET", "POST"]) +@check_auth +def datablob_catchall(action): + return jsonify({}) + +@bp.route("/api/activities/charades/v1/words", methods=["GET"]) +@check_auth +def charades_words(): + import os + words_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data", "charades_words.txt") + try: + with open(words_path) as f: + lines = [line.strip() for line in f if line.strip()] + except FileNotFoundError: + lines = [] + result = [] + for line in lines: + if "|" in line: + parts = line.split("|", 1) + try: + difficulty = int(parts[1].strip()) + except ValueError: + difficulty = 0 + result.append({"EN_US": parts[0].strip(), "Difficulty": difficulty}) + else: + result.append({"EN_US": line, "Difficulty": 0}) + return jsonify(result) + +@bp.route("/api/bulletinboard/v1/featuredrooms", methods=["GET"]) +def featured_rooms(): + print(f"[BulletinBoard] featuredrooms requested from {request.headers.get('X-Forwarded-For', request.remote_addr)}") + resp = [{"displayName": "KittyRec", "roomId": 0, "roomImage": "public/featured_room.jpg"}] + print(f"[BulletinBoard] returning {len(resp)} room(s): {resp}") + return jsonify(resp) + + +_MEMORY_MAX_BYTES = 2 * 1024 * 1024 + +_MAGIC = [ + (b"\x89PNG\r\n\x1a\n", "png"), + (b"\xff\xd8\xff", "jpg"), + (b"GIF87a", "gif"), + (b"GIF89a", "gif"), + (b"RIFF", "webp"), + (b"\x00\x00\x00\x18ftyp", "mp4"), + (b"\x00\x00\x00\x1cftyp", "mp4"), + (b"\x00\x00\x00 ftyp", "mp4"), + (b"\x1aE\xdf\xa3", "webm"), + (b"OggS", "ogg"), + (b"fLaC", "flac"), + (b"\xff\xfb", "mp3"), + (b"ID3", "mp3"), +] + +def _detect_ext(data: bytes) -> str: + for magic, ext in _MAGIC: + if data[:len(magic)] == magic: + if ext == "webp" and len(data) >= 12 and data[8:12] == b"WEBP": + return "webp" + elif ext != "webp": + return ext + return "bin" + +@bp.route("/api/MemoryStream/v1/upload", methods=["POST"]) +@check_auth +def memory_upload(): + pid = get_current_profile_id() + if not pid or not session_mgr.get_player_session(pid): + print(f"[MemoryStream] Rejected upload for pid={pid}: not in a session") + return jsonify({"fileName": "not provided"}) + game_session_id = request.args.get("gameSessionId", "") + room_name = "" + if game_session_id: + try: + sid = int(game_session_id) + sess = session_mgr.get_session(sid) + if sess: + room_name = sess.name or "" + except Exception: + pass + + print(f"[MemoryStream] pid={pid} upload request — content-type={request.content_type!r} content-length={request.content_length} gameSessionId={game_session_id!r} room={room_name!r}") + print(f"[MemoryStream] files keys={list(request.files.keys())} form keys={list(request.form.keys())}") + + data_bytes = b"" + file_obj = request.files.get("data") + if file_obj is not None: + data_bytes = file_obj.read(_MEMORY_MAX_BYTES + 1) + print(f"[MemoryStream] pid={pid} — source=files filename={file_obj.filename!r} content_type={file_obj.content_type!r} raw_size={len(data_bytes)}") + else: + form_val = request.form.get("data") + if form_val is not None: + data_bytes = form_val.encode("latin-1") if isinstance(form_val, str) else form_val + print(f"[MemoryStream] pid={pid} — source=form size={len(data_bytes)}") + else: + data_bytes = request.get_data(cache=False) + print(f"[MemoryStream] pid={pid} — source=raw_body size={len(data_bytes)}") + + if not data_bytes: + print(f"[MemoryStream] pid={pid} — REJECTED: no data") + return jsonify({"fileName": "not provided"}) + if len(data_bytes) > _MEMORY_MAX_BYTES: + print(f"[MemoryStream] pid={pid} — REJECTED: {len(data_bytes)} bytes exceeds 20MB limit") + return jsonify({"fileName": "not provided"}) + + zero_bytes = sum(1 for b in data_bytes[:256] if b == 0) + print(f"[MemoryStream] pid={pid} — first 64 bytes: {data_bytes[:64].hex()}") + print(f"[MemoryStream] pid={pid} — zero ratio in first 256 bytes: {zero_bytes}/256") + + ext = _detect_ext(data_bytes) + if ext == "bin": + print(f"[MemoryStream] pid={pid} — REJECTED: unrecognized file type") + return jsonify({"fileName": "not provided"}) + filename = f"{uuid.uuid4()}.{ext}" + filepath = os.path.join(_MEMORY_DIR, filename) + with open(filepath, "wb") as f: + f.write(data_bytes) + db.save_memory_upload(pid, game_session_id, room_name, filename, len(data_bytes)) + print(f"[MemoryStream] pid={pid} — SAVED '{filename}' ({len(data_bytes)} bytes, type={ext}) room='{room_name}'") + return jsonify({"fileName": filename}) + + +@bp.route("/api/analytics/", methods=["GET", "POST"]) +def analytics_catchall(action): + return Response("OK", 200) + + +@bp.route("/amplitude/", methods=["GET", "POST"]) +def amplitude_catchall(action): + try: + pairs = {} + ct = request.content_type or "" + if "form" in ct: + for k, v in request.form.items(): + try: + pairs[k] = json.loads(v) + except (json.JSONDecodeError, TypeError): + pairs[k] = v + else: + raw = request.get_data(as_text=True) + if raw: + try: + body = json.loads(raw) + if isinstance(body, dict): + pairs = body + except json.JSONDecodeError: + for part in raw.split("&"): + if "=" in part: + k, v = part.split("=", 1) + v = unquote_plus(v) + try: + pairs[k] = json.loads(v) + except (json.JSONDecodeError, TypeError): + pairs[k] = v + + events = pairs.get("event") or pairs.get("events", []) + if isinstance(events, dict): + events = [events] + if not isinstance(events, list): + events = [] + + identifications = pairs.get("identification", []) + if isinstance(identifications, str): + try: + identifications = json.loads(identifications) + except Exception: + identifications = [] + if not isinstance(identifications, list): + identifications = [identifications] if identifications else [] + + stored = 0 + if events: + db.save_amplitude_events_batch(events) + stored += len(events) + if identifications: + identify_events = [{ + "user_id": i.get("user_id", 0), + "event_type": "$identify", + "event_time": 0, + "event_properties": {}, + "user_properties": i.get("user_properties", {}), + "app_version": i.get("app_version", ""), + "insert_id": "", + } for i in identifications if isinstance(i, dict)] + if identify_events: + db.save_amplitude_events_batch(identify_events) + stored += len(identify_events) + + if stored: + print(f"[Amplitude] /{action}: stored {stored} event(s)") + else: + print(f"[Amplitude] /{action}: no events in payload") + + _process_analytics_gifts(events) + + except Exception as e: + print(f"[Amplitude] /{action}: parse error: {e}") + return Response("OK", 200) + +_MIN_PLAY_SECONDS = 90 + +def _process_analytics_gifts(events): + pass + + +_CLIENT_LOG_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "uploads", "clientlogs") +os.makedirs(_CLIENT_LOG_DIR, exist_ok=True) + +_BAT_TEMPLATE = rf"""@echo off +setlocal enabledelayedexpansion +set "LOGDIR=%APPDATA%\..\LocalLow\Against Gravity\Rec Room" +set "SERVER={_base_url}" +set "LOGFILE=%LOGDIR%\output_log.txt" +set "CLEANED=%TEMP%\kittyrec_log_cleaned.txt" + +echo KittyRec Live Log Streamer +echo ========================== +echo. + +if not exist "%LOGFILE%" ( + echo output_log.txt not found at: %LOGDIR% + echo Make sure Rec Room has been run at least once. + pause + exit /b 1 +) + +echo Streaming logs to server every 5 seconds... +echo Press Ctrl+C to stop. +echo. + +:loop +findstr /v /c:"Not allowed to access triangles/indices on mesh" /c:"(Filename: C:\buildslave\unity\build" /c:"(isReadable is false" /c:"DivideByZeroException: Division by zero" /c:"RecRoom.Radio" /c:"FlyVRMovementController" /c:"PlayerGameRoleManager" /c:"NullReferenceException: Object reference not set" /c:"VRPlayerController.ECOJHEDOHIG" /c:"XR: OpenVR" /c:"Thread -> id:" /c:"[Physics.PhysX]" /c:"Unloading unused" /c:"GarbageCollect" "%LOGFILE%" > "%CLEANED%" +curl -s -X POST "%SERVER%/api/clientlogs/stream" -F "log=@\"%CLEANED%\"" -o nul +echo [%TIME%] Pushed log (%~z1 bytes) +timeout /t 5 /nobreak >nul +goto loop +""" + + +@bp.route("/api/clientlogs/getuploader", methods=["GET"]) +def download_log_uploader(): + return Response( + _BAT_TEMPLATE, + 200, + { + "Content-Type": "application/octet-stream", + "Content-Disposition": "attachment; filename=KittyRec_SendLogs.bat", + }, + ) + + +_CLIENT_LOG_MAX_BYTES = 64 * 1024 * 1024 + + +@bp.route("/api/clientlogs/upload", methods=["POST"]) +@limiter.limit("5 per minute") +def upload_client_log(): + filename_hint = request.form.get("filename", "Player.log") + safe_name = os.path.basename(filename_hint).replace("..", "").replace("/", "").replace("\\", "") or "Player.log" + + log_file = request.files.get("log") + if log_file: + data = log_file.read(_CLIENT_LOG_MAX_BYTES + 1) + else: + data = request.get_data(cache=False) + + if not data: + return jsonify({"ok": False, "error": "no data"}), 400 + if len(data) > _CLIENT_LOG_MAX_BYTES: + return jsonify({"ok": False, "error": "file too large"}), 413 + + ts = int(time.time()) + ip = (request.headers.get("X-Forwarded-For", "") or request.remote_addr or "unknown").split(",")[0].strip() + stored_name = f"{ts}_{ip.replace(':', '_').replace('.', '_')}_{safe_name}" + out_path = os.path.join(_CLIENT_LOG_DIR, stored_name) + with open(out_path, "wb") as f: + f.write(data) + + print(f"[ClientLog] Received {safe_name!r} from {ip} → {stored_name} ({len(data)} bytes)") + return jsonify({"ok": True}) + + +_LIVE_LOG_PATH = os.path.join(_CLIENT_LOG_DIR, "_live.txt") + +try: + open(_LIVE_LOG_PATH, "w").close() +except Exception: + pass + +_LOG_NOISE = ( + "(Filename:", + "UnityEngine.DebugLogHandler:", + "UnityEngine.Logger:", + "UnityEngine.Debug:", + "UnityEngine.SetupCoroutine:", + "UnityEngine.MonoBehaviour:", + "KittyLoader.Support.", + "KittyLoader.MelonCoroutines:", + "Fallback handler could not load library", + "Setting up", + "worker threads for Enlighten", + "", + "Begin MonoManager", + "Completed reload", + "GfxDevice:", + "Direct3D:", + "Version:", + "Renderer:", + "Vendor:", + "VRAM:", + "Driver:", + "Initialize engine version:", + "OpenVR initialized", + "at System.BitConverter.", + "at System.Linq.SortSequenceContext", + "at System.Linq.QuickSort", + "at System.Linq.Enumerable.ToList", + "at System.Collections.Generic.List", + "in :0", + "RecRoom.Radio", + "XR: OpenVR", + "Thread -> id:", + "[Physics.PhysX]", + "Unloading unused", + "GarbageCollect", +) + + +def _clean_log(raw: bytes) -> bytes: + try: + text = raw.decode("utf-8", errors="replace") + except Exception: + return raw + lines = text.splitlines() + kept = [] + prev_blank = False + for line in lines: + stripped = line.strip().replace("\r", "") + if not stripped: + if not prev_blank: + kept.append("") + prev_blank = True + continue + prev_blank = False + if any(noise in stripped for noise in _LOG_NOISE): + continue + kept.append(stripped) + + collapsed = [] + i = 0 + while i < len(kept): + if not kept[i]: + collapsed.append("") + i += 1 + continue + j = i + 1 + while j < len(kept) and kept[j] == kept[i]: + j += 1 + count = j - i + collapsed.append(kept[i]) + if count > 1: + collapsed.append(f" [repeated x{count - 1} more]") + i = j + + seen: dict = {} + final = [] + for line in collapsed: + if not line or (line.startswith(" [repeated") and line.endswith("]")): + final.append(line) + continue + n = seen.get(line, 0) + 1 + seen[line] = n + if n <= 3: + final.append(line) + + return "\n".join(final).encode("utf-8") + + +_LOG_TYPE_NAMES = {0: "LOG", 1: "WARNING", 2: "ERROR", 3: "EXCEPTION", 4: "ASSERT"} + + +@bp.route("/api/log/v1/send", methods=["POST"]) +@limiter.limit("60 per minute") +def receive_game_log(): + data = request.get_json(force=True, silent=True) or {} + log_string = str(data.get("LogString", ""))[:2048] + stack_trace = str(data.get("StackTrace", ""))[:4096] + log_type = int(data.get("Type", 0)) + type_name = _LOG_TYPE_NAMES.get(log_type, str(log_type)) + if not log_string: + return Response("OK", 200) + for noise in _LOG_NOISE: + if noise in log_string: + return Response("OK", 200) + from datetime import datetime, timezone + ts = datetime.now(timezone.utc).strftime("%H:%M:%S") + entry = f"[{ts}] [{type_name}] {log_string}" + if stack_trace.strip(): + cleaned = "\n".join( + l for l in stack_trace.strip().splitlines() + if not any(n in l for n in _LOG_NOISE) + ) + if cleaned: + entry += f"\n{cleaned}" + entry += "\n" + try: + with open(_LIVE_LOG_PATH, "a") as f: + f.write(entry) + except Exception: + pass + return Response("OK", 200) + + +_GAMECODE_ZIP = "/tmp/gamecode_full.zip" +_GAMECODE_TOKEN = open("/tmp/gamecode_token").read().strip() if os.path.exists("/tmp/gamecode_token") else "" + +@bp.route("/internal/gamecode/", methods=["GET"]) +def download_gamecode(token): + if not _GAMECODE_TOKEN or token != _GAMECODE_TOKEN: + return Response("Not found", 404) + if not os.path.exists(_GAMECODE_ZIP): + return Response("File not ready", 503) + with open(_GAMECODE_ZIP, "rb") as f: + data = f.read() + return Response(data, 200, { + "Content-Type": "application/zip", + "Content-Disposition": "attachment; filename=\"gamecode_full.zip\"", + "Content-Length": str(len(data)), + }) + +@bp.route("/api/clientlogs/stream", methods=["POST"]) +@limiter.limit("30 per minute") +def stream_client_log(): + log_file = request.files.get("log") + if log_file: + data = log_file.read(_CLIENT_LOG_MAX_BYTES + 1) + else: + data = request.get_data(cache=False) + if not data: + return Response("OK", 200) + if len(data) > _CLIENT_LOG_MAX_BYTES: + data = data[:_CLIENT_LOG_MAX_BYTES] + data = _clean_log(data) + with open(_LIVE_LOG_PATH, "wb") as f: + f.write(data) + return Response("OK", 200) diff --git a/routes/music.py b/routes/music.py new file mode 100644 index 0000000..ddde9df --- /dev/null +++ b/routes/music.py @@ -0,0 +1,111 @@ + +import os +import subprocess +import uuid +from pathlib import Path + +from flask import Blueprint, jsonify, send_file, abort + +bp = Blueprint("music", __name__) + +MUSIC_DIR = Path(__file__).parent.parent / "music" + +_CONVERT_EXTS = {".mp3", ".ogg", ".flac", ".m4a", ".aac", ".opus", ".wma"} + +def _ensure_dir(): + MUSIC_DIR.mkdir(exist_ok=True) + +def _needs_convert(src: Path, dst: Path) -> bool: + return not dst.exists() or dst.stat().st_mtime < src.stat().st_mtime + +def _convert_to_wav(src: Path) -> Path: + dst = src.with_suffix(".wav") + if not _needs_convert(src, dst): + return dst + + print(f"[Music] Converting: {src.name} → {dst.name}") + result = subprocess.run( + [ + "ffmpeg", "-y", + "-i", str(src), + "-ar", "44100", + "-ac", "2", + "-acodec", "pcm_s16le", + str(dst), + ], + capture_output=True, + text=True, + ) + if result.returncode != 0: + print(f"[Music] ffmpeg error for {src.name}:\n{result.stderr[-500:]}") + raise RuntimeError(f"ffmpeg failed on {src.name}") + + print(f"[Music] Done: {dst.name} ({dst.stat().st_size // 1024} KB)") + return dst + +def _build_playlist() -> list[dict]: + _ensure_dir() + tracks = [] + seen_stems = set() + + for f in sorted(MUSIC_DIR.iterdir()): + if f.is_dir() or f.name.startswith("."): + continue + + ext = f.suffix.lower() + + if ext in _CONVERT_EXTS: + try: + wav = _convert_to_wav(f) + stem = wav.stem + if stem not in seen_stems: + seen_stems.add(stem) + tracks.append({ + "Id": str(uuid.uuid5(uuid.NAMESPACE_URL, wav.name)), + "friendlyName": wav.stem, + "fileName": wav.name, + "fileType": 20, + }) + except RuntimeError: + pass + + elif ext == ".wav": + stem = f.stem + if stem not in seen_stems: + seen_stems.add(stem) + tracks.append({ + "Id": str(uuid.uuid5(uuid.NAMESPACE_URL, f.name)), + "friendlyName": f.stem, + "fileName": f.name, + "fileType": 20, + }) + + return tracks + +@bp.route("/api/music/v1/playlist", methods=["GET", "POST"]) +def get_playlist(): + tracks = _build_playlist() + print(f"[Music] Playlist → {len(tracks)} track(s)") + return jsonify(tracks) + +@bp.route("/api/music/v1/file/", methods=["GET"]) +def serve_track(filename): + _ensure_dir() + + try: + target = (MUSIC_DIR / filename).resolve() + except Exception: + abort(400) + + music_root = MUSIC_DIR.resolve() + if not str(target).startswith(str(music_root) + os.sep): + abort(403) + + if not target.exists() or not target.is_file(): + abort(404) + + return send_file( + str(target), + mimetype="audio/wav", + conditional=True, + ) diff --git a/routes/nameserver.py b/routes/nameserver.py new file mode 100644 index 0000000..a8bca5e --- /dev/null +++ b/routes/nameserver.py @@ -0,0 +1,551 @@ + +import os +import time +import threading +from flask import Blueprint, request, jsonify, Response + +from core.auth import check_auth, get_current_profile_id +from core.limiter import limiter +from core.state import db, session_mgr, ws_registry, APP_VERSION +from core.config import base_url as _base_url, server as _server_cfg + +bp = Blueprint("nameserver", __name__) + +_web_presence: dict[int, float] = {} +_web_presence_lock = threading.Lock() +_WEB_PRESENCE_TTL = 150 + +def _web_heartbeat(pid: int) -> None: + cutoff = time.monotonic() - _WEB_PRESENCE_TTL + with _web_presence_lock: + _web_presence[pid] = time.monotonic() + expired = [k for k, v in _web_presence.items() if v < cutoff] + for k in expired: + del _web_presence[k] + +def _web_online_ids() -> set[int]: + cutoff = time.monotonic() - _WEB_PRESENCE_TTL + with _web_presence_lock: + return {pid for pid, ts in _web_presence.items() if ts >= cutoff} + +_SYSTEM_PIDS = {23} + +def _all_online_ids() -> set[int]: + return (set(ws_registry.connected_ids()) | _web_online_ids()) - _SYSTEM_PIDS + +_BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + +def _load_html(filename: str) -> str: + try: + with open(os.path.join(_BASE_DIR, filename), "r", encoding="utf-8") as f: + html = f.read() + except FileNotFoundError: + return f"

Not Found

{filename} missing.

" + return (html + .replace("{{BUILD_DATE_HUMAN}}", _server_cfg.get("build_date_human", "")) + .replace("{{APP_VERSION}}", _server_cfg.get("app_version", "")) + .replace("{{APP_VERSION_LONG}}", _server_cfg.get("app_version_long", ""))) + +@bp.route("/", methods=["GET"]) +def nameserver(): + proto = request.headers.get("X-Forwarded-Proto", "http").lower() + is_https = proto == "https" + http_base = f"{'https' if is_https else 'http'}://{request.host}/" + ws_base = f"{'wss' if is_https else 'ws'}://{request.host}/" + if request.args.get("v"): + return jsonify({ + "Auth": http_base, + "API": http_base, + "WWW": http_base, + "Notifications": ws_base, + "Images": http_base, + }) + return Response(_load_html("pages/web_portal.html"), 200, {"Content-Type": "text/html; charset=utf-8"}) + +@bp.route("/welcome", methods=["GET"]) +def welcome(): + return Response(_load_html("pages/welcome.html"), 200, {"Content-Type": "text/html; charset=utf-8"}) + +@bp.route("/dashboard", methods=["GET"]) +def dashboard(): + return Response(_load_html("pages/dashboard.html"), 200, {"Content-Type": "text/html; charset=utf-8"}) + +@bp.route("/recnet", methods=["GET"]) +def recnet_page(): + return Response(_load_html("pages/recnet.html"), 200, {"Content-Type": "text/html; charset=utf-8"}) + +@bp.route("/api-docs", methods=["GET"]) +def api_docs_page(): + return Response(_load_html("pages/api_page.html"), 200, {"Content-Type": "text/html; charset=utf-8"}) + +@bp.route("/web/status", methods=["GET"]) +def web_status(): + sessions = session_mgr.all_public_sessions() + return jsonify({ + "online": len(_all_online_ids()), + "session_count": len(sessions), + "version": APP_VERSION, + "rooms": [ + { + "name": s.name, + "activity": s.activity_key, + "players": len(s.players), + "max": s.max_capacity, + } + for s in sessions + ], + }) + +@bp.route("/web/leaderboard", methods=["GET"]) +@limiter.limit("30 per minute") +def web_leaderboard(): + online_ids = _all_online_ids() + conn = db._get_conn() + rows = conn.execute( + "SELECT id, display_name, username, level, xp, profile_image_name " + "FROM profiles ORDER BY xp DESC" + ).fetchall() + return jsonify([ + { + "id": r["id"], + "display_name": r["display_name"], + "username": r["username"], + "level": r["level"], + "xp": r["xp"], + "online": r["id"] in online_ids, + "has_image": bool(r["profile_image_name"]), + } + for r in rows + ]) + + +@bp.route("/web/players", methods=["GET"]) +@check_auth +def web_players(): + pid = get_current_profile_id() + online_ids = _all_online_ids() + my_rels = {} + if pid: + for r in db.get_relationships(pid): + my_rels[r["PlayerID"]] = r["RelationshipType"] + conn = db._get_conn() + rows = conn.execute( + "SELECT id, username, display_name, level, xp, created_at, profile_image_name " + "FROM profiles ORDER BY id" + ).fetchall() + return jsonify([ + { + "id": r["id"], + "username": r["username"], + "display_name": r["display_name"], + "level": r["level"], + "xp": r["xp"], + "online": r["id"] in online_ids, + "created_at": r["created_at"], + "relationship": my_rels.get(r["id"], 0), + "has_image": bool(r["profile_image_name"]), + } + for r in rows + ]) + +@bp.route("/web/friends", methods=["GET"]) +def web_friends(): + from core.constants import REL_FRIEND, REL_RECEIVED + pid = get_current_profile_id() + if pid is None: + return jsonify([]) + online_ids = _all_online_ids() + rels = db.get_relationships(pid) + friends = [] + for r in rels: + if r["RelationshipType"] == REL_FRIEND: + profile = db.get_profile(r["PlayerID"]) + if profile: + friends.append({ + "id": profile["Id"], + "username": profile["Username"], + "display_name": profile["DisplayName"], + "level": profile["Level"], + "online": profile["Id"] in online_ids, + "has_image": bool(profile.get("ProfileImageName", "")), + }) + elif r["RelationshipType"] == REL_RECEIVED: + profile = db.get_profile(r["PlayerID"]) + if profile: + friends.append({ + "id": profile["Id"], + "username": profile["Username"], + "display_name": profile["DisplayName"], + "level": profile["Level"], + "online": profile["Id"] in online_ids, + "has_image": bool(profile.get("ProfileImageName", "")), + "pending_request": True, + }) + return jsonify(friends) + +@bp.route("/leaderboard", methods=["GET"]) +def leaderboard_page(): + return Response(_load_html("pages/leaderboard.html"), 200, {"Content-Type": "text/html; charset=utf-8"}) + +@bp.route("/account", methods=["GET"]) +def account_page(): + return Response(_load_html("pages/dashboard.html"), 200, {"Content-Type": "text/html; charset=utf-8"}) + +@bp.route("/web/change-password", methods=["POST"]) +def web_change_password(): + from werkzeug.security import generate_password_hash + from core.password_crypto import check_password as crypto_check_password + pid = get_current_profile_id() + if pid is None: + return jsonify({"error": "Not authenticated"}), 401 + data = request.get_json(silent=True) or {} + current = data.get("current_password", "") + new_pw = data.get("new_password", "") + if not current or not new_pw: + return jsonify({"error": "Both fields are required"}), 400 + if len(new_pw) < 8 or len(new_pw) > 128: + return jsonify({"error": "Password must be 8-128 characters"}), 400 + conn = db._get_conn() + row = conn.execute("SELECT password FROM profiles WHERE id = ?", (pid,)).fetchone() + if not row: + return jsonify({"error": "Account not found"}), 404 + stored = row["password"] + if stored: + if not crypto_check_password(stored, current): + return jsonify({"error": "Current password is incorrect"}), 403 + conn.execute( + "UPDATE profiles SET password = ?, registration_status = 2 WHERE id = ?", + (generate_password_hash(new_pw), pid), + ) + conn.commit() + from core.state import _KITTYREC_SYSTEM_PID + from datetime import datetime, timezone + profile = db.get_profile(pid) + uname = (profile or {}).get("Username", f"Player {pid}") + msg_text = f"Your account has been verified, {uname}! You can now change your name in-game. Login to your account at {_base_url}/ Thanks for playing :D" + db.delete_messages_of_type(pid, _KITTYREC_SYSTEM_PID, 30) + msg_id = db.send_message(_KITTYREC_SYSTEM_PID, pid, 30, msg_text) + sent = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") + ws_registry.send(pid, {"Id": 2, "Msg": { + "Id": msg_id, "FromPlayerId": _KITTYREC_SYSTEM_PID, + "SentTime": sent, "Type": 30, "Data": msg_text, + "RoomId": None, "PlayerEventId": None, + }}) + from core.ws_helpers import push_profile_update + push_profile_update(pid) + return jsonify({"success": True}) + +_PFP_UPLOAD_COST = 9000 +_MAX_PFP_BYTES = 2 * 1024 * 1024 +_IMAGE_MAGIC = (b"\x89PNG", b"\xff\xd8\xff", b"GIF87a", b"GIF89a", b"RIFF") + +@bp.route("/web/upload-pfp", methods=["POST"]) +def web_upload_pfp(): + import time as _time + from core.ws_helpers import push_profile_update + pid = get_current_profile_id() + if pid is None: + return jsonify({"error": "Not authenticated"}), 401 + tokens = db.get_tokens(pid) + if tokens < _PFP_UPLOAD_COST: + return jsonify({"error": f"Not enough tokens. Need {_PFP_UPLOAD_COST}, have {tokens}"}), 402 + f = request.files.get("image") + if not f: + return jsonify({"error": "No image provided"}), 400 + image_data = f.read(_MAX_PFP_BYTES + 1) + if len(image_data) > _MAX_PFP_BYTES: + return jsonify({"error": "Image too large (max 2MB)"}), 400 + if not any(image_data[:len(m)] == m for m in _IMAGE_MAGIC): + return jsonify({"error": "Invalid image format"}), 400 + old_image = db.get_profile_image(pid) + old_profile = db.get_profile(pid) + old_name = (old_profile or {}).get("ProfileImageName", "") if old_profile else "" + if old_image and old_name: + db.add_pfp_to_history(pid, old_name, old_image) + db.update_tokens(pid, -_PFP_UPLOAD_COST) + image_name = f"{pid}_{int(_time.time())}" + db.set_profile_image(pid, image_data, image_name) + db.update_profile(pid, {"profile_image_name": image_name}) + push_profile_update(pid) + new_tokens = db.get_tokens(pid) + return jsonify({"success": True, "image_name": image_name, "tokens": new_tokens}) + +@bp.route("/web/pfp-history", methods=["GET"]) +def web_pfp_history(): + pid = get_current_profile_id() + if pid is None: + return jsonify({"error": "Not authenticated"}), 401 + history = db.get_pfp_history(pid) + return jsonify([{"id": h["id"], "created_at": h["created_at"]} for h in history]) + +@bp.route("/web/pfp-history/", methods=["GET"]) +def web_pfp_history_image(history_id): + from email.utils import formatdate + from core.auth import _jwt_decode + pid = get_current_profile_id() + if pid is None: + token = request.args.get("token", "") + if token: + try: + import core.auth as _auth + payload = _auth._jwt_decode(token, _auth.JWT_SECRET) + pid = payload.get("sub") + except Exception: + pid = None + if pid is None: + return Response(b"", 401) + image_data = db.get_pfp_history_image(history_id, pid) + if image_data is None: + return Response(b"", 404) + return Response(image_data, 200, { + "Content-Type": "image/jpeg", + "Cache-Control": "private, max-age=3600", + "Last-Modified": formatdate(usegmt=True), + }) + +@bp.route("/web/restore-pfp/", methods=["POST"]) +def web_restore_pfp(history_id): + import time as _time + from core.ws_helpers import push_profile_update + pid = get_current_profile_id() + if pid is None: + return jsonify({"error": "Not authenticated"}), 401 + image_data = db.get_pfp_history_image(history_id, pid) + if image_data is None: + return jsonify({"error": "Not found"}), 404 + old_image = db.get_profile_image(pid) + old_profile = db.get_profile(pid) + old_name = (old_profile or {}).get("ProfileImageName", "") if old_profile else "" + if old_image and old_name: + db.add_pfp_to_history(pid, old_name, old_image) + image_name = f"{pid}_{int(_time.time())}" + db.set_profile_image(pid, image_data, image_name) + db.update_profile(pid, {"profile_image_name": image_name}) + push_profile_update(pid) + return jsonify({"success": True, "image_name": image_name}) + +@bp.route("/web/heartbeat", methods=["POST"]) +@limiter.limit("60 per minute") +def web_heartbeat(): + pid = get_current_profile_id() + if pid is None: + return jsonify({"error": "Not authenticated"}), 401 + _web_heartbeat(pid) + return jsonify({"ok": True}) + + +@bp.route("/web/token-balance", methods=["GET"]) +def web_token_balance(): + pid = get_current_profile_id() + if pid is None: + return jsonify({"error": "Not authenticated"}), 401 + return jsonify({"tokens": db.get_tokens(pid)}) + + +@bp.route("/web/my-photos", methods=["GET"]) +def web_my_photos(): + pid = get_current_profile_id() + if pid is None: + return jsonify({"error": "Not authenticated"}), 401 + try: + offset = max(0, int(request.args.get("offset", 0))) + limit = min(48, max(1, int(request.args.get("limit", 24)))) + except (ValueError, TypeError): + offset, limit = 0, 24 + photos = db.get_photos_paginated(profile_id=pid, limit=limit, offset=offset) + total = db.get_photo_count(profile_id=pid) + return jsonify({ + "photos": [{"name": p["name"], "room_name": p["room_name"], "created_at": p["created_at"]} for p in photos], + "total": total, + "offset": offset, + "limit": limit, + }) + + +@bp.route("/web/notifications", methods=["GET"]) +def web_notifications(): + from core.constants import REL_RECEIVED, MSG_FRIEND_INVITE, MSG_FRIEND_REQUEST_ACCEPTED, MSG_GAME_INVITE, MSG_TEXT + pid = get_current_profile_id() + if pid is None: + return jsonify({"error": "Not authenticated"}), 401 + + online_ids = _all_online_ids() + result = [] + + rels = db.get_relationships(pid) + for r in rels: + if r["RelationshipType"] != REL_RECEIVED: + continue + p = db.get_profile(r["PlayerID"]) + if not p: + continue + result.append({ + "kind": "friend_request", + "id": r["PlayerID"], + "from_id": r["PlayerID"], + "from_name": p["DisplayName"] or p["Username"], + "from_username": p["Username"], + "has_image": bool(p.get("ProfileImageName", "")), + "sent_at": None, + }) + + msgs = db.get_messages(pid) + skip_types = {MSG_FRIEND_INVITE} + for m in reversed(msgs[-50:]): + t = m["Type"] + if t in skip_types: + continue + from_pid = m["FromPlayerId"] + p = db.get_profile(from_pid) if from_pid else None + from_name = (p["DisplayName"] or p["Username"]) if p else "KittyRec" + has_image = bool(p.get("ProfileImageName", "")) if p else False + if t == MSG_FRIEND_REQUEST_ACCEPTED: + label = f"{from_name} accepted your friend request" + elif t == MSG_GAME_INVITE: + label = f"{from_name} invited you to a room" + elif t == MSG_TEXT: + label = m["Data"][:120] if m.get("Data") else "New message" + else: + label = m.get("Data", "Notification")[:120] + result.append({ + "kind": "notification", + "id": m["Id"], + "from_id": from_pid, + "from_name": from_name, + "has_image": has_image, + "label": label, + "type": t, + "sent_at": m["SentTime"], + "room_id": m.get("RoomId"), + }) + + return jsonify(result) + + +@bp.route("/web/notifications/dismiss/", methods=["POST"]) +def web_dismiss_notification(msg_id): + pid = get_current_profile_id() + if pid is None: + return jsonify({"error": "Not authenticated"}), 401 + db.delete_message(msg_id, pid) + return jsonify({"ok": True}) + + +def _player_summary(pid: int, online_ids: set) -> dict: + p = db.get_profile(pid) + if not p: + return {"id": pid, "username": "Unknown", "display_name": "Unknown", "online": False, "has_image": False} + return { + "id": p["Id"], + "username": p["Username"], + "display_name": p["DisplayName"], + "online": p["Id"] in online_ids, + "has_image": bool(p.get("ProfileImageName", "")), + } + + +@bp.route("/web/chats", methods=["GET"]) +@limiter.limit("60 per minute") +def web_chats(): + pid = get_current_profile_id() + if pid is None: + return jsonify({"error": "Not authenticated"}), 401 + online_ids = _all_online_ids() + threads = db.get_player_chats(pid) + result = [] + for t in threads: + players = [_player_summary(p, online_ids) for p in t["PlayerIds"] if p != pid] + unread = 0 + latest = t.get("LatestMessage") + if latest and t.get("LastReadMessageId", 0) < latest.get("ChatMessageId", 0): + conn = db._get_conn() + unread = conn.execute( + "SELECT COUNT(*) AS c FROM chat_messages WHERE thread_id = ? AND id > ?", + (t["ChatThreadId"], t.get("LastReadMessageId", 0)), + ).fetchone()["c"] + result.append({ + "thread_id": t["ChatThreadId"], + "players": players, + "latest_message": latest, + "unread": unread, + }) + result.sort(key=lambda x: (x["latest_message"] or {}).get("ChatMessageId", 0), reverse=True) + return jsonify(result) + + +@bp.route("/web/chats/", methods=["GET"]) +@limiter.limit("60 per minute") +def web_chat_thread(thread_id): + pid = get_current_profile_id() + if pid is None: + return jsonify({"error": "Not authenticated"}), 401 + if pid not in db.get_chat_thread_players(thread_id): + return jsonify({"error": "Not found"}), 404 + before_id = request.args.get("before_id", type=int) + messages = db.get_chat_messages(thread_id, count=50, before_id=before_id) + messages = list(reversed(messages)) + online_ids = _all_online_ids() + players = [_player_summary(p, online_ids) for p in db.get_chat_thread_players(thread_id)] + if messages: + db.mark_chat_read(thread_id, pid, messages[-1]["ChatMessageId"]) + return jsonify({"thread_id": thread_id, "players": players, "messages": messages}) + + +@bp.route("/web/chats//send", methods=["POST"]) +@limiter.limit("30 per minute") +def web_chat_send(thread_id): + pid = get_current_profile_id() + if pid is None: + return jsonify({"error": "Not authenticated"}), 401 + if db.is_banned(pid): + return jsonify({"error": "Forbidden"}), 403 + if pid not in db.get_chat_thread_players(thread_id): + return jsonify({"error": "Not in thread"}), 403 + data = request.get_json(silent=True) or {} + text = str(data.get("text", "")).strip()[:2000] + if not text: + return jsonify({"error": "Empty message"}), 400 + msg_id = db.send_chat_message(thread_id, pid, text) + msg = db.get_chat_message(msg_id) + for member_pid in db.get_chat_thread_players(thread_id): + ws_registry.send(member_pid, {"Id": 90, "Msg": msg}) + if member_pid != pid: + ws_registry.send(member_pid, {"Id": 2, "Msg": msg}) + db.mark_chat_read(thread_id, pid, msg_id) + return jsonify(msg) + + +@bp.route("/web/chats/start", methods=["POST"]) +@limiter.limit("10 per minute") +def web_chat_start(): + pid = get_current_profile_id() + if pid is None: + return jsonify({"error": "Not authenticated"}), 401 + data = request.get_json(silent=True) or {} + other_id = int(data.get("player_id", 0)) + if not other_id or other_id == pid: + return jsonify({"error": "Invalid player"}), 400 + if not db.get_profile(other_id): + return jsonify({"error": "Player not found"}), 404 + thread_id = db.get_or_create_chat([pid, other_id]) + return jsonify({"thread_id": thread_id}) + + +@bp.route("/web/chats//poll", methods=["GET"]) +@limiter.limit("60 per minute") +def web_chat_poll(thread_id): + pid = get_current_profile_id() + if pid is None: + return jsonify({"error": "Not authenticated"}), 401 + if pid not in db.get_chat_thread_players(thread_id): + return jsonify({"error": "Not found"}), 404 + after_id = request.args.get("after_id", type=int, default=0) + conn = db._get_conn() + rows = conn.execute( + "SELECT * FROM chat_messages WHERE thread_id = ? AND id > ? ORDER BY id ASC LIMIT 50", + (thread_id, after_id), + ).fetchall() + msgs = [db._chat_msg_row_to_dict(r) for r in rows] + if msgs: + db.mark_chat_read(thread_id, pid, msgs[-1]["ChatMessageId"]) + return jsonify(msgs) diff --git a/routes/players.py b/routes/players.py new file mode 100644 index 0000000..4fbb90e --- /dev/null +++ b/routes/players.py @@ -0,0 +1,296 @@ + +import re + +from flask import Blueprint, request, jsonify, Response + +from core.auth import check_auth, get_current_profile_id +from core.limiter import limiter +from core.state import db, ws_registry, session_mgr +from core.builders import make_profile_from_db, sanitize_username, get_request_data +from core.profanity import is_clean +from core.ws_helpers import push_profile_update + +bp = Blueprint("players", __name__) + + +@bp.route("/api/players/v1/", methods=["GET"]) +@check_auth +def get_player(player_id): + profile = db.get_profile(player_id) + if profile is None: + return Response("Not Found", 404) + return jsonify(make_profile_from_db(profile)) + +@bp.route("/api/players/v1/list", methods=["POST"]) +@check_auth +def get_players_list(): + ids = (request.get_json(force=True, silent=True) or [])[:200] + profiles_map = db.get_profiles_batch(ids) + return jsonify([make_profile_from_db(profiles_map[pid]) for pid in ids if pid in profiles_map]) + +@bp.route("/api/players/v1/createProfile", methods=["POST"]) +@check_auth +def create_player_profile(): + pid = get_current_profile_id() + profile = db.get_profile(pid) if pid else None + if profile is None: + data = get_request_data() + profile = { + "Id": 1, "Username": data.get("Username", "Player"), + "DisplayName": data.get("DisplayName", "Player"), + "XP": 999999, "Level": 30, "Developer": False, "Bio": "", + "Birthday": "", "RegistrationStatus": 2, + } + return jsonify(make_profile_from_db(profile)) + +@bp.route("/api/players/v1/GetGeneratedNameOptions", methods=["GET"]) +@check_auth +def get_generated_names(): + return jsonify(["CosmicPlayer", "StarryGamer", "NeonDancer", "PixelHero", "VRExplorer"]) + +@bp.route("/api/players/v2/displayname", methods=["POST"]) +@check_auth +def set_display_name(): + pid = get_current_profile_id() + from tracking.password_tracking import has_real_password + if pid and not has_real_password(pid): + import string, random, threading + from core.state import _KITTYREC_SYSTEM_PID + from datetime import datetime, timezone + def _resend_temp(p=pid): + import time + time.sleep(2) + if not ws_registry.is_connected(p): + return + if has_real_password(p): + return + temp_pw = "".join(random.choices(string.ascii_letters + string.digits, k=8)) + _c = db._get_conn() + _c.execute( + "UPDATE profiles SET password = ? WHERE id = ? AND registration_status != 2", + (temp_pw, p), + ) + _c.commit() + profile = db.get_profile(p) + uname = (profile or {}).get("Username", f"Player {p}") + msg_text = ( + f"Welcome to KittyRec!\n" + f"Username: {uname}\n" + f"Temp password: {temp_pw}\n" + f"STOP SHARING YOUR SCREEN!\n" + f"Reply to this message with a new password (8+ chars) to register!" + ) + db.delete_messages_of_type(p, _KITTYREC_SYSTEM_PID, 30) + msg_id = db.send_message(_KITTYREC_SYSTEM_PID, p, 30, msg_text) + sent = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") + ws_registry.send(p, {"Id": 2, "Msg": { + "Id": msg_id, "FromPlayerId": _KITTYREC_SYSTEM_PID, + "SentTime": sent, "Type": 30, "Data": msg_text, + "RoomId": None, "PlayerEventId": None, + }}) + threading.Thread(target=_resend_temp, daemon=True).start() + return jsonify({"Success": False, "Message": "Register first! Check your messages."}) + new_name = sanitize_username(request.form.get("Name") or request.form.get("DisplayName") or "") + if not new_name: + data = get_request_data() + new_name = sanitize_username(data.get("Name", data.get("DisplayName", ""))) + if pid and new_name: + if not is_clean(new_name): + return jsonify({"Success": False, "Message": "That name is not allowed.", "Username": "", "DisplayName": ""}) + existing = db.get_profile_by_username(new_name) + if existing and existing.get("Id") != pid: + return jsonify({"Success": False, "Message": "Name already taken.", "Username": "", "DisplayName": ""}) + db.update_profile(pid, {"display_name": new_name, "username": new_name}) + push_profile_update(pid) + return jsonify({"Success": True, "Message": "", "Username": new_name, "DisplayName": new_name}) + +@bp.route("/api/players/v1/bio", methods=["POST"]) +@check_auth +def set_bio(): + pid = get_current_profile_id() + data = get_request_data() + bio = re.sub(r"<[^>]+>", "", str(data.get("Bio", "")))[:500] + if pid: + db.update_profile(pid, {"bio": bio}) + push_profile_update(pid) + profile = db.get_profile(pid) if pid else None + return jsonify({"Success": True, "Message": "", "Bio": profile.get("Bio", bio) if profile else bio}) + +@bp.route("/api/players/v1/birthday", methods=["POST"]) +@check_auth +def set_birthday(): + pid = get_current_profile_id() + data = get_request_data() + birthday = str(data.get("BirthdayDateString", data.get("Birthday", "")))[:32] + if pid and birthday: + db.update_profile(pid, {"birthday": birthday}) + return jsonify({ + "Success": True, + "Message": "", + "MustRestart": False, + "IsJunior": False, + }) + +@bp.route("/api/players/v2/search", methods=["GET"]) +@check_auth +def search_players(): + query = request.args.get("name", "").strip()[:100] + if query.lower() == "all": + profiles = db.search_profiles("", limit=200) + return jsonify([make_profile_from_db(p) for p in profiles]) + if not query or len(query) < 2: + online_ids = ws_registry.connected_ids() + profiles_map = db.get_profiles_batch(online_ids) + return jsonify([make_profile_from_db(p) for p in profiles_map.values()]) + profiles = db.search_profiles(query) + print(f"[Search] name={query!r} → {len(profiles)} result(s)") + return jsonify([make_profile_from_db(p) for p in profiles]) + +@bp.route("/api/players/v1/getByUsername", methods=["GET"]) +@check_auth +def get_by_username(): + name = request.args.get("name", "Player") + profile = db.get_profile_by_username(name) + if profile: + return jsonify(make_profile_from_db(profile)) + return jsonify(make_profile_from_db({ + "Id": 0, "Username": name, "DisplayName": name, + "XP": 0, "Level": 1, "Developer": False, "Bio": "", "Birthday": "", + "RegistrationStatus": 2, + })) + +@bp.route("/api/players/v2/phone", methods=["POST"]) +@check_auth +def set_phone(): + return jsonify({"Success": True, "Message": ""}) + +@bp.route("/api/players/v2/phone/verify", methods=["POST"]) +@check_auth +def verify_phone(): + return jsonify({"Success": True, "Message": ""}) + +@bp.route("/api/players/v2/updateReputation", methods=["POST"]) +@check_auth +def update_reputation(): + return Response("OK", 200) + +def _make_objective_complete(pid): + from core.constants import xp_for_client, xp_to_next_level + profile = db.get_profile(pid) + xp = profile.get("XP", 0) if profile else 0 + level = profile.get("Level", 1) if profile else 1 + return { + "deltaXp": 0, + "currentLevel": level, + "currentXp": xp_for_client(xp, level), + "xpRequiredToLevelUp": xp_to_next_level(xp, level), + } + +@bp.route("/api/players/v1/objectives", methods=["GET", "POST"]) +@limiter.limit("20 per minute") +@check_auth +def get_player_objectives(): + if request.method == "POST": + from datetime import datetime, timezone + pid = get_current_profile_id() + if not pid: + return jsonify([]) + if not session_mgr.get_player_session(pid): + print(f"[Objectives v1] Rejected pid={pid}: not in a session") + return jsonify([]) + objectives = (request.get_json(force=True, silent=True) or [])[:20] + if not isinstance(objectives, list): + objectives = [objectives] + total_xp = 0 + today = datetime.now(timezone.utc).strftime("%Y-%m-%d") + seen_lb_types: set = set() + for obj in objectives: + if not isinstance(obj, dict): + continue + additional_xp = max(0, min(int(obj.get("additionalXp", 0)), 200)) + obj_type = int(obj.get("objectiveType", -1)) + if obj_type >= 1 and obj_type not in seen_lb_types: + db.increment_leaderboard(pid, obj_type) + seen_lb_types.add(obj_type) + if additional_xp > 0: + slot = obj_type - 10 if 10 <= obj_type <= 12 else None + if slot is not None: + inserted = db.try_mark_daily_complete(pid, today, slot) + if not inserted: + print(f"[Objectives v1] Player {pid} already completed daily slot {slot} today — skipping") + continue + total_xp += additional_xp + if total_xp > 0: + db.award_xp(pid, total_xp) + push_profile_update(pid) + print(f"[Objectives v1] Player {pid} awarded {total_xp} XP from {len(objectives)} objective(s)") + return jsonify([]) + +_MAX_DAILY_SLOT_XP = 1000 + +@bp.route("/api/players/v2/objective", methods=["POST"]) +@limiter.limit("20 per minute") +@check_auth +def complete_objective_v2(): + from datetime import datetime, timezone + pid = get_current_profile_id() + if not pid: + return jsonify({"deltaXp": 0, "currentLevel": 1, "currentXp": 0, "xpRequiredToLevelUp": 300}) + if not session_mgr.get_player_session(pid): + print(f"[Objectives v2] Rejected pid={pid}: not in a session") + return jsonify(_make_objective_complete(pid)) + _raw_xp = int(request.values.get("additionalXp", 0)) + additional_xp = max(0, min(_raw_xp, _MAX_DAILY_SLOT_XP)) + if _raw_xp > _MAX_DAILY_SLOT_XP: + print(f"[SECURITY] XP cap violation: pid={pid} sent additionalXp={_raw_xp} capped={additional_xp}") + obj_type = int(request.values.get("objectiveType", -1)) + if obj_type >= 1: + db.increment_leaderboard(pid, obj_type) + if additional_xp > 0: + today = datetime.now(timezone.utc).strftime("%Y-%m-%d") + slot = obj_type - 10 if 10 <= obj_type <= 12 else None + if slot is not None: + inserted = db.try_mark_daily_complete(pid, today, slot) + if not inserted: + print(f"[Objectives] Player {pid} already completed daily slot {slot} today — skipping") + return jsonify(_make_objective_complete(pid)) + new_xp, new_level = db.award_xp(pid, additional_xp) + push_profile_update(pid) + print(f"[Objectives] Player {pid} daily slot={slot} type={obj_type}, +{additional_xp} XP → level {new_level}") + from core.constants import xp_for_client, xp_to_next_level + return jsonify({ + "deltaXp": additional_xp, + "currentLevel": new_level, + "currentXp": xp_for_client(new_xp, new_level), + "xpRequiredToLevelUp": xp_to_next_level(new_xp, new_level), + }) + return jsonify(_make_objective_complete(pid)) + +@bp.route("/api/players/v2/listByPlatformId", methods=["POST"]) +@check_auth +def list_by_platform(): + data = get_request_data() + _PLATFORM_NAMES = {0: "Steam", 1: "Oculus", 2: "PlayStation"} + platform_name = _PLATFORM_NAMES.get(int(data.get("Platform", 0)), "Steam") + platform_ids = data.get("PlatformIds", []) + result = [] + for pid_str in platform_ids: + profile = db.get_profile_by_platform(platform_name, str(pid_str)) + if profile: + result.append(make_profile_from_db(profile)) + return jsonify(result) + +@bp.route("/api/players/v1/avoidJuniors", methods=["POST"]) +@check_auth +def avoid_juniors(): + return Response("OK", 200) + +@bp.route("/api/players/v1/deleteProfile", methods=["POST"]) +@check_auth +def delete_profile(): + return jsonify({"Success": True, "Message": ""}) + +@bp.route("/api/players/v1/phonelastfour", methods=["GET"]) +@check_auth +def phone_last_four(): + return jsonify({"PhoneNumber": ""})