async def get_user(user=Depends(get_user_or_404)):
return user
def create_club_tag(
club_tag: schemas.ClubTagCreate,
db: Session = Depends(dependencies.get_db),
user: schemas.User = Depends(dependencies.get_current_user),
):
return crud.create_club_tag(user.id, club_tag, db)
def create_user(
user: schemas.UserCreate,
db: Session = Depends(dependencies.get_db),
):
return crud.create_user(user, db)
def club_user_leave(
club_id: int,
db: Session = Depends(dependencies.get_db),
user: schemas.User = Depends(dependencies.get_current_user),
):
return crud.remove_user_from_club(club_id, user.id, db)
def delete_note(
note_id: int,
db: Session = Depends(dependencies.get_db),
user: schemas.User = Depends(dependencies.get_current_user),
):
return crud.delete_note(user.id, note_id, db)
def unfollow_user(
user_id: int,
db: Session = Depends(dependencies.get_db),
user: schemas.User = Depends(dependencies.get_current_user),
):
return crud.unfollow_user(user.id, user_id, db)
def read_clubs(
is_active: bool = True,
db: Session = Depends(dependencies.get_db),
user: schemas.User = Depends(dependencies.get_current_user),
):
return crud.read_clubs(user.id, is_active, db)
async def get_note(user: UserInDB = Depends(get_current_user)):
"""
Get the current users notes paginated
"""
return await NotesTableHandler.get(user.id)
async def search_notes(keyword: str,
user: UserInDB = Depends(get_current_user)):
"""
Search notes based on keyword
"""
return await NotesTableHandler.search(keyword, user.id)
async def verify_api_key(x_api_key: str = Depends(
APIKeyHeader(name="X-API-Key"))):
if not await app.state.system.verify_api_key(x_api_key):
raise HTTPException(status_code=401, detail="Invalid API key")
async def verify_admin_api_key(x_api_key: str = Depends(
APIKeyHeader(name="X-API-Key"))):
if not await app.state.system.verify_api_key(x_api_key, is_admin=True):
raise HTTPException(status_code=403, detail="Invalid API key")
app = FastAPI(title="ACE2 Remote API",
version="1.0.0",
openapi_tags=tags_metadata,
dependencies=[Depends(verify_api_key)])
@app.on_event("startup")
async def startup_event():
if ACE_ADMIN_PASSWORD not in os.environ:
sys.stderr.write(
f"\n\nERROR: missing {ACE_ADMIN_PASSWORD} env var\n\n")
sys.exit(1)
# register a default operating environment that ignores command line parameters
env = register_global_env(ACEOperatingEnvironment([]))
system = DefaultACESystem()
env.set_system(system)
app.state.system = system
async def verify_admin_api_key(x_api_key: str = Depends(
APIKeyHeader(name="X-API-Key"))):
if not await app.state.system.verify_api_key(x_api_key, is_admin=True):
raise HTTPException(status_code=403, detail="Invalid API key")
async def get_books(request: Request, mongodb: Mongodb = Depends(Mongodb)):
books = mongodb.read_books()
return templates.TemplateResponse(
'index.html',
{'request': request, 'title': 'home', 'books': books}
)
async def me(
user: user_db_model = Depends(
get_current_active_user), # type: ignore
):
return user
def get_users_router(
get_user_manager: UserManagerDependency[models.UC, models.UD],
user_model: Type[models.U],
user_update_model: Type[models.UU],
user_db_model: Type[models.UD],
authenticator: Authenticator,
requires_verification: bool = False,
) -> APIRouter:
"""Generate a router with the authentication routes."""
router = APIRouter()
get_current_active_user = authenticator.current_user(
active=True, verified=requires_verification)
get_current_superuser = authenticator.current_user(
active=True, verified=requires_verification, superuser=True)
async def get_user_or_404(
id: UUID4,
user_manager: BaseUserManager[models.UC,
models.UD] = Depends(get_user_manager),
) -> models.UD:
try:
return await user_manager.get(id)
except UserNotExists:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
@router.get(
"/me",
response_model=user_model,
name="users:current_user",
responses={
status.HTTP_401_UNAUTHORIZED: {
"description": "Missing token or inactive user.",
},
},
)
async def me(
user: user_db_model = Depends(
get_current_active_user), # type: ignore
):
return user
@router.patch(
"/me",
response_model=user_model,
dependencies=[Depends(get_current_active_user)],
name="users:current_user",
responses={
status.HTTP_401_UNAUTHORIZED: {
"description": "Missing token or inactive user.",
},
status.HTTP_400_BAD_REQUEST: {
"model": ErrorModel,
"content": {
"application/json": {
"examples": {
ErrorCode.UPDATE_USER_EMAIL_ALREADY_EXISTS: {
"summary":
"A user with this email already exists.",
"value": {
"detail":
ErrorCode.UPDATE_USER_EMAIL_ALREADY_EXISTS
},
},
ErrorCode.UPDATE_USER_INVALID_PASSWORD: {
"summary": "Password validation failed.",
"value": {
"detail": {
"code":
ErrorCode.UPDATE_USER_INVALID_PASSWORD,
"reason":
"Password should be"
"at least 3 characters",
}
},
},
}
}
},
},
},
)
async def update_me(
request: Request,
user_update: user_update_model, # type: ignore
user: user_db_model = Depends(get_current_active_user), # type: ignore
user_manager: BaseUserManager[models.UC,
models.UD] = Depends(get_user_manager),
):
try:
return await user_manager.update(user_update,
user,
safe=True,
request=request)
except InvalidPasswordException as e:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail={
"code": ErrorCode.UPDATE_USER_INVALID_PASSWORD,
"reason": e.reason,
},
)
except UserAlreadyExists:
raise HTTPException(
status.HTTP_400_BAD_REQUEST,
detail=ErrorCode.UPDATE_USER_EMAIL_ALREADY_EXISTS,
)
@router.get(
"/{id:uuid}",
response_model=user_model,
dependencies=[Depends(get_current_superuser)],
name="users:user",
responses={
status.HTTP_401_UNAUTHORIZED: {
"description": "Missing token or inactive user.",
},
status.HTTP_403_FORBIDDEN: {
"description": "Not a superuser.",
},
status.HTTP_404_NOT_FOUND: {
"description": "The user does not exist.",
},
},
)
async def get_user(user=Depends(get_user_or_404)):
return user
@router.patch(
"/{id:uuid}",
response_model=user_model,
dependencies=[Depends(get_current_superuser)],
name="users:user",
responses={
status.HTTP_401_UNAUTHORIZED: {
"description": "Missing token or inactive user.",
},
status.HTTP_403_FORBIDDEN: {
"description": "Not a superuser.",
},
status.HTTP_404_NOT_FOUND: {
"description": "The user does not exist.",
},
status.HTTP_400_BAD_REQUEST: {
"model": ErrorModel,
"content": {
"application/json": {
"examples": {
ErrorCode.UPDATE_USER_EMAIL_ALREADY_EXISTS: {
"summary":
"A user with this email already exists.",
"value": {
"detail":
ErrorCode.UPDATE_USER_EMAIL_ALREADY_EXISTS
},
},
ErrorCode.UPDATE_USER_INVALID_PASSWORD: {
"summary": "Password validation failed.",
"value": {
"detail": {
"code":
ErrorCode.UPDATE_USER_INVALID_PASSWORD,
"reason":
"Password should be"
"at least 3 characters",
}
},
},
}
}
},
},
},
)
async def update_user(
user_update: user_update_model, # type: ignore
request: Request,
user=Depends(get_user_or_404),
user_manager: BaseUserManager[models.UC,
models.UD] = Depends(get_user_manager),
):
try:
return await user_manager.update(user_update,
user,
safe=False,
request=request)
except InvalidPasswordException as e:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail={
"code": ErrorCode.UPDATE_USER_INVALID_PASSWORD,
"reason": e.reason,
},
)
except UserAlreadyExists:
raise HTTPException(
status.HTTP_400_BAD_REQUEST,
detail=ErrorCode.UPDATE_USER_EMAIL_ALREADY_EXISTS,
)
@router.delete(
"/{id:uuid}",
status_code=status.HTTP_204_NO_CONTENT,
response_class=Response,
dependencies=[Depends(get_current_superuser)],
name="users:user",
responses={
status.HTTP_401_UNAUTHORIZED: {
"description": "Missing token or inactive user.",
},
status.HTTP_403_FORBIDDEN: {
"description": "Not a superuser.",
},
status.HTTP_404_NOT_FOUND: {
"description": "The user does not exist.",
},
},
)
async def delete_user(
user=Depends(get_user_or_404),
user_manager: BaseUserManager[models.UC,
models.UD] = Depends(get_user_manager),
):
await user_manager.delete(user)
return None
return router
async def prueba(db: Session = Depends(obtener_db)):
resultado = db.query(Contacto).all()
return resultado
async def create_reservation(reservation: ReserveUserRequest,
uid=Depends(AuthorizationFactory('activity', 'create'))):
res = db.reserve_item(uid, reservation.item_name, reservation.amount, int(time()*1000))
return res
async def obtener_lista_contactos(db: Session = Depends(obtener_db)):
return repositorio.lista_contactos(db)
async def reservation_cancel(request: ReserveUserCancel, uid=Depends(AuthorizationFactory('activity', 'cancel'))):
ctnt = {'reason': request.reason, 'status': 'canceled'}
r = db.reservation_cancel(uid, request.aid, ctnt)
return {'r': str(r)}
def read_club(
club_id: int,
db: Session = Depends(dependencies.get_db),
user: schemas.User = Depends(dependencies.get_current_user),
):
return crud.read_club(user.id, club_id, db)
async def reservation_checkout(request: ReserveFrontdeskCheckout, uid=Depends(AuthorizationFactory('activity', 'checkout'))):
ctnt = {'item_ids':request.item_ids, 'status': 'checked out'}
r = db.reservation_checkout(uid, request.aid, ctnt)
return {'r': str(r)}
def club_user_join(
club_id: int,
db: Session = Depends(dependencies.get_db),
user: schemas.User = Depends(dependencies.get_current_user),
):
return crud.add_user_to_club(club_id, user.id, db)
async def reservation_return(request: ReserveFrontdeskReturn, uid=Depends(AuthorizationFactory('activity', 'return'))):
ctnt = {'note': request.note, 'status': 'closed'}
r = db.reservation_return(uid, request.aid, ctnt)
return {'r': str(r)}
def create_note(
note: schemas.NoteCreate,
db: Session = Depends(dependencies.get_db),
user: schemas.User = Depends(dependencies.get_current_user),
):
return crud.create_note(user.id, note, db)
def protected(Authorize: AuthJWT = Depends()):
Authorize.jwt_required()
return {'hello': 'world'}
def read_tags(
archived: bool = False,
db: Session = Depends(dependencies.get_db),
user: schemas.User = Depends(dependencies.get_current_user),
):
return crud.read_tags(user.id, archived, db)
def raw_token(Authorize: AuthJWT = Depends()):
Authorize.jwt_required()
return Authorize.get_raw_jwt()
def delete_club_tag(
club_tag_id: int,
db: Session = Depends(dependencies.get_db),
user: schemas.User = Depends(dependencies.get_current_user),
):
return crud.delete_club_tag(user.id, club_tag_id, db)
def get_refresh_token(Authorize: AuthJWT = Depends()):
Authorize.jwt_refresh_token_required()
return Authorize.get_jwt_subject()
def read_user(user: schemas.User = Depends(dependencies.get_current_user), ):
return user
async def update_schema(
conn=Depends(connection()),
schema: str = Path(..., regex=ID_REGEX),
file: UploadFile = File(...),
):
schema = "gen3_" + schema
migration_eql = io.StringIO()
print(f"CREATE MIGRATION {schema}::mig TO {{", file=migration_eql)
with PFBReader(file.file) as pfb:
nodes = {}
for node in pfb.metadata["nodes"]:
nodes[node["name"]] = node
for node in pfb.schema:
node = dict(node)
if node["type"] == "record":
nodes[node["name"]]["fields"] = [
dict(field) for field in node["fields"]
]
else:
logger.warning("Skipping node of unknown type %s: %s",
node["type"], node)
enums = {}
for node in nodes.values():
node_name = _make_node_name(node["name"])
print(f" type {node_name} {{", file=migration_eql)
for field in node["fields"]:
types = field["type"]
if isinstance(types, str):
types = [types]
required = True
type_ = None
for t in types:
if isinstance(t, list):
t = dict(t)
if t["type"] == "enum":
enum_type = f"{node_name}_{field['name']}_t"
enums.setdefault(enum_type,
set()).update(t["symbols"])
assert type_ in (
None,
enum_type,
), "union type is not supported"
type_ = enum_type
else:
logger.warning("Skipping %s.%s type %s", node_name,
field["name"], t)
elif t == "null":
required = False
else:
assert type_ is None, "union type is not supported"
type_ = t
if type_ is None:
logger.warning("Skipping null type field: %s", field)
else:
print(
f" {'required ' if required else ''}"
f"property {field['name']} -> {_TYPES.get(type_, type_)};",
file=migration_eql,
)
for link in node["links"]:
migration_eql.write(" ")
if link["multiplicity"] in {"ONE_TO_MANY", "MANY_TO_MANY"}:
migration_eql.write("multi ")
migration_eql.write(
f"link {link['name']} -> {_make_node_name(link['dst'])}")
if link["multiplicity"] == "ONE_TO_ONE":
print(" {", file=migration_eql)
print(" constraint exclusive;",
file=migration_eql)
print(" }", file=migration_eql)
else:
print(";", file=migration_eql)
print(" }", file=migration_eql)
for enum_name, symbols in enums.items():
print(f" scalar type {enum_name} extending str {{",
file=migration_eql)
print(f" constraint one_of ('", file=migration_eql, end="")
migration_eql.write("', '".join(symbols))
print("');", file=migration_eql)
print(" }", file=migration_eql)
print("}", file=migration_eql)
logger.critical("Migrating schema of %s to:\n%s", schema,
migration_eql.getvalue())
async with conn.transaction() as tx:
await ensure_module(conn, schema)
await conn.execute(migration_eql.getvalue())
try:
await conn.fetchall(f"COMMIT MIGRATION {schema}::mig")
except edgedb.errors.InternalServerError:
# bug in EdgeDB
tx.raise_rollback()
return schema
