482 lines
16 KiB
Python
482 lines
16 KiB
Python
from fastapi import FastAPI, Form, File, UploadFile, Header, HTTPException, Body
|
|
from fastapi.responses import PlainTextResponse
|
|
from fastapi.exceptions import RequestValidationError
|
|
from starlette.exceptions import HTTPException as StarletteHTTPException
|
|
|
|
from typing import Union, Optional, Any
|
|
import uvicorn
|
|
from . import data_types as types
|
|
from . import database as db
|
|
from . import hook_system
|
|
from . import hooks
|
|
|
|
import pymongo
|
|
|
|
app = FastAPI()
|
|
hook = hook_system.hook
|
|
|
|
|
|
@app.exception_handler(RequestValidationError)
|
|
async def http_exception_handler(request, exc):
|
|
return PlainTextResponse(f"{str(exc)}", status_code=422)
|
|
|
|
|
|
@app.exception_handler(StarletteHTTPException)
|
|
async def http_exception_handler(request, exc):
|
|
return PlainTextResponse(
|
|
f"[{exc.status_code}] {str(exc.detail)}", status_code=exc.status_code
|
|
)
|
|
|
|
|
|
## Users
|
|
|
|
|
|
@app.post("/api/v1/login")
|
|
async def login(username: str = Form(), password: str = Form(), version: str = Form()):
|
|
"""User login"""
|
|
hook.execute_hooks("player_login", username=username)
|
|
auth = db.auth_check(username + ":" + password)
|
|
if not auth[0]:
|
|
if auth[1] == "nouser":
|
|
raise HTTPException(404, detail="User not found.")
|
|
elif auth[1] == "wrongpass":
|
|
raise HTTPException(403, detail="Password is incorrect.")
|
|
else:
|
|
return {"token": username + ":" + password, "userId": auth[1]["ID"]}
|
|
|
|
|
|
@app.put("/api/v1/user")
|
|
async def create_user(
|
|
username: str = Form(),
|
|
password: str = Form(),
|
|
email: str = Form(),
|
|
version: str = Form(),
|
|
):
|
|
"""Create a user with specified credentials"""
|
|
token = username + ":" + password
|
|
|
|
UserID = len(list(db.user_collection.find({})))
|
|
if UserID == 0:
|
|
UserID = 1
|
|
|
|
insert_data = {
|
|
**types.User(Username=username, Email=email, ID=UserID).dict(),
|
|
"Password": password,
|
|
}
|
|
|
|
db.user_collection.insert_one(insert_data)
|
|
return {"token": token, "userId": UserID}
|
|
|
|
|
|
@app.get("/api/v1/notifunread")
|
|
async def notifunread():
|
|
"""Returns the number of unread notifications."""
|
|
# FIXME Add notifications
|
|
return 0
|
|
|
|
|
|
@app.get("/api/v1/refresh")
|
|
async def refresh_login(Authorization: Union[str, None] = Header(default=None)):
|
|
"""Intended for refreshing user token."""
|
|
return {"token": Authorization}
|
|
|
|
|
|
@app.get("/api/v1/user/{user_id}")
|
|
async def get_user(user_id: int):
|
|
"""Returns specified user's profile."""
|
|
query = db.user_collection.find_one({"ID": user_id})
|
|
del query["Password"]
|
|
return types.User(**query)
|
|
|
|
|
|
## Maps
|
|
|
|
|
|
@app.get("/api/v1/mapcount")
|
|
async def mapcount():
|
|
return len(list(db.maps_collection.find({})))
|
|
|
|
|
|
@app.get("/api/v1/useruploadcooldown")
|
|
async def useruploadcooldown():
|
|
"""Limits the amount of levels that user can upload."""
|
|
return {"success": True}
|
|
|
|
|
|
@app.get("/api/v1/map")
|
|
async def search_for_maps(
|
|
start: int = 0,
|
|
limit: int = 5,
|
|
min_diff: float = 0.0,
|
|
max_diff: float = 5.0,
|
|
order: str = '[{ "Dir": "desc", "Name": "created_at" }]',
|
|
name: str = "",
|
|
author: str = "",
|
|
author_id: Optional[int] = None,
|
|
last_x_hours: Optional[int] = None,
|
|
):
|
|
"""Search for maps."""
|
|
|
|
# query = db.maps_collection.find({ "CreatorId": author_id }).limit(limit)
|
|
query = db.maps_collection.find({}).limit(limit)
|
|
entries = []
|
|
for i in query:
|
|
del i["_id"]
|
|
del i["MapData"]
|
|
entries.append(i)
|
|
return entries
|
|
|
|
|
|
@app.get("/api/v1/map/{mapID}")
|
|
async def getMap(mapID: int):
|
|
query = db.maps_collection.find_one({"ID": mapID})
|
|
del query["_id"]
|
|
return query
|
|
|
|
|
|
@app.post("/api/v1/map/{mapID}/start")
|
|
async def getMap(mapID: int):
|
|
query = db.maps_collection.find_one({"ID": mapID})
|
|
del query["_id"]
|
|
|
|
returned_resp = {
|
|
"BestDeaths": 0,
|
|
"BestPlaytime": 0,
|
|
"Clear": False,
|
|
"CurMap": query,
|
|
"Difficulty": 0,
|
|
"Followed": False,
|
|
"Played": True,
|
|
"Rating": 5,
|
|
"TagIDs": "1,8,9",
|
|
"TagNames": "Boss/Avoidance,Music,Art",
|
|
}
|
|
return returned_resp
|
|
|
|
|
|
@app.post("/api/v1/map/{mapID}/stop")
|
|
async def stopMapPlay(
|
|
mapID: int,
|
|
clear: int = Form(),
|
|
deaths: int = Form(),
|
|
playtime: int = Form(),
|
|
totalDeaths: int = Form(),
|
|
totalTime: int = Form(),
|
|
replayData: str = Form(),
|
|
Authorization: Union[str, None] = Header(default=None),
|
|
):
|
|
"""Saves the map replay, and informs the user if their play is a record"""
|
|
authcheck = db.auth_check(Authorization)
|
|
if not authcheck[0] and authcheck[1] == "nouser":
|
|
raise HTTPException(404, detail="User not found")
|
|
elif not authcheck[0] and authcheck[1] == "wrongpass":
|
|
raise HTTPException(403, detail="Wrong password")
|
|
elif authcheck[0]:
|
|
NewMapRecord = False
|
|
FirstClear = False
|
|
|
|
userData = types.User(**authcheck[1])
|
|
|
|
query = db.maps_collection.find_one(
|
|
{"ID": mapID, "Leaderboard.UserID": userData.ID}
|
|
)
|
|
if query is not None:
|
|
del query["_id"]
|
|
print(__import__("json").dumps(query, indent=4))
|
|
|
|
BestUserTime = None
|
|
BestTime = None
|
|
if query is not None and "Leaderboard" in query:
|
|
print("-" * 3)
|
|
for i in query["Leaderboard"]:
|
|
if i["UserID"] == userData.ID:
|
|
if BestUserTime is None or BestUserTime > i["BestPlaytime"]:
|
|
BestUserTime = i["BestPlaytime"]
|
|
if BestTime is None or BestTime > i["BestPlaytime"]:
|
|
BestTime = i["BestPlaytime"]
|
|
if len(query["Leaderboard"]) <= 1 and i["UserID"] != userData.ID:
|
|
FirstClear = True
|
|
print(BestUserTime, BestTime)
|
|
if BestUserTime is None or playtime < BestUserTime:
|
|
print(BestUserTime)
|
|
|
|
updateQuery = db.maps_collection.update_one(
|
|
{"ID": mapID},
|
|
{"$pull": {"Leaderboard": {"UserID": userData.ID}},
|
|
}
|
|
)
|
|
updateQuery = db.maps_collection.update_one(
|
|
{"ID": mapID},
|
|
{
|
|
"$push": {
|
|
"Leaderboard": types.MapLeaderboard(
|
|
ShoesColor=userData.ShoesColor,
|
|
PantsColor=userData.PantsColor,
|
|
ShirtColor=userData.ShirtColor,
|
|
CapeColor=userData.CapeColor,
|
|
SkinColor=userData.SkinColor,
|
|
HairColor=userData.HairColor,
|
|
HatSpr=userData.HatSpr,
|
|
Country=userData.Country,
|
|
HairSpr=userData.HairSpr,
|
|
HatColor=userData.HatColor,
|
|
HatColorInv=userData.HatColorInv,
|
|
FacialExpression=userData.FacialExpression,
|
|
DeathEffect=userData.DeathEffect,
|
|
GunSpr=userData.GunSpr,
|
|
BulletSpr=userData.BulletSpr,
|
|
SwordSpr=userData.SwordSpr,
|
|
Costume=userData.Costume,
|
|
FollowerSpr=userData.FollowerSpr,
|
|
FollowerColor=userData.FollowerColor,
|
|
SaveEffect=userData.SaveEffect,
|
|
TextSnd=userData.TextSnd,
|
|
BestPlaytime=playtime,
|
|
BestPlaytimeTime="2020-02-13T15:19:33Z",
|
|
BestReplay=replayData,
|
|
CreatorName=userData.Username,
|
|
UserID=userData.ID,
|
|
).dict()
|
|
},
|
|
},
|
|
)
|
|
if BestTime is None or playtime < BestTime:
|
|
print(BestTime, playtime)
|
|
NewMapRecord = True
|
|
|
|
hook.execute_hooks(
|
|
"map_finished",
|
|
user=userData,
|
|
mapID=mapID,
|
|
clear=clear,
|
|
deaths=deaths,
|
|
playtime=playtime,
|
|
FirstClear=FirstClear,
|
|
NewMapRecord=NewMapRecord,
|
|
)
|
|
|
|
return {"FirstClear": FirstClear, "NewMapRecord": NewMapRecord}
|
|
|
|
|
|
@app.put("/api/v1/map")
|
|
async def upload_map(
|
|
Authorization: Union[str, None] = Header(default=None),
|
|
mapName: str = Form(),
|
|
mapDescription: str = Form(default=""),
|
|
mapVersion: int = Form(),
|
|
mapData: str = Form(),
|
|
file: Optional[UploadFile] = None,
|
|
mapReplay: str = Form(),
|
|
deaths: int = Form(),
|
|
playtime: int = Form(),
|
|
totalDeaths: int = Form(),
|
|
totalTime: int = Form(),
|
|
listed: int = Form(),
|
|
requiresCancels: int = Form(),
|
|
hideInChallenges: int = Form(),
|
|
tags: str = Form(),
|
|
rng: int = Form(),
|
|
clientVersion: float = Form(),
|
|
):
|
|
authcheck = db.auth_check(Authorization)
|
|
if not authcheck[0] and authcheck[1] == "nouser":
|
|
raise HTTPException(404, detail="User not found")
|
|
elif not authcheck[0] and authcheck[1] == "wrongpass":
|
|
raise HTTPException(403, detail="Wrong password")
|
|
elif authcheck[0]:
|
|
print(authcheck)
|
|
userData = types.User(**authcheck[1])
|
|
ID = len(list(db.maps_collection.find({}))) + 1
|
|
MapCode = db.id_to_mapcode(ID)
|
|
db.maps_collection.insert_one(
|
|
{
|
|
**types.Map(
|
|
CreatorName=userData.Username,
|
|
CreatorId=userData.ID,
|
|
ID=ID,
|
|
Name=mapName,
|
|
Description=mapDescription,
|
|
Version=mapVersion,
|
|
MapCode=MapCode,
|
|
MapData=mapData,
|
|
Listed=bool(listed),
|
|
HiddenInChallenges=hideInChallenges,
|
|
TagIDs=tags,
|
|
TagNames=",".join(types.convertTagsToNames(tags)),
|
|
ShoesColor=userData.ShoesColor,
|
|
PantsColor=userData.PantsColor,
|
|
ShirtColor=userData.ShirtColor,
|
|
CapeColor=userData.CapeColor,
|
|
SkinColor=userData.SkinColor,
|
|
HairColor=userData.HairColor,
|
|
HatSpr=userData.HatSpr,
|
|
Country=userData.Country,
|
|
HairSpr=userData.HairSpr,
|
|
HatColor=userData.HatColor,
|
|
HatColorInv=userData.HatColorInv,
|
|
FacialExpression=userData.FacialExpression,
|
|
DeathEffect=userData.DeathEffect,
|
|
GunSpr=userData.GunSpr,
|
|
BulletSpr=userData.BulletSpr,
|
|
SwordSpr=userData.SwordSpr,
|
|
Costume=userData.Costume,
|
|
FollowerSpr=userData.FollowerSpr,
|
|
FollowerColor=userData.FollowerColor,
|
|
SaveEffect=userData.SaveEffect,
|
|
TextSnd=userData.TextSnd,
|
|
Leaderboard=[
|
|
types.MapLeaderboard(
|
|
BestPlaytime=playtime,
|
|
BestPlaytimeTime="2020-02-13T15:19:33Z",
|
|
BestReplay=mapReplay,
|
|
CreatorName=userData.Username,
|
|
UserID=userData.ID,
|
|
).dict()
|
|
],
|
|
).dict()
|
|
}
|
|
)
|
|
return {"MapCode": MapCode}
|
|
# raise HTTPException(501)
|
|
|
|
|
|
@app.get("/api/v1/map/{mapID}/besttimes/{maxEntries}")
|
|
async def getMapLeaderboard(mapID, maxEntries):
|
|
"""Returns maxEntries records for the specified level"""
|
|
query = db.maps_collection.find_one({"ID": int(mapID)})
|
|
if not query:
|
|
raise HTTPException(404, detail="Map not found")
|
|
del query["_id"]
|
|
leaderboard = query["Leaderboard"]
|
|
|
|
return sorted(leaderboard, key=lambda sort: sort["BestPlaytime"])[0:5]
|
|
|
|
|
|
@app.get("/api/v1/map/{mapID}/userbesttime/{userID}")
|
|
async def getPlayerRecord(mapID, userID):
|
|
"""Returns specific replay"""
|
|
query = db.maps_collection.find_one({"ID": int(mapID)})
|
|
if not query:
|
|
raise HTTPException(404, detail="Map not found")
|
|
del query["_id"]
|
|
leaderboard = query["Leaderboard"]
|
|
|
|
# Find user
|
|
replayIndex = None
|
|
BestTime = None
|
|
for i in range(len(leaderboard)):
|
|
print(f"DBG: {i}, {leaderboard[i]}\t{leaderboard[i]['UserID'] == int(userID):}")
|
|
if leaderboard[i]["UserID"] == int(userID) and (BestTime is None or leaderboard[i]["BestPlaytime"] < BestTime):
|
|
replayIndex = i
|
|
print(leaderboard[replayIndex])
|
|
|
|
if replayIndex is not None:
|
|
return {"BestMapTime": leaderboard[replayIndex], "Exists": True}
|
|
else:
|
|
return {"BestMapTime": None, "Exists": False}
|
|
|
|
|
|
@app.get("/api/v1/map/{mapID}/besttime")
|
|
async def getBestRecord(mapID: int):
|
|
query = db.maps_collection.find_one({"ID": int(mapID)})
|
|
BestTime = None
|
|
BestPlay = None
|
|
for i in query["Leaderboard"]:
|
|
if BestTime is None or BestTime > i["BestPlaytime"]:
|
|
BestTime = i["BestPlaytime"]
|
|
BestPlay = i
|
|
|
|
return {"BestMapTime": BestPlay, "Exists": True}
|
|
|
|
|
|
@app.post("/api/v1/map/{mapID}/invalidatealltimes")
|
|
async def invalidateAllTimes(
|
|
mapID: int,
|
|
Reason: int = Body(),
|
|
CustomReason: str = Body(default=""),
|
|
Authorization: Union[str, None] = Header(default=None),
|
|
):
|
|
"""Removes ALL records from a specific map"""
|
|
|
|
authcheck = db.auth_check(Authorization)
|
|
if not authcheck[0] and authcheck[1] == "nouser":
|
|
raise HTTPException(404, detail="User not found")
|
|
elif not authcheck[0] and authcheck[1] == "wrongpass":
|
|
raise HTTPException(403, detail="Wrong password")
|
|
elif authcheck[0]:
|
|
userData = types.User(**authcheck[1])
|
|
if userData.Admin:
|
|
query = db.maps_collection.update_one(
|
|
{"ID": mapID}, {"$push": {"Leaderboard": {"$each": [], "$slice": 0}}}
|
|
)
|
|
db.LogAdminAction(
|
|
action_type="invalidateAllTimes",
|
|
action_data={
|
|
"Reason": Reason,
|
|
"CustomReason": CustomReason,
|
|
"mapID": mapID,
|
|
},
|
|
UserID=userData.ID,
|
|
)
|
|
else:
|
|
db.LogAdminAction(
|
|
action_type="invalidateAllTimes",
|
|
action_data={
|
|
"Reason": Reason,
|
|
"CustomReason": CustomReason,
|
|
"mapID": mapID,
|
|
"unauthorized": True,
|
|
},
|
|
success=False,
|
|
)
|
|
raise HTTPException(
|
|
403,
|
|
detail="Attempted to perform an administrator action without permission. This will be reported.",
|
|
)
|
|
|
|
|
|
## General
|
|
|
|
|
|
@app.post("/api/v1/reports")
|
|
async def reportContent(
|
|
Authorization: Union[str, None] = Header(default=None),
|
|
user_id: int = Form(),
|
|
map_id: Optional[int] = Form(default=None),
|
|
report_type: int = Form(),
|
|
content: str = Form(),
|
|
):
|
|
|
|
authcheck = db.auth_check(Authorization)
|
|
if not authcheck[0] and authcheck[1] == "nouser":
|
|
raise HTTPException(404, detail="User not found")
|
|
elif not authcheck[0] and authcheck[1] == "wrongpass":
|
|
raise HTTPException(403, detail="Wrong password")
|
|
elif authcheck[0]:
|
|
db.reports_collection.insert_one(
|
|
{
|
|
"user_id": user_id,
|
|
"map_id": map_id,
|
|
"report_type": report_type,
|
|
"content": content,
|
|
}
|
|
)
|
|
return True
|
|
|
|
|
|
@app.get("/api/v1/featuredlist")
|
|
async def featuredlist():
|
|
"""Returns the list id of the weekly levels list."""
|
|
# FIXME Add playlists
|
|
return
|
|
|
|
|
|
@app.get("/api/v1/followcheck")
|
|
async def followcheck():
|
|
# FIXME Find the purpouse of this endpoint
|
|
return 1
|
|
|
|
|
|
def start():
|
|
"""Launched with `poetry run start` at root level"""
|
|
uvicorn.run("customiwmserver.main:app", host="0.0.0.0", port=8001, reload=True)
|