dev

backend/api/core/Auth.py

@@ -34,7 +34,7 @@ def dict2obj(dictObj):
     return d
 
 
-async def createToken(alter: str, equVersion: str, expire=86400 / 24 * 2, redis=None, env=''):
+def createToken(alter: str, equVersion: str, redis = None, expire=86400 / 24 * 2)->str:
     ts_str = str(time.time() + expire)
     ts_byte = ts_str.encode('utf-8')
     sha1_tshex_str = hmac.new(alter.encode('utf-8'), ts_byte, 'sha1').hexdigest()
@@ -42,15 +42,16 @@ async def createToken(alter: str, equVersion: str, expire=86400 / 24 * 2, redis=
     token = base64.urlsafe_b64encode(token.encode('utf-8')).decode('utf-8')
     # character = createCharacter(alter)
     character = {}
-    await redis.set(f'token:{token}', json.dumps(AlterState(alter, token, character, equVersion).to_dict()), int(expire))
+    redis.set(f'token:{token}', json.dumps(AlterState(alter, token, character, equVersion).to_dict()), int(expire))
     return token
 
 
-async def readToken(token: str, redis, env) -> AlterState:
+def readToken(token: str, redis) -> AlterState:
     info = None
     try:
-        info = dict2obj(json.loads(await redis.get(f'token:{token}')))
-    except Exception:
+        info = dict2obj(json.loads(redis.get(f'token:{token}')))
+    except Exception as ex:
+        print(ex)
         ResponseException('登录过期或无效Token，请刷新后重试')
     if info is None:
         raise ResponseException('登录过期或无效Token，请刷新后重试')
@@ -62,20 +63,7 @@ def deleteToken(token, redis, env):
     return token
 
 
-async def authorize(request: Request, access_token: Optional[str] = Header(None)):
-    if access_token is not None:
-        info = await readToken(access_token, request.app.state.redis, request.app.state.env)
-        return info
-    else:
-        raise ResponseException('登录过期或无效Token，请刷新后重试')
-
-
-def unauthorize(request: Request, access_token: Optional[str] = Header(None)):
-    if access_token is not None:
-        return deleteToken(access_token, request.app.state.redis, request.app.state.env)
-
-
-async def uid(request: Request, access_uid: Optional[str] = Header(None)):
+def uid(access_uid: Optional[str] = Header(None)):
     try:
         return int(access_uid)
     except Exception:

backend/api/dp.py

@@ -1,9 +1,26 @@
-from typing import Annotated
+from typing import Annotated, Optional
 from redis import Redis
 from sqlalchemy.orm import Session
-from fastapi import Depends
+from fastapi import Depends, Header
 
+from api.core.exception import ResponseException
 from database.connect import get_db,get_redis
+from api.core.Auth import AlterState, deleteToken, readToken
 
 SessionDep = Annotated[Session, Depends(get_db)]
 RedisDep = Annotated[Redis, Depends(get_redis)]
+
+
+def authorize(redis:RedisDep, access_token: Optional[str] = Header(None)):
+    if access_token is not None:
+        info = readToken(access_token, redis)
+        return info
+    else:
+        raise ResponseException('登录过期或无效Token，请刷新后重试')
+
+
+def unauthorize(redis:RedisDep, access_token: Optional[str] = Header(None)):
+    if access_token is not None:
+        return deleteToken(access_token, redis)
+
+AltersDep = Annotated[AlterState, Depends(authorize)]

backend/api/routes/info.py

@@ -4,7 +4,8 @@ import json
 from fastapi import APIRouter,Request
 from api.core.Response import Return, response
 from api.core.Redis import get_redis_info
-from api.dp import RedisDep
+from api.dp import RedisDep,AltersDep
+from core.basic.character import createCharacter
 
 router = APIRouter()
 
@@ -20,22 +21,20 @@ async def get_adventure_info(request: Request,redis:RedisDep):
 
     return response(data=adventure_info)
 
-@router.get('/equipment/list')
-async def get_equipment_list(request: Request,redis:RedisDep):
-    def get_equipment_list():
-        with open('./dataFiles/equipment-list.json', encoding='utf-8') as fp:
-            return json.load(fp)
-    equipment_list = get_redis_info(redis, 'dcalc:equipment', get_equipment_list)
-
-    return response(data=equipment_list)
-
-@router.get("/token/get/{alter}", response_model=Return[str])
-async def getToken(
-    alter: str, request: Request, version: str = None, equVersion: str = ""
+@router.get("/token/get/{alter}")
+async def getToken(redis:RedisDep,
+    alter: str, request: Request, version: str = None, equVersion: str = "0"
 ):
-    if version is not None and version != "default" and version != "":
-        alter = version + "." + alter
-    token = createToken(
-        alter, equVersion, redis=request.app.state.redis, env=request.app.state.env
-    )
+    token = createToken(alter, equVersion, redis)
     return response(data=token)
+
+@router.get("/character")
+async def get_character_info(
+    request: Request, state: AltersDep ,redis:RedisDep
+):
+    character = createCharacter(state.alter, state.equVersion)
+    def get_character():
+        return character.getInfo()
+    info = get_redis_info(redis, f"dcalc:character:{state.alter}", get_character)
+    return response(data=info)
+