仓库初始化

app/routes/__init__.py

@@ -0,0 +1 @@
+from . import *

app/routes/character.py

@@ -0,0 +1,35 @@
+from fastapi import APIRouter, HTTPException, status
+from ..controllers.character import *
+from fastapi import Depends
+from sqlalchemy.orm import Session
+from ..dependencies.database import get_db
+
+router = APIRouter()
+
+
+#角色创建接口
+@router.post("/characters",response_model=CharacterCreateResponse)
+async def create_character(character:CharacterCreateRequest, db: Session = Depends(get_db)):
+    response = await create_character_handler(character, db)
+    return response
+
+
+#用户更新接口
+@router.put("/characters/{character_id}",response_model=CharacterUpdateResponse)
+async def update_character(character_id:int,character:CharacterUpdateRequest, db: Session = Depends(get_db)):
+    response = await update_character_handler(character_id, character, db)
+    return response
+
+
+#角色删除接口
+@router.delete("/characters/{character_id}", response_model=CharacterDeleteResponse)
+async def delete_character(character_id: int, db: Session = Depends(get_db)):
+    response = await delete_character_handler(character_id, db)
+    return response
+
+
+#角色查询接口
+@router.get("/characters/{character_id}",response_model=CharacterQueryResponse)
+async def get_character(character_id: int, db: Session = Depends(get_db)):
+    response = await get_character_handler(character_id, db)
+    return response

app/routes/chat.py

@@ -0,0 +1,48 @@
+from fastapi import APIRouter, HTTPException, status, WebSocket
+from ..controllers.chat import *
+from fastapi import Depends
+from ..dependencies.database import get_db
+from ..dependencies.redis import get_redis
+
+router = APIRouter()
+
+
+#创建新聊天接口
+@router.post("/chats", response_model=ChatCreateResponse)
+async def create_chat(chat: ChatCreateRequest, db=Depends(get_db), redis=Depends(get_redis)):
+    response = await create_chat_handler(chat, db, redis)
+    return response
+
+#删除聊天接口
+@router.delete("/chats/{user_character_id}", response_model=ChatDeleteResponse)
+async def delete_chat(user_character_id: int, db=Depends(get_db), redis=Depends(get_redis)):
+    response = await delete_chat_handler(user_character_id, db, redis)
+    return response
+
+#非流式聊天
+@router.post("/chats/non-streaming", response_model=ChatNonStreamResponse)
+async def non_streaming_chat(chat: ChatNonStreamRequest,db=Depends(get_db), redis=Depends(get_redis)):
+    raise HTTPException(status_code=status.HTTP_403_FORBIDDEN,detail="this api is not available")
+    response = await non_streaming_chat_handler(chat, db, redis)
+    return response
+
+
+#流式聊天_单次
+@router.websocket("/chat/streaming/temporary")
+async def streaming_chat(ws: WebSocket,db=Depends(get_db), redis=Depends(get_redis)):
+    await ws.accept()
+    await streaming_chat_temporary_handler(ws,db,redis)
+
+
+#流式聊天_持续
+@router.websocket("/chat/streaming/lasting")
+async def streaming_chat(ws: WebSocket,db=Depends(get_db), redis=Depends(get_redis)):
+    await ws.accept()
+    await streaming_chat_lasting_handler(ws,db,redis)
+
+
+#语音通话
+@router.websocket("/chat/voice_call")
+async def voice_chat(ws: WebSocket,db=Depends(get_db), redis=Depends(get_redis)):
+    await ws.accept()
+    await voice_call_handler(ws,db,redis)

app/routes/session.py

@@ -0,0 +1,29 @@
+from fastapi import APIRouter, Query, HTTPException, status
+from ..controllers.session import *
+from fastapi import Depends
+from ..dependencies.database import get_db
+from ..dependencies.redis import get_redis
+
+
+router = APIRouter()
+
+
+#session_id查询接口
+@router.get("/sessions", response_model=SessionIdQueryResponse)
+async def get_session_id(user_id: int=Query(..., description="用户id"), character_id: int=Query(..., description="角色id"),db=Depends(get_db)):
+    response = await get_session_id_handler(user_id, character_id, db)
+    return response
+
+
+#session查询接口
+@router.get("/sessions/{session_id}", response_model=SessionQueryResponse)
+async def get_session(session_id: str, db=Depends(get_db), redis=Depends(get_redis)):
+    response = await get_session_handler(session_id, db, redis)
+    return response
+
+
+#session更新接口
+@router.put("/sessions/{session_id}", response_model=SessionUpdateResponse)
+async def update_session(session_id: str, session_data: SessionUpdateRequest, db=Depends(get_db), redis=Depends(get_redis)):
+    response = await update_session_handler(session_id, session_data, db, redis)
+    return response

app/routes/user.py

@@ -0,0 +1,71 @@
+from fastapi import APIRouter, HTTPException, status
+from ..controllers.user import *
+from fastapi import Depends
+from sqlalchemy.orm import Session
+from ..dependencies.database import get_db
+
+
+router = APIRouter()
+
+
+#角色创建接口
+@router.post('/users', response_model=UserCrateResponse)
+async def create_user(user: UserCrateRequest,db: Session = Depends(get_db)):
+    response = await create_user_handler(user,db)
+    return response
+
+
+#角色更新接口
+@router.put('/users/{user_id}', response_model=UserUpdateResponse)
+async def update_user(user_id: int, user: UserUpdateRequest, db: Session = Depends(get_db)):
+    response = await update_user_handler(user_id, user, db)
+    return response
+
+
+#角色删除接口
+@router.delete('/users/{user_id}', response_model=UserDeleteResponse)
+async def delete_user(user_id: int, db: Session = Depends(get_db)):
+    response = await delete_user_handler(user_id, db)
+    return response
+
+
+#角色查询接口
+@router.get('/users/{user_id}', response_model=UserQueryResponse)
+async def get_user(user_id: int, db: Session = Depends(get_db)):
+    response = await get_user_handler(user_id, db)
+    return response
+
+
+#硬件绑定接口
+@router.post('/users/hardware',response_model=HardwareBindResponse)
+async def bind_hardware(hardware: HardwareBindRequest, db: Session = Depends(get_db)):
+    response = await bind_hardware_handler(hardware, db)
+    return response
+
+
+#硬件解绑接口
+@router.delete('/users/hardware/{hardware_id}',response_model=HardwareUnbindResponse)
+async def unbind_hardware(hardware_id: int, db: Session = Depends(get_db)):
+    response = await unbind_hardware_handler(hardware_id, db)
+    return response
+
+
+#硬件换绑
+@router.put('/users/hardware/{hardware_id}/bindchange',response_model=HardwareChangeBindResponse)
+async def change_bind_hardware(hardware_id: int, user: HardwareChangeBindRequest, db: Session = Depends(get_db)):
+    response = await change_bind_hardware_handler(hardware_id, user, db)
+    return response
+
+
+#硬件信息更新
+@router.put('/users/hardware/{hardware_id}/info',response_model=HardwareUpdateResponse)
+async def update_hardware_info(hardware_id: int, hardware: HardwareUpdateRequest, db: Session = Depends(get_db)):
+    response = await update_hardware_handler(hardware_id, hardware, db)
+    return response
+
+
+#硬件查询
+@router.get('/users/hardware/{hardware_id}',response_model=HardwareQueryResponse)
+async def get_hardware(hardware_id: int, db: Session = Depends(get_db)):
+    response = await get_hardware_handler(hardware_id, db)
+    return response