def fastapi_users(request, mock_user_db, mock_authentication,
oauth_client) -> FastAPIUsers:
fastapi_users = FastAPIUsers(
mock_user_db,
[mock_authentication],
User,
UserCreate,
UserUpdate,
UserDB,
"SECRET",
)
fastapi_users.get_oauth_router(oauth_client, "SECRET")
@fastapi_users.on_after_register()
def on_after_register():
return request.param()
@fastapi_users.on_after_forgot_password()
def on_after_forgot_password():
return request.param()
@fastapi_users.on_after_update()
def on_after_update():
return request.param()
return fastapi_users
def get_users_router(db):
users_collection = db["users"]
user_db = MongoDBUserDatabase(UserDB, users_collection)
fastapi_users = FastAPIUsers(
user_db,
[jwt_authentication],
User,
UserCreate,
UserUpdate,
UserDB,
)
users_router = APIRouter()
users_router.include_router(
fastapi_users.get_auth_router(jwt_authentication),
prefix="/auth/jwt",
tags=["auth"],
)
users_router.include_router(fastapi_users.get_register_router(),
prefix="/auth",
tags=["auth"])
users_router.include_router(
fastapi_users.get_reset_password_router(settings.JWT_SECRET_KEY),
prefix="/auth",
tags=["auth"],
)
users_router.include_router(fastapi_users.get_users_router(),
prefix="/users",
tags=["users"])
return users_router
def test_get_oauth_router(mocker, fastapi_users: FastAPIUsers, oauth_client: OAuth2):
# Check that existing OAuth router declared
# before the handlers decorators is correctly binded
existing_oauth_router = fastapi_users.oauth_routers[0]
event_handlers = existing_oauth_router.event_handlers
assert len(event_handlers[Event.ON_AFTER_REGISTER]) == 1
assert len(event_handlers[Event.ON_AFTER_FORGOT_PASSWORD]) == 1
# Check that OAuth router declared
# after the handlers decorators is correctly binded
oauth_router = fastapi_users.get_oauth_router(oauth_client, "SECRET")
assert isinstance(oauth_router, EventHandlersRouter)
event_handlers = oauth_router.event_handlers
assert len(event_handlers[Event.ON_AFTER_REGISTER]) == 1
assert len(event_handlers[Event.ON_AFTER_FORGOT_PASSWORD]) == 1
def fastapi_users(request, mock_user_db, mock_authentication) -> FastAPIUsers:
class User(BaseUser):
pass
fastapi_users = FastAPIUsers(mock_user_db, mock_authentication, User,
"SECRET")
@fastapi_users.on_after_register()
def on_after_register():
return request.param()
@fastapi_users.on_after_forgot_password()
def on_after_forgot_password():
return request.param()
return fastapi_users
async def test_app_client(
mock_user_db, mock_authentication, oauth_client,
get_test_client) -> AsyncGenerator[httpx.AsyncClient, None]:
fastapi_users = FastAPIUsers(
mock_user_db,
[mock_authentication],
User,
UserCreate,
UserUpdate,
UserDB,
)
app = FastAPI()
app.include_router(fastapi_users.get_register_router())
app.include_router(fastapi_users.get_reset_password_router("SECRET"))
app.include_router(fastapi_users.get_auth_router(mock_authentication))
app.include_router(fastapi_users.get_oauth_router(oauth_client, "SECRET"))
app.include_router(fastapi_users.get_users_router(), prefix="/users")
@app.get("/current-user")
def current_user(user=Depends(fastapi_users.get_current_user)):
return user
@app.get("/current-active-user")
def current_active_user(user=Depends(
fastapi_users.get_current_active_user)):
return user
@app.get("/current-superuser")
def current_superuser(user=Depends(fastapi_users.get_current_superuser)):
return user
@app.get("/optional-current-user")
def optional_current_user(user=Depends(
fastapi_users.get_optional_current_user)):
return user
@app.get("/optional-current-active-user")
def optional_current_active_user(
user=Depends(fastapi_users.get_optional_current_active_user), ):
return user
@app.get("/optional-current-superuser")
def optional_current_superuser(
user=Depends(fastapi_users.get_optional_current_superuser), ):
return user
async for client in get_test_client(app):
yield client
async def configure_db_and_routes():
app.mongodb_client = AsyncIOMotorClient(settings.DB_URL,
uuidRepresentation="standard")
app.db = app.mongodb_client.get_default_database()
user_db = MongoDBUserDatabase(UserDB, app.db["users"])
app.fastapi_users = FastAPIUsers(
user_db,
[jwt_authentication],
User,
UserCreate,
UserUpdate,
UserDB,
)
app.include_router(get_users_router(app))
app.include_router(get_todo_router(app))
async def startup():
await db.connect_to_database(path=DATABASE_URL)
disc_db = db.client[DATABASE_NAME]
global fs
fs = AsyncIOMotorGridFSBucket(disc_db)
global song_db
song_db = disc_db.get_collection(SONGS_DB)
global mix_db
mix_db = disc_db.get_collection(MIX_DB)
user_col = disc_db[USER_DB]
global user_db
user_db = MongoDBUserDatabase(UserDB, user_col)
global fastapi_users
fastapi_users = FastAPIUsers(user_db, [jwt_authentication], User,
UserCreate, UserUpdate, UserDB)
app.include_router(fastapi_users.get_auth_router(jwt_authentication),
prefix="/auth/jwt",
tags=["auth"])
app.include_router(
fastapi_users.get_register_router(after_register=on_after_register),
prefix="/auth",
tags=["auth"])
app.include_router(
fastapi_users.get_reset_password_router(
SECRET, after_forgot_password=on_after_forgot_password),
prefix="/auth",
tags=["auth"],
)
app.include_router(
fastapi_users.get_verify_router(
SECRET, after_verification_request=after_verification_request),
prefix="/auth",
tags=["auth"],
)
app.include_router(fastapi_users.get_users_router(),
prefix="/users",
tags=["users"])
from fastapi_jwt_auth.exceptions import AuthJWTException
from fastapi_jwt_auth import AuthJWT
from fastapi_users.router.common import ErrorCode
from fastapi_users.authentication import JWTAuthentication
from fastapi_users import FastAPIUsers
from app.app_app import app
from app.mail import send_mail
from app.google_analytics import ga
import common.models as M
jwt_authentication = JWTAuthentication(secret=SECRET, lifetime_seconds=60 * 5)
fastapi_users = FastAPIUsers(
M.user_db,
[jwt_authentication],
M.FU_User,
M.FU_UserCreate,
M.FU_UserUpdate,
M.FU_UserDB,
)
def on_after_register(user: M.FU_UserDB, request: Request):
ga(user.id, 'user', 'register')
with db():
t = M.Tag(user_id=user.id, main=True, selected=True, name='Main')
db.session.add(t)
db.session.commit()
send_mail(user.email, "welcome", {})
def on_after_forgot_password(user: M.FU_UserDB, token: str, request: Request):
from fastapi import Depends, Response
from fastapi_users import FastAPIUsers
from fastapi_users.authentication import JWTAuthentication
from ..config import settings
from .models import user_db, User, UserCreate, UserUpdate, UserDB
jwt_authentication = JWTAuthentication(secret=settings.jwt_secret, lifetime_seconds=3600, tokenUrl="/auth/login")
accounts = FastAPIUsers(
db=user_db,
auth_backends=[jwt_authentication],
user_model=User,
user_create_model=UserCreate,
user_update_model=UserUpdate,
user_db_model=UserDB,
)
authrouter = accounts.get_auth_router(jwt_authentication)
authresetpasswordrouter = accounts.get_reset_password_router(reset_password_token_secret=settings.reset_password_secret)
registerrouter = accounts.get_register_router()
usersrouter = accounts.get_users_router()
@authrouter.post("/refresh-token")
async def refresh_token(response: Response, user=Depends(accounts.get_current_active_user)):
return await jwt_authentication.get_login_response(user, response)
import types
from fastapi_users import FastAPIUsers
from config.jwt import jwt_authentication
from db.init import user_db
from db.schema import User, UserDB, UserUpdate, UserCreate
from routers.v1.auth import get_refresh_token_router, get_verify_account_router
fastapi_users = FastAPIUsers(
user_db,
[jwt_authentication],
User,
UserCreate,
UserUpdate,
UserDB,
)
fastapi_users.get_refresh_token = types.MethodType(get_refresh_token_router,
fastapi_users)
fastapi_users.get_verify_account = types.MethodType(get_verify_account_router,
fastapi_users)
def after_verification_request(user: UserDB, token: str, request: Request):
print(
f"Verification requested for user {user.id}. Verification token: {token}"
)
jwt_authentication = JWTAuthentication(secret=SECRET,
lifetime_seconds=3600,
tokenUrl="auth/jwt/login")
app = FastAPI()
fastapi_users = FastAPIUsers(
user_db,
[jwt_authentication],
User,
UserCreate,
UserUpdate,
UserDB,
)
app.include_router(fastapi_users.get_auth_router(jwt_authentication),
prefix="/auth/jwt",
tags=["auth"])
app.include_router(fastapi_users.get_register_router(on_after_register),
prefix="/auth",
tags=["auth"])
app.include_router(
fastapi_users.get_reset_password_router(
SECRET, after_forgot_password=on_after_forgot_password),
prefix="/auth",
tags=["auth"],
)
from app.app_app import app
from common.utils import vars, SECRET
from app.mail import send_mail
from fastapi import Depends, Response, Request, BackgroundTasks
from fastapi_sqlalchemy import db # an object to provide global access to a database session
from fastapi_users.authentication import JWTAuthentication
from fastapi_users import FastAPIUsers
import common.models as M
from app.google_analytics import ga
jwt_lifetime = 60 * 60 * 24 * 7 # 1wk. TODO implement token refresh
jwt_authentication = JWTAuthentication(secret=SECRET, lifetime_seconds=jwt_lifetime)
fastapi_users = FastAPIUsers(
M.user_db, [jwt_authentication], M.FU_User, M.FU_UserCreate, M.FU_UserUpdate, M.FU_UserDB,
)
@app.post("/auth/jwt/refresh")
async def refresh_jwt(response: Response, user=Depends(fastapi_users.get_current_user)):
return await jwt_authentication.get_login_response(user, response)
def on_after_register(user: M.FU_UserDB, request: Request):
ga(user.id, 'user', 'register')
with db():
t = M.Tag(user_id=user.id, main=True, selected=True, name='Main')
db.session.add(t)
db.session.commit()
send_mail(user.email, "welcome", {})
def on_after_forgot_password(user: M.FU_UserDB, token: str, request: Request):
from fastapi_users.authentication import JWTAuthentication
from fastapi_users.db import SQLAlchemyUserDatabase
from fastapi_users import FastAPIUsers
from schemas.user_schema import UserDB, User, UserCreate, UserUpdate
from db import database
from models.users import users
user_db = SQLAlchemyUserDatabase(UserDB, database, users)
SECRET = "djfdjdd9s93jd00fh38d83r32dbcs8s9a02b3jd0s"
auth_backends = []
jwt_authentication = JWTAuthentication(secret=SECRET, lifetime_seconds=3600)
auth_backends.append(jwt_authentication)
fastapi_users = FastAPIUsers(
user_db,
[jwt_authentication],
User,
UserCreate,
UserUpdate,
UserDB,
)
print(f"User {user.id} has registered.")
def on_after_forgot_password(user: UserDB, token: str, request: Request):
print(f"User {user.id} has forgot their password. Reset token: {token}")
jwt_authentication = JWTAuthentication(secret=SECRET,
lifetime_seconds=3600,
tokenUrl="/auth/jwt/login")
app = FastAPI()
fastapi_users = FastAPIUsers(
user_db,
[jwt_authentication],
User,
UserCreate,
UserUpdate,
UserDB,
)
app.include_router(fastapi_users.get_auth_router(jwt_authentication),
prefix="/auth/jwt",
tags=["auth"])
app.include_router(fastapi_users.get_register_router(on_after_register),
prefix="/auth",
tags=["auth"])
app.include_router(
fastapi_users.get_reset_password_router(
SECRET, after_forgot_password=on_after_forgot_password),
prefix="/auth",
tags=["auth"],
)
app.add_middleware(
CORSMiddleware,
allow_origins=origins,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
SECRET = "VERYBIGSECRET"
jwt_authentication = JWTAuthentication(secret=SECRET, lifetime_seconds=3600)
fastapi_users = FastAPIUsers(
user_db,
[jwt_authentication],
User,
UserCreate,
UserUpdate,
UserDB,
)
db = Database(
"quiz"
) # TODO: Rewrite to https://fastapi.tiangolo.com/tutorial/sql-databases
@app.get("/", description="Check if site working", tags=['dev'])
def test():
return {"status": "Hello, slvt!"}
@app.get("/hard_reset", description="Drop full database", tags=['dev'])
Define API endpoints for the users resource.
Most of it has been included by the fastapi_users package.
"""
from fastapi_users import FastAPIUsers
from fastapi import Request
from typing import Dict, Any
from backend.server.models.user_models import User, UserCreate, UserUpdate, UserDB
from backend.server.auth import auth_backends
from backend.server.database import user_db
fastapi_users = FastAPIUsers(
user_db,
auth_backends,
User,
UserCreate,
UserUpdate,
UserDB,
)
def on_after_register(user: UserDB, request: Request):
print(f"User {user.id} has registered.")
def on_after_update(user: UserDB, updated_user_data: Dict[str, Any],
request: Request):
print(
f"User {user.id} has been updated with the following data: {updated_user_data}"
)
auth_backends = []
authentication = JWTAuthentication(secret=SECRET, lifetime_seconds=3600)
auth_backends.append(authentication)
# --- FastAPIUsers Object Declaration -----------------------------------------
# MongoDB "users" collection adaptor for API calls
user_db = MongoDBUserDatabase(UserDB, collection)
# FastAPI Users helper class with all the configurations from above
# It provides us all the routes
fastapi_users = FastAPIUsers(
user_db,
auth_backends,
User,
UserCreate,
UserUpdate,
UserDB
)
# --- FastAPI Server Initialization -------------------------------------------
# Learn more https://frankie567.github.io/fastapi-users/configuration/routers/
# Initiating FastAPI Server
app = FastAPI()
# Managing CORS for the React Frontend connections
from fastapi.middleware.cors import CORSMiddleware
origins = [
from fastapi_users.authentication import JWTAuthentication
from fastapi_users import FastAPIUsers
from .models import user_db
from .schemas import User, UserDB, UserCreate, UserUpdate
SECRET = "BHIVGIVBKLJBytspfpuh1438a7089;ASAEPIUHAGH312839ASFNsdfgsdg"
auth_backends = []
jwt_authentication = JWTAuthentication(secret=SECRET,
lifetime_seconds=3600,
tokenUrl="/auth/jwt/login")
auth_backends.append(jwt_authentication)
fastapi_users = FastAPIUsers(user_db, auth_backends, User, UserCreate,
UserUpdate, UserDB)
current_active_user = fastapi_users.current_user(active=True)
print(f"User {user.id} has forgot their password. Reset token: {token}")
def after_verification_request(user: UserDB, token: str, request: Request):
print(
f"Verification requested for user {user.id}. Verification token: {token}"
)
cookie_authentication = CookieAuthentication(secret=SECRET,
cookie_secure=not IS_DEVELOPMENT)
fastapi_users = FastAPIUsers(
user_db,
[cookie_authentication],
User,
UserCreate,
UserUpdate,
UserDB,
)
app.include_router(fastapi_users.get_auth_router(cookie_authentication),
prefix="/auth/cookie",
tags=["auth"])
"""
app.include_router(
fastapi_users.get_register_router(on_after_register), prefix="/auth", tags=["auth"]
)
"""
app.include_router(
fastapi_users.get_reset_password_router(
SECRET, after_forgot_password=on_after_forgot_password),
prefix="/auth",
from .schemas.experience import ExperienceDB
from .schemas.language import Language as LanguageSchema
from .schemas.language import LanguageDB
from .schemas.user import User, UserCreate, UserDB, UserUpdate
APP_SECRET = os.getenv("APP_SECRET")
jwt_authentication = JWTAuthentication(secret=APP_SECRET,
lifetime_seconds=3600,
tokenUrl="/auth/jwt/login")
app = FastAPI()
fastapi_users = FastAPIUsers(
user_db,
[jwt_authentication],
User,
UserCreate,
UserUpdate,
UserDB,
)
app.include_router(fastapi_users.get_auth_router(jwt_authentication),
prefix="/auth/jwt",
tags=["auth"])
app.include_router(fastapi_users.get_register_router(),
prefix="/auth",
tags=["auth"])
app.include_router(fastapi_users.get_reset_password_router(APP_SECRET),
prefix="/auth",
tags=["auth"])
app.include_router(fastapi_users.get_verify_router(APP_SECRET),
prefix="/auth",
tags=["auth"])
from motor.motor_asyncio import AsyncIOMotorClient
from uuid import UUID, uuid4
from server.models.users import *
from server.config import *
from server.database import get_database
client = AsyncIOMotorClient(MONGO_ENDPOINT, uuidRepresentation="standard")
db = client[DB_NAME]
collection = db["users"]
user_db = MongoDBUserDatabase(UserDB, collection)
fastapi_users = FastAPIUsers(
user_db,
AUTH_BACKENDS,
User,
UserCreate,
UserUpdate,
UserDB,
)
router = APIRouter()
@router.post("/{id}/deactivate", response_model=User, status_code=HTTP_200_OK)
async def deactivate_user(
id,
db: AsyncIOMotorClient = Depends(get_database),
user: User = Depends(fastapi_users.get_current_user),
):
if user.heir_id != '':
assets = db["assets"].find({"user_id": str(user.id)})
Base.metadata.create_all(engine)
users = UserTable.__table__
oauth_accounts = OAuthAccount.__table__
user_db = SQLAlchemyUserDatabase(UserDB, database, users, oauth_accounts)
auth_backends = [
JWTAuthentication(secret=SECRET, lifetime_seconds=3600),
]
app = FastAPI()
fastapi_users = FastAPIUsers(
user_db,
auth_backends,
User,
UserCreate,
UserUpdate,
UserDB,
SECRET,
)
app.include_router(fastapi_users.router, prefix="/users", tags=["users"])
google_oauth_router = fastapi_users.get_oauth_router(google_oauth_client,
SECRET)
app.include_router(google_oauth_router, prefix="/google-oauth", tags=["users"])
@fastapi_users.on_after_register()
def on_after_register(user: User):
print(f"User {user.id} has registered.")
engine = sqlalchemy.create_engine(DATABASE_URL,
connect_args={"check_same_thread": False})
Base.metadata.create_all(engine)
users = UserTable.__table__
user_db = SQLAlchemyUserDatabase(UserDB, database, users)
app = FastAPI()
fastapi_users = FastAPIUsers(
user_db,
auth_backends,
User,
UserCreate,
UserUpdate,
UserDB,
)
async def fake_get_active_user():
DISABLE_AUTH = settings.DISABLE_AUTH
if DISABLE_AUTH == "True":
return True
else:
await fastapi_users.get_current_active_user()
if settings.DISABLE_AUTH != "True":
get_active_user = fastapi_users.get_current_active_user
from fastapi_users import FastAPIUsers
from fastapi_users.authentication import JWTAuthentication
from fastapi_users.db import SQLAlchemyUserDatabase
from . import database, dbutils, models, schemas, settings
user_db = SQLAlchemyUserDatabase(
schemas.UserDB, database.database, models.User.__table__
)
jwt_authentication = JWTAuthentication(
secret=settings.SECRET, lifetime_seconds=3600, tokenUrl="/auth/jwt/login"
)
fastapi_users = FastAPIUsers(
user_db,
[jwt_authentication],
schemas.UserBase,
schemas.UserCreate,
schemas.UserUpdate,
schemas.UserDB,
)
class Boto3ClientCache:
"""
There may be many s3 nodes in the cluser. Once a client has been established,
cache it for future use. This class works for sts and s3 type clients.
"""
def __init__(self):
self.cache: Dict[str, boto3.Session] = {}
@staticmethod
from fastapi import APIRouter
from fastapi_users import FastAPIUsers
from fastapi_users.authentication import JWTAuthentication
from app.db import user_db
from app.models.users import User, UserCreate, UserUpdate, UserDB
SECRET = "SECRET"
auth_backends = []
jwt_authentication = JWTAuthentication(secret=SECRET, lifetime_seconds=3600)
auth_backends.append(jwt_authentication)
fastapi_users = FastAPIUsers(
user_db,
auth_backends,
User,
UserCreate,
UserUpdate,
UserDB,
)
current_active_user = fastapi_users.current_user(active=True)
auth_router = APIRouter(tags=["auth"])
auth_router.include_router(
fastapi_users.get_auth_router(jwt_authentication, requires_verification=False)
)
auth_router.include_router(fastapi_users.get_register_router())
user_router = APIRouter(tags=["users"])
from fastapi import FastAPI, Response, Request
from backend.api import routers
from backend.core.config import BACKEND_CORS_ORIGINS
from fastapi.middleware.cors import CORSMiddleware
from backend.db.session import database
from backend.users.logic import user_db, auth_backends, SECRET, jwt_authentication
from backend.users.schemas import User, UserCreate, UserUpdate, UserDB
app = FastAPI()
fastapi_users = FastAPIUsers(
user_db,
auth_backends,
User,
UserCreate,
UserUpdate,
UserDB,
)
app.add_middleware(
CORSMiddleware,
allow_origins=BACKEND_CORS_ORIGINS,
allow_credentials=True,
allow_methods=['*'],
allow_headers=['*'],
)
# @app.middleware("http")
# async def db_session_middleware(request: Request, call_next):
# response = Response("Internal server error", status_code=500)
def on_after_forgot_password(user: UserDB, token: str, request: Request):
# todo: send email to user with token
print(f"User {user.id} has forgot their password. Reset token: {token}")
jwt_authentication = JWTAuthentication(
secret=SECRET,
lifetime_seconds=3600,
tokenUrl=requests.utils.urlparse(base_url()).path + "/auth/jwt/login"
)
fastapi_users = FastAPIUsers(
user_db,
[jwt_authentication],
User,
UserCreate,
UserUpdate,
UserDB,
)
jwt_auth_router = fastapi_users.get_auth_router(jwt_authentication)
@jwt_auth_router.post("/refresh")
async def refresh_jwt(response: Response, user=Depends(fastapi_users.get_current_active_user)):
return await jwt_authentication.get_login_response(user, response)
register_router = fastapi_users.get_register_router(on_after_register)
reset_password_router = fastapi_users.get_reset_password_router(
SECRET, after_forgot_password=on_after_forgot_password
)
):
print(f"Verification requested for user {user.id}. Verification token: {token}")
async def get_user_manager(user_db: SQLAlchemyUserDatabase = Depends(get_user_db)):
yield UserManager(user_db)
bearer_transport = BearerTransport(tokenUrl="auth/jwt/login")
def get_jwt_strategy() -> JWTStrategy:
return JWTStrategy(secret=SECRET, lifetime_seconds=3600)
auth_backend = AuthenticationBackend(
name="jwt",
transport=bearer_transport,
get_strategy=get_jwt_strategy,
)
fastapi_users = FastAPIUsers(
get_user_manager,
[auth_backend],
User,
UserCreate,
UserUpdate,
UserDB,
)
current_active_user = fastapi_users.current_user(active=True)
from pydantic.types import UUID4
from pydantic import EmailStr
from ..desk.models import appeals
from ..reference_book.services import update_employee_licence
from ..service import send_mail, Email
auth_backends = []
jwt_authentication = JWTAuthentication(secret=SECRET, lifetime_seconds=3600)
auth_backends.append(jwt_authentication)
all_users = FastAPIUsers(
user_db,
auth_backends,
User,
UserCreate,
UserUpdate,
UserDB,
)
any_user = all_users.current_user(active=True)
employee = all_users.current_user(active=True, superuser=False)
developer_user = all_users.current_user(active=True, superuser=True)
default_uuid = UUID4("00000000-0000-0000-0000-000000000000")
async def get_owner(client_id: int, user: UserTable = Depends(any_user)):
if not (user.client_id == client_id and user.is_owner):
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
return user
print(f"User {user.id} has registered.")
def on_after_forgot_password(user: UserDB, token: str, request: Request):
print(f"User {user.id} has forgot their password. Reset token: {token}")
jwt_authentication = JWTAuthentication(
secret=SECRET, lifetime_seconds=3600, tokenUrl="/auth/jwt/login"
)
app = FastAPI()
fastapi_users = FastAPIUsers(
user_db,
[jwt_authentication],
User,
UserCreate,
UserUpdate,
UserDB,
)
app.include_router(
fastapi_users.get_auth_router(jwt_authentication), prefix="/auth/jwt", tags=["auth"]
)
app.include_router(
fastapi_users.get_register_router(on_after_register), prefix="/auth", tags=["auth"]
)
app.include_router(
fastapi_users.get_reset_password_router(
SECRET, after_forgot_password=on_after_forgot_password
),
prefix="/auth",
tags=["auth"],
