'refactor'

.env

@@ -1 +0,0 @@
-API_BASE_URL=https://api-dev.futabus.vn

.gitignore

@@ -0,0 +1 @@
+.env

Dockerfile

@@ -1,6 +1,8 @@
-FROM python:3.9
+FROM python:3.10.4
 
-ENV API_BASE_URL https://api-dev.futabus.vn
+ENV API_BASE_URL 'https://api-dev.futabus.vn'
+ENV API_ACCESS_TOKEN 'https://api-dev.futabus.vn/identity/api/token/anonymous-token'
+ENV ENVIRONMENT 'dev'
 
 COPY . .
 

app/busbooking-451909-aa92e337868d.json

@@ -1,13 +0,0 @@
-{
-  "type": "service_account",
-  "project_id": "busbooking-451909",
-  "private_key_id": "aa92e337868d77340f1e1bc3d0119738f48b8a49",
-  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDwozPFZx+v2DH+\nXFMLaft+4tnaWKPDGEgQ0IGwmXUtgVzd7iuH/fI9tXFiRw1ecFGAzundf1qiJJis\npMgfMxXm5fWpaKa4AM5LKxootKYPLZeJ3/N+BhJkCSmDXZmk6TuBff3WBRUkDj9n\nQTnpRSCBsCxArvm2zw6PSUqHwPiW/g05q6escmHXZUO3wpLgFz41u1Xy7M2Rc/bO\n3j6OYogYxZkp5aY5EpWhUKO2+qNVaVQqDweJhQ7/M+UpX5Va9VdMAM7dm3BUIy1Y\n3c8NDgUvL5uXKljoHrPpGXm+1QZTnrT18y3Jmo5PxkIF0u/SXDnFTYl9CL876ewq\nYaN55d9fAgMBAAECggEAArpm8Nr9cfnqfy6+xkdaUZLy01Xj7WdOEdq7Taw/ttdb\nnSyBE9aeM3LmKS4TCboOQn6WCivSdDoj/PkVR71Fh0ueIGCOW1GvBQ0lC8cYht2G\ndUqzsP8SoE22ScX64vK9+PbbtNxz4+fBckM8C9f7yVyc89LIA/mO+bLkBGv8pYGQ\nNg2Po8Oi8wjA06XMEaFVfrURnyQoUVVeIXBn/L0TViL/vSo0wshYQw9hoXI6RrUW\n1SDjfRmzOIt63R7x4Bn/BZYvgjtRewAL325ooZVXqrzXHZ9yinC/7BIrxQCF9Ncr\nuKok9SDhNES2OUUbO8QlwW4EVvTkiCb59r26jqU26QKBgQD6K2AyZ1u2XRI9HpW3\nsAeshUDcG/Gj0cnWQlpe6hr+UOrMt7LIgOhuQeR1/5EZ/ZLG8FYKE096ffP/2ND8\nG+JzTTj5Fiv9ZzUdKWPQGE5D6TwJmVAO6R8ZaodykkIgg7Thn17og4EbeSAqNtey\nh2LSLnYrT9imjfR78n+vPYCwfQKBgQD2PvRknpN+zMYnMUA/pho0/c7G8kbORiWp\nDpHabHDbtdKSgWC3enQ3bVPSeGiZNvrjSar+1/8H2C3WovhgYTp4o7+IdM2cKWOZ\nJsQNbgoXYgeaylIiwZGRQN0x1q4ho2w3UGxu3spupyFFo8yNRay8JkCI6OMX+ZWd\nG2QXQEOSCwKBgQCrZa55uhC+x9NoJp1DBYqsa3t9knOi3mffsQRDhTdLSFsmOTF3\nZ8JXUDPbmGZsnSvDuwPn0UUh0kuq3XyJTf1/K8g9+C/ZZK2iNipZd12f75sfpHeS\nT6vr+O2l1IkTx8jU0CDxQq/hB8K+yWZMva85+3UgxYrUyetYRFOw131k7QKBgGxc\nt9+viOi75FdK7SMVTWMUbfJOm6oaZGhI6RZdsix9jvS5yn3zfUEG82QjaKRD9ZQf\nzwfmtWwWTdWuUe7X2otMQ/UgsXqPHC1BSfU+/2Ha2c3cStjQpeZtzOkpt+dFq1GM\nKqt/j0WydonW0yU4DBOgIbYeBhF+28APVbSFqzaRAoGBAPRPNNCJcbIsCZEyBgwn\nCgK9W5anZDVmtwXbAVAoKMzzxFVi49W+6Lduw9oeTqgx9J1AdQMwV27I0hcPtfBE\nw5IVhrQsd6dRKDt/CJwEN6/iR9AqLx3T/rO342yOIi9GSPsFISQiiPDywfkNSzj6\nhT0eDw3eRs/RUv0zqcjFUjNI\n-----END PRIVATE KEY-----\n",
-  "client_email": "[email protected]",
-  "client_id": "111019976759266480456",
-  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
-  "token_uri": "https://oauth2.googleapis.com/token",
-  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
-  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/chatbot%40busbooking-451909.iam.gserviceaccount.com",
-  "universe_domain": "googleapis.com"
-}

app/core/config.py

@@ -1,9 +0,0 @@
-import os
-from dotenv import load_dotenv
-
-load_dotenv()  # Load biến môi trường từ file .env
-
-class Settings:
-    API_BASE_URL = os.getenv("API_BASE_URL")  # API gốc (backend dev)
-
-settings = Settings()

app/dialogflow/api/router.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from fastapi import APIRouter
+
+from app.dialogflow.api.v1.dialogflow import router as dialogflow_router
+from core.conf import settings
+
+v1 = APIRouter(prefix=settings.FASTAPI_API_V1_PATH)
+
+v1.include_router(dialogflow_router)

app/{api/routes.py → dialogflow/api/v1/dialogflow.py}

@@ -3,67 +3,34 @@ from fastapi import FastAPI, APIRouter, HTTPException, Request, Response # type:
 from fastapi.responses import JSONResponse, RedirectResponse, HTMLResponse # type: ignore
 from datetime import datetime, timedelta
 from fastapi.templating import Jinja2Templates
+from app.dialogflow.services.dialog_service import dialog_service
 
 
-from app.services import api
-from app.utils.constants import code_province
-from app.types.Respone import DialogFlowResponseAPI
+from common.external.external_api import api
+from app.dialogflow.services.origin_codes import origin_codes
+from common.response.respone_dialogflow import DialogFlowResponseAPI
 router = APIRouter()
 
-templates = Jinja2Templates(directory="app/templates")
-
-def to_datetime_from_Dialogflow(time: dict):
-    date_time = datetime(int(time["year"]), int(time["month"]), int(time["day"]))
-    return date_time
-
-def process_dates_to_timestamp(from_time: datetime = None, to_time: datetime = None):
-    if to_time is None and from_time is not None:
-        to_time = from_time.replace(hour=23, minute=59, second=59)
-    
-    if from_time is None:
-        today = datetime.today().date()
-        from_time = datetime.combine(today, datetime.min.time())
-        to_time = datetime.combine(today, datetime.max.time()) - timedelta(microseconds=1)
-
-    return int(from_time.timestamp()) * 1000 , int(to_time.timestamp()) * 1000
-def get_param_from_dialogflow(body: any):
-    session_info = body.get("sessionInfo", {})
-    parameters = session_info.get("parameters", {}) if isinstance(session_info.get("parameters"), dict) else {}
-    raw_date = parameters.get("date")
-    if raw_date is not None:
-        raw_date = to_datetime_from_Dialogflow(raw_date)
-    raw_departure_city = parameters.get("departure_city")
-    raw_destination_city = parameters.get("destination_city")
-    raw_ticket_number = parameters.get("ticket_number")
-    raw_time_of_day = parameters.get("time_of_day")
-    return raw_departure_city, raw_destination_city, raw_ticket_number, raw_date, raw_time_of_day
-
-async def search_route_ids_from_province(departure_code: str, destination_code: str):
-    response = await api.get(f'/metadata/office/routes?DestCode={destination_code}&OriginCode={departure_code}')
-    route_ids = []
-    if isinstance(response, list):  # Kiểm tra nếu data là danh sách
-            route_ids = [route.get("routeId", -1) for route in response]
-
-    return route_ids
+templates = Jinja2Templates(directory="templates")
 
 @router.post('/routes')
 async def route(request: Request):
     body = await request.json()
-    raw_departure_city, raw_destination_city, raw_ticket_number , raw_date, _ = get_param_from_dialogflow(body)
+    raw_departure_city, raw_destination_city, raw_ticket_number , raw_date, _ = dialog_service.get_param_from_dialogflow(body)
     
     
     ticket_count = int(raw_ticket_number) if raw_ticket_number else 1
 
     if raw_date is None:
-        from_time, to_time = process_dates_to_timestamp()
+        from_time, to_time = dialog_service.process_dates_to_timestamp()
         date = datetime.today().date().strftime('%m-%d-%Y')
     else:
         date = raw_date.strftime('%m-%d-%Y')
-        from_time, to_time = process_dates_to_timestamp(raw_date)
-    departure_code = code_province.get(raw_departure_city)
-    destination_code = code_province.get(raw_destination_city)
-    route_dep_to_des = await search_route_ids_from_province(departure_code,destination_code)
-    route_des_to_dep = await search_route_ids_from_province(destination_code,departure_code)
+        from_time, to_time = dialog_service.process_dates_to_timestamp(raw_date)
+    departure_code = origin_codes.get(raw_departure_city)
+    destination_code = origin_codes.get(raw_destination_city)
+    route_dep_to_des = await dialog_service.search_route_ids_from_province(departure_code,destination_code)
+    route_des_to_dep = await dialog_service.search_route_ids_from_province(destination_code,departure_code)
     routes_ids = list(set(route_dep_to_des + route_des_to_dep))
     payload = {
         "from_time": from_time,
@@ -128,16 +95,16 @@ async def route(request: Request):
 @router.post('/price')
 async def price(request: Request):
     body = await request.json()
-    raw_departure_city, raw_destination_city, _, raw_date, _ = get_param_from_dialogflow(body)
+    raw_departure_city, raw_destination_city, _, raw_date, _ = dialog_service.get_param_from_dialogflow(body)
     
     if raw_date is None:
-        from_time, to_time = process_dates_to_timestamp()
-    from_time, to_time = process_dates_to_timestamp(raw_date)
+        from_time, to_time = dialog_service.process_dates_to_timestamp()
+    from_time, to_time = dialog_service.process_dates_to_timestamp(raw_date)
 
-    departure_code = code_province.get(raw_departure_city)
-    destination_code = code_province.get(raw_destination_city)
-    route_dep_to_des = await search_route_ids_from_province(departure_code,destination_code)
-    route_des_to_dep = await search_route_ids_from_province(destination_code,departure_code)
+    departure_code = origin_codes.get(raw_departure_city)
+    destination_code = origin_codes.get(raw_destination_city)
+    route_dep_to_des = await dialog_service.search_route_ids_from_province(departure_code,destination_code)
+    route_des_to_dep = await dialog_service.search_route_ids_from_province(destination_code,departure_code)
     routes_ids = list(set(route_dep_to_des + route_des_to_dep))
     payload = {
         "from_time": from_time,
@@ -193,17 +160,17 @@ async def price(request: Request):
 @router.post('/trip/list')
 async def booking_trip(request: Request) -> Response:
     body = await request.json()
-    raw_departure_city, raw_destination_city, raw_ticket_number, raw_date, raw_time_of_day = get_param_from_dialogflow(body)
+    raw_departure_city, raw_destination_city, raw_ticket_number, raw_date, raw_time_of_day = dialog_service.get_param_from_dialogflow(body)
     
     date = raw_date.strftime('%m-%d-%Y')
-    from_time, to_time = process_dates_to_timestamp(raw_date)
+    from_time, to_time = dialog_service.process_dates_to_timestamp(raw_date)
     ticket_count = int(raw_ticket_number) if raw_ticket_number else 1
 
-    departure_code = code_province.get(raw_departure_city)
-    destination_code = code_province.get(raw_destination_city)
+    departure_code = origin_codes.get(raw_departure_city)
+    destination_code = origin_codes.get(raw_destination_city)
 
-    route_dep_to_des = await search_route_ids_from_province(departure_code,destination_code)
-    route_des_to_dep = await search_route_ids_from_province(destination_code,departure_code)
+    route_dep_to_des = await dialog_service.search_route_ids_from_province(departure_code,destination_code)
+    route_des_to_dep = await dialog_service.search_route_ids_from_province(destination_code,departure_code)
     routes_ids = list(set(route_dep_to_des + route_des_to_dep))
     payload = {
         "from_time": from_time,
@@ -233,7 +200,9 @@ async def booking_trip(request: Request) -> Response:
                                 "id": trip["id"],
                                 "departure_date": trip["raw_departure_date"],
                                 "departure_time": trip["raw_departure_time"],
-                                "kind": trip["seat_type_name"]
+                                "kind": trip["seat_type_name"],
+                                "way_id": trip["way_id"]
+
                                 })
                 text = ["Quý khách vui lòng lựa chọn chuyến xe\n" + "\n".join(f"{i+1}. {name}" for i, name in enumerate(routes_name))]
                 payload={
@@ -301,13 +270,16 @@ async def is_valid_select_trip(request: Request) -> Response:
             if trip["route_name"] == raw_input:
                 route_id = int(trip["route_id"])
                 kind = trip["kind"]
+                way_id = trip["way_id"]
                 break
         
         parameters = {
                 "is_valid_trip": True,
                 "route_name": raw_input,
                 "kind": kind,
-                "route_id": route_id
+                "route_id": route_id,
+                "way_id": way_id,
+                
             }
     else:
         parameters = {
@@ -333,7 +305,7 @@ async def time_trip(request: Request) -> Response:
         parameters = {
             "time_list": time_list
         }
-        text = [f"Quý khách lựa chọn thời gian chuyến xe {route_name}\n" + " | ".join(map(str, time_list))]
+        text = [f"Quý khách lựa chọn thời gian chuyến {route_name}\n" + " | ".join(map(str, time_list))]
         payload={
                                 "richContent": [
                                     [
@@ -368,7 +340,7 @@ async def is_valid_select_time(request: Request) -> Response:
                 "is_valid_time": True,
                 "departure_time": raw_input
             }
-            text = [f'{raw_input} | {route_name}']
+            text = [f' Quý khách chọn chuyến {raw_input} | {route_name}']
         else:
             parameters = {
                 "is_valid_time": False
@@ -379,6 +351,40 @@ async def is_valid_select_time(request: Request) -> Response:
         print(e)
         return DialogFlowResponseAPI(text=["Hệ thống xảy ra lỗi. Quý khách vui lòng thử lại sau hoặc liên hệ Trung tâm tổng đài 1900 6067 để được hỗ trợ."])
 
+
+@router.post('/trip/seats')
+async def seats_trip(request: Request) -> Response:
+    try:
+        body = await request.json()
+        session_info = body.get("sessionInfo", {})
+        parameters = session_info.get("parameters")
+        
+        trip_id: int = parameters.get("trip_id", None)
+        route_id: int = parameters.get("route_id", None)
+        departure_date: str = parameters.get("departure_date", None)
+        departure_time: str = parameters.get("departure_time", None)
+        kind: str = parameters.get("kind", None)
+        seats_empty, seats = await dialog_service.seats_trip(route_id, trip_id, departure_date, departure_time, kind)
+        text=["Vui lòng chọn ghế"]
+        payload={
+                                "richContent": [
+                                    [
+                                        {
+                                            "type": "chips",
+                                            "options": [ 
+                                                {"text": seat["chair"]} for seat in (seats_empty)
+                                            ]
+                                        }
+                                    ]
+                                ]
+                            }
+        parameters = {
+            "seats": seats
+        }
+        return DialogFlowResponseAPI(text=text, payload=payload, parameters=parameters)
+    except Exception as e:
+        print(e)
+        return DialogFlowResponseAPI(text=["Hệ thống xảy ra lỗi. Quý khách vui lòng thử lại sau hoặc liên hệ Trung tâm tổng đài 1900 6067 để được hỗ trợ."])
 @router.get("/")
 def home():
     return "Hello World!"

app/dialogflow/services/dialog_service.py

@@ -0,0 +1,57 @@
+from datetime import datetime
+
+from common.external.external_api import api
+
+class DialogService:
+    @staticmethod
+    def to_datetime_from_Dialogflow(time: dict):
+        date_time = datetime(int(time["year"]), int(time["month"]), int(time["day"]))
+        return date_time
+
+    def process_dates_to_timestamp(from_time: datetime = None, to_time: datetime = None):
+        if to_time is None and from_time is not None:
+            to_time = from_time.replace(hour=23, minute=59, second=59)
+        
+        if from_time is None:
+            today = datetime.today().date()
+            from_time = datetime.combine(today, datetime.min.time())
+            to_time = datetime.combine(today, datetime.max.time()) - timedelta(microseconds=1)
+
+        return int(from_time.timestamp()) * 1000 , int(to_time.timestamp()) * 1000
+    def get_param_from_dialogflow(self, body: any):
+        session_info = body.get("sessionInfo", {})
+        parameters = session_info.get("parameters", {}) if isinstance(session_info.get("parameters"), dict) else {}
+        raw_date = parameters.get("date")
+        if raw_date is not None:
+            raw_date = self.to_datetime_from_Dialogflow(raw_date)
+        raw_departure_city = parameters.get("departure_city")
+        raw_destination_city = parameters.get("destination_city")
+        raw_ticket_number = parameters.get("ticket_number")
+        raw_time_of_day = parameters.get("time_of_day")
+        return raw_departure_city, raw_destination_city, raw_ticket_number, raw_date, raw_time_of_day
+
+    async def search_route_ids_from_province(departure_code: str, destination_code: str):
+        response = await api.get(f'/metadata/office/routes?DestCode={destination_code}&OriginCode={departure_code}')
+        route_ids = []
+        if isinstance(response, list):
+                route_ids = [route.get("routeId", -1) for route in response]
+        return route_ids
+
+
+    async def seats_trip(route_id: int, trip_id:int, departure_date: str, departure_time: str, kind: str):
+        try:
+            params = {
+                "departureDate": departure_date,
+                "departureTime": departure_time,
+                "kind": kind,
+            }
+            response = api.get(api_base="https://api-busline-dev.vato.vn/api", endpoint=f"/buslines/futa/booking/seats/{route_id}/{trip_id}" , params=params)
+            seats = response["data"]
+            seats_empty = [ seat for seat in seats if seat["bookStatus"] == 0 ]
+            return seats_empty, seats
+        except Exception as e:
+            print(e)
+            raise Exception("Error fetching seats data")
+        
+dialog_service: DialogService = DialogService()
+    

app/dialogflow/services/origin_codes.py

@@ -0,0 +1,4 @@
+import json
+
+with open("static/files/code_province.json", "r", encoding="utf-8") as file:
+    origin_codes = json.load(file)

app/router.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from fastapi import APIRouter
+
+from app.dialogflow.api.router import v1 as dialogflow_v1
+
+router = APIRouter()
+
+router.include_router(dialogflow_v1)

app/services/api.py

@@ -1,61 +0,0 @@
-import httpx
-from app.core.config import settings
-from typing import Optional, Dict, Any
-
-API_BASE_URL = settings.API_BASE_URL 
-
-async def get(endpoint: str, params: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None):
-    """Gọi API GET"""
-    url = f"{API_BASE_URL}{endpoint}"
-    headers = headers or {}
-    async with httpx.AsyncClient() as client:
-        try:
-            response = await client.get(url, headers=headers, params=params)
-            response.raise_for_status()
-            return response.json()
-        except httpx.HTTPStatusError as http_err:
-            return {"error": f"HTTP {http_err.response.status_code}: {http_err.response.text}"}
-        except Exception as err:
-            return {"error": f"Request failed: {str(err)}"}
-
-async def post(endpoint: str , payload: Dict[str, Any] = None,headers: Optional[Dict[str, str]] = None):
-    """Gọi API POST"""
-    url = f"{API_BASE_URL}{endpoint}"
-    headers = headers or {"Content-Type": "application/json"}
-    async with httpx.AsyncClient() as client:
-        try:
-            response = await client.post(url, json=payload, headers=headers)
-            response.raise_for_status()
-            return response.json()
-        except httpx.HTTPStatusError as http_err:
-            return {"error": f"HTTP {http_err.response.status_code}: {http_err.response.text}"}
-        except Exception as err:
-            return {"error": f"Request failed: {str(err)}"}
-
-async def put_api(endpoint: str, payload: Dict[str, Any], headers: Optional[Dict[str, str]] = None):
-    """Gọi API PUT"""
-    url = f"{API_BASE_URL}{endpoint}"
-    headers = headers or {"Content-Type": "application/json"}
-    async with httpx.AsyncClient() as client:
-        try:
-            response = await client.put(url, json=payload, headers=headers)
-            response.raise_for_status()
-            return response.json()
-        except httpx.HTTPStatusError as http_err:
-            return {"error": f"HTTP {http_err.response.status_code}: {http_err.response.text}"}
-        except Exception as err:
-            return {"error": f"Request failed: {str(err)}"}
-
-async def delete_api(endpoint: str, params: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None):
-    """Gọi API DELETE"""
-    url = f"{API_BASE_URL}{endpoint}"
-    headers = headers or {}
-    async with httpx.AsyncClient() as client:
-        try:
-            response = await client.delete(url, headers=headers, params=params)
-            response.raise_for_status()
-            return response.json()
-        except httpx.HTTPStatusError as http_err:
-            return {"error": f"HTTP {http_err.response.status_code}: {http_err.response.text}"}
-        except Exception as err:
-            return {"error": f"Request failed: {str(err)}"}

app/utils/constants.py

@@ -1,5 +0,0 @@
-import json
-
-# Đọc dữ liệu từ file JSON
-with open("app/utils/code_province.json", "r", encoding="utf-8") as file:
-    code_province = json.load(file)

common/exception/__init__.py

@@ -0,0 +1,2 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-

common/exception/errors.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from typing import Any
+
+from fastapi import HTTPException
+from starlette.background import BackgroundTask
+
+from common.response.response_code import CustomErrorCode, StandardResponseCode
+
+
+class BaseExceptionMixin(Exception):
+
+    code: int
+
+    def __init__(self, *, msg: str = None, data: Any = None, background: BackgroundTask | None = None):
+        self.msg = msg
+        self.data = data
+        # The original background task: https://www.starlette.io/background/
+        self.background = background
+
+
+class HTTPError(HTTPException):
+    """HTTP """
+
+    def __init__(self, *, code: int, msg: Any = None, headers: dict[str, Any] | None = None):
+        super().__init__(status_code=code, detail=msg, headers=headers)
+
+
+class CustomError(BaseExceptionMixin):
+
+    def __init__(self, *, error: CustomErrorCode, data: Any = None, background: BackgroundTask | None = None):
+        self.code = error.code
+        super().__init__(msg=error.msg, data=data, background=background)
+
+
+class RequestError(BaseExceptionMixin):
+    code = StandardResponseCode.HTTP_400
+
+    def __init__(self, *, msg: str = 'Bad Request', data: Any = None, background: BackgroundTask | None = None):
+        super().__init__(msg=msg, data=data, background=background)
+
+
+class ForbiddenError(BaseExceptionMixin):
+
+    code = StandardResponseCode.HTTP_403
+
+    def __init__(self, *, msg: str = 'Forbidden', data: Any = None, background: BackgroundTask | None = None):
+        super().__init__(msg=msg, data=data, background=background)
+
+
+class NotFoundError(BaseExceptionMixin):
+    code = StandardResponseCode.HTTP_404
+
+    def __init__(self, *, msg: str = 'Not Found', data: Any = None, background: BackgroundTask | None = None):
+        super().__init__(msg=msg, data=data, background=background)
+
+
+class ServerError(BaseExceptionMixin):
+
+    code = StandardResponseCode.HTTP_500
+
+    def __init__(
+        self, *, msg: str = 'Internal Server Error', data: Any = None, background: BackgroundTask | None = None
+    ):
+        super().__init__(msg=msg, data=data, background=background)
+
+
+class GatewayError(BaseExceptionMixin):
+
+    code = StandardResponseCode.HTTP_502
+
+    def __init__(self, *, msg: str = 'Bad Gateway', data: Any = None, background: BackgroundTask | None = None):
+        super().__init__(msg=msg, data=data, background=background)
+
+
+class AuthorizationError(BaseExceptionMixin):
+
+    code = StandardResponseCode.HTTP_401
+
+    def __init__(self, *, msg: str = 'Permission Denied', data: Any = None, background: BackgroundTask | None = None):
+        super().__init__(msg=msg, data=data, background=background)
+
+
+class TokenError(HTTPError):
+
+    code = StandardResponseCode.HTTP_401
+
+    def __init__(self, *, msg: str = 'Not Authenticated', headers: dict[str, Any] | None = None):
+        super().__init__(code=self.code, msg=msg, headers=headers or {'WWW-Authenticate': 'Bearer'})

common/exception/exception_handler.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from fastapi import FastAPI, Request
+from fastapi.exceptions import RequestValidationError
+from pydantic import ValidationError
+from starlette.exceptions import HTTPException
+from starlette.middleware.cors import CORSMiddleware
+from uvicorn.protocols.http.h11_impl import STATUS_PHRASES
+
+from common.exception.errors import BaseExceptionMixin
+from common.response.response_code import CustomResponseCode, StandardResponseCode
+from common.response.response_schema import response_base
+from common.schema import (
+    CUSTOM_VALIDATION_ERROR_MESSAGES,
+)
+from core.conf import settings
+from utils.serializers import MsgSpecJSONResponse
+from utils.trace_id import get_request_trace_id
+
+
+def _get_exception_code(status_code: int) -> int:
+    try:
+        STATUS_PHRASES[status_code]
+        return status_code
+    except Exception:
+        return StandardResponseCode.HTTP_400
+
+
+async def _validation_exception_handler(request: Request, exc: RequestValidationError | ValidationError):
+    errors = []
+    for error in exc.errors():
+        custom_message = CUSTOM_VALIDATION_ERROR_MESSAGES.get(error['type'])
+        if custom_message:
+            ctx = error.get('ctx')
+            if not ctx:
+                error['msg'] = custom_message
+            else:
+                error['msg'] = custom_message.format(**ctx)
+                ctx_error = ctx.get('error')
+                if ctx_error:
+                    error['ctx']['error'] = (
+                        ctx_error.__str__().replace("'", '"') if isinstance(ctx_error, Exception) else None
+                    )
+        errors.append(error)
+    error = errors[0]
+    if error.get('type') == 'json_invalid':
+        message = 'json解析失败'
+    else:
+        error_input = error.get('input')
+        field = str(error.get('loc')[-1])
+        error_msg = error.get('msg')
+        message = f'{field} {error_msg}，输入：{error_input}' if settings.ENVIRONMENT == 'dev' else error_msg
+    msg = f'请求参数非法: {message}'
+    data = {'errors': errors} if settings.ENVIRONMENT == 'dev' else None
+    content = {
+        'code': StandardResponseCode.HTTP_422,
+        'msg': msg,
+        'data': data,
+    }
+    request.state.__request_validation_exception__ = content
+    content.update(trace_id=get_request_trace_id(request))
+    return MsgSpecJSONResponse(status_code=422, content=content)
+
+
+def register_exception(app: FastAPI):
+    @app.exception_handler(HTTPException)
+    async def http_exception_handler(request: Request, exc: HTTPException):
+        if settings.ENVIRONMENT == 'dev':
+            content = {
+                'code': exc.status_code,
+                'msg': exc.detail,
+                'data': None,
+            }
+        else:
+            res = response_base.fail(res=CustomResponseCode.HTTP_400)
+            content = res.model_dump()
+        request.state.__request_http_exception__ = content
+        content.update(trace_id=get_request_trace_id(request))
+        return MsgSpecJSONResponse(
+            status_code=_get_exception_code(exc.status_code),
+            content=content,
+            headers=exc.headers,
+        )
+
+    @app.exception_handler(RequestValidationError)
+    async def fastapi_validation_exception_handler(request: Request, exc: RequestValidationError):
+        return await _validation_exception_handler(request, exc)
+
+    @app.exception_handler(ValidationError)
+    async def pydantic_validation_exception_handler(request: Request, exc: ValidationError):
+        return await _validation_exception_handler(request, exc)
+
+    @app.exception_handler(AssertionError)
+    async def assertion_error_handler(request: Request, exc: AssertionError):
+        if settings.ENVIRONMENT == 'dev':
+            content = {
+                'code': StandardResponseCode.HTTP_500,
+                'msg': str(''.join(exc.args) if exc.args else exc.__doc__),
+                'data': None,
+            }
+        else:
+            res = response_base.fail(res=CustomResponseCode.HTTP_500)
+            content = res.model_dump()
+        request.state.__request_assertion_error__ = content
+        content.update(trace_id=get_request_trace_id(request))
+        return MsgSpecJSONResponse(
+            status_code=StandardResponseCode.HTTP_500,
+            content=content,
+        )
+
+    @app.exception_handler(BaseExceptionMixin)
+    async def custom_exception_handler(request: Request, exc: BaseExceptionMixin):
+        content = {
+            'code': exc.code,
+            'msg': str(exc.msg),
+            'data': exc.data if exc.data else None,
+        }
+        request.state.__request_custom_exception__ = content
+        content.update(trace_id=get_request_trace_id(request))
+        return MsgSpecJSONResponse(
+            status_code=_get_exception_code(exc.code),
+            content=content,
+            background=exc.background,
+        )
+
+    @app.exception_handler(Exception)
+    async def all_unknown_exception_handler(request: Request, exc: Exception):
+        if settings.ENVIRONMENT == 'dev':
+            content = {
+                'code': StandardResponseCode.HTTP_500,
+                'msg': str(exc),
+                'data': None,
+            }
+        else:
+            res = response_base.fail(res=CustomResponseCode.HTTP_500)
+            content = res.model_dump()
+        request.state.__request_all_unknown_exception__ = content
+        content.update(trace_id=get_request_trace_id(request))
+        return MsgSpecJSONResponse(
+            status_code=StandardResponseCode.HTTP_500,
+            content=content,
+        )
+
+    if settings.MIDDLEWARE_CORS:
+
+        @app.exception_handler(StandardResponseCode.HTTP_500)
+        async def cors_custom_code_500_exception_handler(request, exc):
+            """
+            500 
+
+            `Related issue <https://github.com/encode/starlette/issues/1175>`_
+
+            `Solution <https://github.com/fastapi/fastapi/discussions/7847#discussioncomment-5144709>`_
+
+            :param request: FastAPI
+            :param exc:
+            :return:
+            """
+            if isinstance(exc, BaseExceptionMixin):
+                content = {
+                    'code': exc.code,
+                    'msg': exc.msg,
+                    'data': exc.data,
+                }
+            else:
+                if settings.ENVIRONMENT == 'dev':
+                    content = {
+                        'code': StandardResponseCode.HTTP_500,
+                        'msg': str(exc),
+                        'data': None,
+                    }
+                else:
+                    res = response_base.fail(res=CustomResponseCode.HTTP_500)
+                    content = res.model_dump()
+            request.state.__request_cors_500_exception__ = content
+            content.update(trace_id=get_request_trace_id(request))
+            response = MsgSpecJSONResponse(
+                status_code=exc.code if isinstance(exc, BaseExceptionMixin) else StandardResponseCode.HTTP_500,
+                content=content,
+                background=exc.background if isinstance(exc, BaseExceptionMixin) else None,
+            )
+            origin = request.headers.get('origin')
+            if origin:
+                cors = CORSMiddleware(
+                    app=app,
+                    allow_origins=settings.CORS_ALLOWED_ORIGINS,
+                    allow_credentials=True,
+                    allow_methods=['*'],
+                    allow_headers=['*'],
+                    expose_headers=settings.CORS_EXPOSE_HEADERS,
+                )
+                response.headers.update(cors.simple_headers)
+                has_cookie = 'cookie' in request.headers
+                if cors.allow_all_origins and has_cookie:
+                    response.headers['Access-Control-Allow-Origin'] = origin
+                elif not cors.allow_all_origins and cors.is_allowed_origin(origin=origin):
+                    response.headers['Access-Control-Allow-Origin'] = origin
+                    response.headers.add_vary_header('Origin')
+            return response

common/external/external_api.py

@@ -0,0 +1,83 @@
+import httpx
+from core.conf import settings
+from typing import Optional, Dict, Any
+from core.token_manager import get_access_token
+
+API_BASE_URL = settings.API_BASE_URL
+
+class API():
+    @staticmethod
+    async def get(endpoint: str, params: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None, api_base: str = None):
+        if api_base:
+            url = f"{api_base}{endpoint}"
+        else:
+            url = f"{API_BASE_URL}{endpoint}"
+        access_token = get_access_token()
+        headers = headers or {}
+        headers.setdefault("Content-Type", "application/json")
+        headers["Authorization"] = f"Bearer {access_token}"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(url, headers=headers, params=params)
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPStatusError as http_err:
+                return {"error": f"HTTP {http_err.response.status_code}: {http_err.response.text}"}
+            except Exception as err:
+                return {"error": f"Request failed: {str(err)}"}
+
+    @staticmethod
+    async def post(endpoint: str , payload: Dict[str, Any] = None,headers: Optional[Dict[str, str]] = None, api_base: str = None):
+        if api_base:
+            url = f"{api_base}{endpoint}"
+        else:
+            url = f"{API_BASE_URL}{endpoint}"
+        access_token = get_access_token()
+        headers = headers or {}
+        headers.setdefault("Content-Type", "application/json")
+        headers["Authorization"] = f"Bearer {access_token}"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(url, json=payload, headers=headers)
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPStatusError as http_err:
+                return {"error": f"HTTP {http_err.response.status_code}: {http_err.response.text}"}
+            except Exception as err:
+                return {"error": f"Request failed: {str(err)}"}
+
+    @staticmethod
+    async def put_api(endpoint: str, payload: Dict[str, Any], headers: Optional[Dict[str, str]] = None):
+        url = f"{API_BASE_URL}{endpoint}"
+        access_token = get_access_token()
+        headers = headers or {}
+        headers.setdefault("Content-Type", "application/json")
+        headers["Authorization"] = f"Bearer {access_token}"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.put(url, json=payload, headers=headers)
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPStatusError as http_err:
+                return {"error": f"HTTP {http_err.response.status_code}: {http_err.response.text}"}
+            except Exception as err:
+                return {"error": f"Request failed: {str(err)}"}
+
+    @staticmethod
+    async def delete_api(endpoint: str, params: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None):
+        url = f"{API_BASE_URL}{endpoint}"
+        access_token = get_access_token()
+        headers = headers or {}
+        headers.setdefault("Content-Type", "application/json")
+        headers["Authorization"] = f"Bearer {access_token}"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.delete(url, headers=headers, params=params)
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPStatusError as http_err:
+                return {"error": f"HTTP {http_err.response.status_code}: {http_err.response.text}"}
+            except Exception as err:
+                return {"error": f"Request failed: {str(err)}"}
+
+api: API = API()

common/log.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import inspect
+import logging
+import os
+import sys
+
+from asgi_correlation_id import correlation_id
+from loguru import logger
+
+from core import path_conf
+from core.conf import settings
+
+
+class InterceptHandler(logging.Handler):
+    def emit(self, record: logging.LogRecord):
+        # 获取对应的 Loguru 级别（如果存在）
+        try:
+            level = logger.level(record.levelname).name
+        except ValueError:
+            level = record.levelno
+
+        # 查找记录日志消息的调用者
+        frame, depth = inspect.currentframe(), 0
+        while frame and (depth == 0 or frame.f_code.co_filename == logging.__file__):
+            frame = frame.f_back
+            depth += 1
+
+        logger.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())
+
+
+def setup_logging() -> None:
+    """
+    - https://github.com/benoitc/gunicorn/issues/1572#issuecomment-638391953
+    - https://github.com/pawamoy/pawamoy.github.io/issues/17
+    """
+    logging.root.handlers = [InterceptHandler()]
+    logging.root.setLevel(settings.LOG_STD_LEVEL)
+
+    for name in logging.root.manager.loggerDict.keys():
+        logging.getLogger(name).handlers = []
+        if 'uvicorn.access' in name or 'watchfiles.main' in name:
+            logging.getLogger(name).propagate = False
+        else:
+            logging.getLogger(name).propagate = True
+
+        # Debug log handlers
+        # logging.debug(f'{logging.getLogger(name)}, {logging.getLogger(name).propagate}')
+
+    # https://github.com/snok/asgi-correlation-id/issues/7
+    def correlation_id_filter(record):
+        cid = correlation_id.get(settings.LOG_CID_DEFAULT_VALUE)
+        record['correlation_id'] = cid[: settings.LOG_CID_UUID_LENGTH]
+        return record
+
+    # 配置 loguru 处理器
+    logger.remove()  # 移除默认处理器
+    logger.configure(
+        handlers=[
+            {
+                'sink': sys.stdout,
+                'level': settings.LOG_STD_LEVEL,
+                'filter': lambda record: correlation_id_filter(record),
+                'format': settings.LOG_STD_FORMAT,
+            }
+        ]
+    )
+
+
+def set_custom_logfile() -> None:
+    log_path = path_conf.LOG_DIR
+    if not os.path.exists(log_path):
+        os.mkdir(log_path)
+
+    log_access_file = os.path.join(log_path, settings.LOG_ACCESS_FILENAME)
+    log_error_file = os.path.join(log_path, settings.LOG_ERROR_FILENAME)
+
+    # https://loguru.readthedocs.io/en/stable/api/logger.html#loguru._logger.Logger.add
+    log_config = {
+        'format': settings.LOG_FILE_FORMAT,
+        'enqueue': True,
+        'rotation': '5 MB',
+        'retention': '7 days',
+        'compression': 'tar.gz',
+    }
+
+    logger.add(
+        str(log_access_file),
+        level=settings.LOG_ACCESS_FILE_LEVEL,
+        filter=lambda record: record['level'].no <= 25,
+        backtrace=False,
+        diagnose=False,
+        **log_config,
+    )
+
+    logger.add(
+        str(log_error_file),
+        level=settings.LOG_ERROR_FILE_LEVEL,
+        filter=lambda record: record['level'].no >= 30,
+        backtrace=True,
+        diagnose=True,
+        **log_config,
+    )
+
+
+log = logger