Переезд

config.json

@@ -3,7 +3,7 @@
         "host": "localhost",
         "port": 3306,
         "user": "root",
-        "password": "",
+        "password": "root",
         "database": "pywinbd"
     },
     "redis": {
@@ -28,7 +28,7 @@
         "demonRate": 0,
         "leaderboards_limit": 5,
         "lang": "en",
-        "path": "/winnertestss"
+        "path": "/winners"
     },
     "json:api": {
         "isWorked": true,

config.py

@@ -52,6 +52,7 @@ def parse_config():
     try:
         with open("./config.json", "r") as config:
             json_object = json.load(config)
+            print(json_object["use_env"])
             if json_object["use_env"]:
                 parsedb = {
                     "host": os.environ.get("POSTGRES_HOST"),
@@ -97,6 +98,7 @@ def parse_config():
                 database = Database(**json_object["database"])
                 system = System(**json_object["system"])
                 redis = Redis(**json_object["redis"])
+                print(system)
                 return {"database": database, "system": system, "redis": redis, "small_chest": chest_small, "big_chest": chest_big}
     except KeyError as ex:
         print(ex)
@@ -111,4 +113,6 @@ def parse_config():
 system = conf["system"]
 redis = conf["redis"]
 small_chest = conf["small_chest"]
-big_chest = conf["big_chest"]
+big_chest = conf["big_chest"]
+
+print(system)

src/__init__.py

@@ -15,7 +15,7 @@ async def on_startup() -> None:
 
 
 def init_apis(app: FastAPI) -> None:
-    app.mount("/winnertestss", init_gd())
+    app.mount("/winners", init_gd())
     app.mount("/v2", init_api())
 
 

src/api/levels/get_levels.py

@@ -1,51 +1,44 @@
 import numpy
 from fastapi import APIRouter
-from fastapi.responses import JSONResponse
-
-from src.errors import GenericError
-from src.schemas.levels.model import APILevelSchema
-from src.schemas.levels.service.get import GetLevel
-from src.schemas.levels.errors import LevelNotFoundError
-from src.errors import GenericError
 router = APIRouter(prefix="/levels", tags=["Levels"])
 
 
-@router.get("/{lvlid}", summary="Get level by id", responses={
-    404: {
-        "model": GenericError,
-        "description": "level with this ID not found"
-    }
-}
-            )
-async def get_levels(lvlid: int) -> JSONResponse:
-    levelData: LevelModel = (await LevelService.get_level_buid(levelID=lvlid))["database"]
-    return levelData.to_API_model()
-
-
-@router.post("/search", summary="Searching levels by filter", responses={
-    404: {
-        "model": GenericError,
-        "description": "level with this ID not found"
-    }
-}
-            )
-async def get_levelsByFilters(filters: GetLevel) -> list[APILevelSchema]:
-    """
-      Endpoint to get levels by filters
-
-      Return list of APILevel
-    """
-    try:
-        levelData: list[LevelModel] = (await LevelService.test_get_levels(filters))['database']
-        result = list[APILevelSchema]
-
-        for i in numpy.arange(levelData): # Fast range
-            result.append(i.to_API_model())
-
-        return result
-
-    except LevelNotFoundError:
-        return GenericError("Level Not Found", 404)
-
-    except TypeError as e:
-        return GenericError(f"Internal Generic Error {e}", 500)
+# @router.get("/{lvlid}", summary="Get level by id", responses={
+#     404: {
+#         "model": GenericError,
+#         "description": "level with this ID not found"
+#     }
+# }
+#             )
+# async def get_levels(lvlid: int) -> JSONResponse:
+#     levelData: LevelModel = (await LevelService.get_level_buid(levelID=lvlid))["database"]
+#     return levelData.to_API_model()
+#
+#
+# @router.post("/search", summary="Searching levels by filter", responses={
+#     404: {
+#         "model": GenericError,
+#         "description": "level with this ID not found"
+#     }
+# }
+#             )
+# async def get_levelsByFilters(filters: GetLevel) -> list[APILevelSchema]:
+#     """
+#       Endpoint to get levels by filters
+#
+#       Return list of APILevel
+#     """
+#     try:
+#         levelData: list[LevelModel] = (await LevelService.test_get_levels(filters))['database']
+#         result = list[APILevelSchema]
+#
+#         for i in numpy.arange(levelData): # Fast range
+#             result.append(i.to_API_model())
+#
+#         return result
+#
+#     except LevelNotFoundError:
+#         return GenericError("Level Not Found", 404)
+#
+#     except TypeError as e:
+#         return GenericError(f"Internal Generic Error {e}", 500)

src/api/scores/get_scores.py

@@ -1,8 +1,7 @@
 from fastapi import APIRouter
-from src.schemas.scores.get import Leaderboard
 router = APIRouter(prefix="/scores", tags=["Scores"])
 
 
-@router.get("/")
-async def get_scores() -> Leaderboard:
-    return await LeaderBoardsService.leaderboard("top")
+# @router.get("/")
+# async def get_scores() -> Leaderboard:
+#     return await LeaderBoardsService.leaderboard("top")

src/api/users/get_users.py

@@ -1,21 +1,27 @@
 from fastapi import APIRouter, Depends
-
+from src.depends.context import Context
 
 router = APIRouter(prefix="/users", tags=["Users"])
 
 
 @router.get("/{usrid}")
-async def get_user(usrid):
-    info(f"Request to api | /api/users/{usrid}")
-    userData = (await UserService.get_user_byid(id=usrid))["database"]
-    return {
-        "status": "ok",
-        "userName": userData.userName,
-        "role": userData.role,
-        "stats": {
-            "stars": userData.stars,
-            "diamonds": userData.diamonds,
-            "coins": userData.coins,
-            "iconkits": userData.iconkits,
-        },
-    }
+async def get_user(
+    usrid: int,
+    context: Context,
+):
+    async with context:
+        user = await context.services.users.get_user_byid(usrid)
+        return user
+    # info(f"Request to api | /api/users/{usrid}")
+    # userData = (await UserService.get_user_byid(id=usrid))["database"]
+    # return {
+    #     "status": "ok",
+    #     "userName": userData.userName,
+    #     "role": userData.role,
+    #     "stats": {
+    #         "stars": userData.stars,
+    #         "diamonds": userData.diamonds,
+    #         "coins": userData.coins,
+    #         "iconkits": userData.iconkits,
+    #     },
+    # }

src/gd/accounts/auth.py

@@ -28,8 +28,8 @@ async def register_account(
      Return status code
     """
     try:
-        await UserService().register_user(
-            userName=userName, password=password, mail=email, ip=request.client.host, ctx=context
+        await UserService(ctx=context).register_user(
+            userName=userName, password=password, mail=email, ip=request.client.host
         )
         return PlainTextResponse("1", 200)
 
@@ -52,7 +52,7 @@ async def login(
      Return userid or error code
     """
     try:
-        user: UsersModel = await UserService.login_user(context, userName, gjp2)
+        user: UsersModel = await UserService(ctx=context).login_user(userName, gjp2)
         return f"{user.id},{user.id}"
 
     # Validate errors

src/gd/accounts/page.py

@@ -77,6 +77,7 @@ async def updateGJUserScore22(
     color2: int = Form(),
     color3: int = Form()
 ):
+    print(stars)
     async with context:
         if await checkValidGJP2(ctx=context, id=accountID, gjp2=gjp2):
             iconkit = {

src/gd/levels/levels.py

@@ -12,13 +12,13 @@
 from src.schemas.levels.service.get import GetLevel
 from src.services.daily import DailyService
 from src.services.levels import LevelService
-from src.utils.security import checkValidGJP2
 from src.schemas.levels.errors import *
 router = APIRouter(tags=["Levels"])
 
 
 @router.post("/uploadGJLevel21.php")
 async def upload_level(
+        context: Context,
         levelString: str = Form(),
         accountID: int = Form(),
         levelName: str = Form(),
@@ -37,39 +37,32 @@ async def upload_level(
         gameVersion: int = Form(),
         gjp2: str = Form(),
 ):
-
-    if await checkValidGJP2(accountID, gjp2=gjp2):
-        SystemObj = UploadLevel(
-            levelString=levelString,
-            accountID=accountID,
-            levelName=levelName,
-            levelDesc=levelDesc,
-            levelVersion=levelVersion,
-            levelLength=levelLength,
-            audioTrack=audioTrack,
-            password=password,
-            original=original,
-            twoPlayer=twoPlayer,
-            songID=songID,
-            objects=objects,
-            coins=coins,
-            requestedStars=requestedStars,
-            ldm=ldm,
-            gameVersion=gameVersion,
-        )
-        service = await LevelService().upload_level(data=SystemObj)
-        # dispatch(Events.NewLevel, LevelObject(service))
-        if service["status"] == "ok":
-            print("its okey")
-            return service["level"].id
-        else:
-            error(service["details"])
-            return "-1"
+    SystemObj = UploadLevel(
+                levelString=levelString,
+                accountID=accountID,
+                levelName=levelName,
+                levelDesc=levelDesc,
+                levelVersion=levelVersion,
+                levelLength=levelLength,
+                audioTrack=audioTrack,
+                password=password,
+                original=original,
+                twoPlayer=twoPlayer,
+                songID=songID,
+                objects=objects,
+                coins=coins,
+                requestedStars=requestedStars,
+                ldm=ldm,
+                gameVersion=gameVersion,
+    )
+    service = await LevelService(context).upload_level(data=SystemObj, gjp=gjp2)
+    if service["status"] == "ok":
+        print("its okey")
+        return str(service["level"].id)
     else:
-        print("ups")
+        error(service["details"])
         return "-1"
 
-
 @router.post("/getGJLevels21.php")
 # @cache(
 #     ttl=f"{redis.ttl}s",

src/gd/misc/likes.py

@@ -1,6 +1,6 @@
 from fastapi import APIRouter, Form
 from fastapi.responses import PlainTextResponse
-
+from src.depends.context import Context
 from config import system
 from src.objects.levelObject import LevelObject
 from src.services.levels import LevelService
@@ -9,32 +9,30 @@
 
 
 @router.post(
-    f"{system.path}/likeGJItem211.php", response_class=PlainTextResponse, tags=["Misc"]
+    f"/likeGJItem211.php", response_class=PlainTextResponse, tags=["Misc"]
 )
 async def like_item(
+    context: Context,
     itemID: str = Form(),
     liketype: int = Form(alias="type"),
     accountID: str = Form(),
     like: int = Form(),
 ):
-    if liketype == 1:
-        if like == 1:
-            service = await LevelService.get_level_buid(levelID=itemID)
-
-            like = await LevelObject(service=service).like(accountID=accountID)
-            if like["status"] == "ok":
-                info("Like")
-                return "1"
-
-        elif like == 0:
-            service = await LevelService.get_level_buid(levelID=itemID)
-
-            like = await LevelObject(service=service).dislike(
-                accountID=accountID
-            )
-            if like["status"] == "ok":
-                info("Dislike")
-                return "1"
+    async with context:
+        if liketype == 1:
+            if like == 1:
+                like = await (await LevelService(context).get_level_buid(itemID)).like(accountID)
+
+                if like["status"] == "ok":
+                    context.console.info("Like")
+                    return "1"
+
+            elif like == 0:
+                dislike = await (await LevelService(context).get_level_buid(itemID)).dislike(accountID)
+
+                if dislike["status"] == "ok":
+                    context.console.info("Dislike")
+                    return "1"
 
 
 # class testClass: