decoded = jwt.decode(token, public_key, algorithms=[alg], audience=aud, issuer=issuer)

@router.post("/users/login", status_code=status.HTTP_200_OK)
def login(
        user: UserLogin,
        response: Response,
        session: Session = Depends(get_db)
):
    rec = UserService(session).authenticate_user(user=user)
    if not rec:
        raise HTTPException(status_code=404, detail="User does NOT exist in the system")
    rec = jsonable_encoder(rec)
    subject = {
        'username': rec.get('username'),
        'role': rec.get('role'),
        'departments': rec.get('departments')
    }

    access_token = access_security.create_access_token(subject=subject, expires_delta=timedelta(minutes=1))
    refresh_token = refresh_security.create_refresh_token(subject=subject, expires_delta=timedelta(minutes=2))

    access_security.set_access_cookie(response=response, access_token=access_token)
    refresh_security.set_refresh_cookie(response=response, refresh_token=refresh_token)

    return {'user': rec, 'access_token': access_token, 'refresh_token': refresh_token}

@lru_cache
def get_access_security() -> JwtAccessBearerCookie:
    """Return an JWT access security object to generate and test access tokens.

    Returns:
        JwtAccessBearerCookie: The access security.
    """
    return JwtAccessBearerCookie(
        secret_key=settings.secret_key,
        auto_error=True,
        access_expires_delta=settings.access_expires_delta,
    )

AccessSecurityDependency = Annotated[
    JwtAuthorizationCredentials,
    Depends(get_access_security()),
]

 @router.patch(
        "/api/calibration-order/id/{id}",
        response_model=CalibrationOrder,
        response_model_exclude_unset=True,
    )
    async def update_calibration_order_by_id(
        id: str,
        patch: list[dict],
        credentials: AccessSecurityDependency,
    ) -> CalibrationOrder:

@pytest.fixture()
def client_authenticated() -> Generator[TestClient, Any, None]:
    """
    Pytest fixture that yields an instance of TestClient which skips the authentication.

    Yields:
        Generator[TestClient, Any, None]: An instance of the TestClient.
    """

    def get_access_security_override() -> None:
        return None

    app.dependency_overrides[
        Depends(get_access_security())
    ] = get_access_security_override
    with TestClient(app) as c:
        yield c

@router.post(
    "/refresh",
)
async def refresh_token(
    response: Response,
    credentials: JwtAuthorizationCredentials = Security(refresh_security),
    db: Session = Depends(get_db),
):
    logger.info("Request: Refresh -> New Request to refresh JWT token.")

    user = get_user_by_id(db, credentials["id"])

    logger.info("Request: Refresh -> Returning new credentials.")

    set_authentication_cookies(response, user)

    return {
        "user": user,
        "detail": "Token refreshed successfully!"
    }

# 使用python-jose来生成jwt,验证jwt,获取当前用户的方法

# 生成token
# def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
import os
from datetime import datetime, timedelta

from fastapi_jwt import JwtRefreshBearer, JwtAuthorizationCredentials, JwtAccessBearer

from fastapi import Security, HTTPException
from dotenv import load_dotenv

load_dotenv()
secret_key = os.getenv("SECRET_KEY", 'leees')

access_token_expires = int(os.getenv("JWT_EXPIRE_TIME", 7))
refresh_token_expires = int(os.getenv("JWT_REFRESH_TIME", 30))


access_security = JwtAccessBearer(
    secret_key=secret_key,
    auto_error=True,
    # change access token validation timedelta
    access_expires_delta=timedelta(days=access_token_expires)
)


# Read refresh token from bearer header only
refresh_security = JwtRefreshBearer(
    secret_key=secret_key,
    auto_error=True,  # automatically raise HTTPException: HTTP_401_UNAUTHORIZED
    refresh_expires_delta=timedelta(days=refresh_token_expires)
)


def create_token(data: dict):
    return access_security.create_access_token(subject=data)


def create_refresh_token(data: dict):
    return refresh_security.create_refresh_token(subject=data)

# 创建同时返回access_token和refresh_token的方法


def create_tokens_refresh(data: dict):
    access_token = access_security.create_access_token(subject=data)
    refresh_token = refresh_security.create_refresh_token(subject=data)
    return {"access_token": access_token, "refresh_token": refresh_token}

# 刷新token


def refresh(
        credentials: JwtAuthorizationCredentials = Security(refresh_security)
):
    # Update access/refresh tokens pair
    # We can customize expires_delta when creating
    access_token = access_security.create_access_token(
        subject=credentials.subject)
    refresh_token = refresh_security.create_refresh_token(
        subject=credentials.subject, expires_delta=timedelta(days=2))

    return {"access_token": access_token, "refresh_token": refresh_token}


def get_current_user(
        credentials: JwtAuthorizationCredentials = Security(access_security)
):

    # auto_error=False, fo we should check manually

    if not credentials:
        raise HTTPException(status_code=401, detail='error')

    # now we can access Credentials object
    return credentials.subject