async def register(
background_tasks: BackgroundTasks,
user_create: UserCreate = Body(..., embed=True),
conn: AsyncIOMotorClient = Depends(get_database),
smtp_conn: FastMail = Depends(get_smtp),
) -> UserResponse:
await check_availability_username_and_email(conn, user_create.email,
user_create.username)
async with await conn.start_session(
) as session, session.start_transaction():
user_db: UserDB = await create_user(conn, user_create)
token: str = await TokenUtils.wrap_user_db_data_into_token(
user_db, subject=TokenSubject.ACCESS)
token_activation_expires_delta = timedelta(
minutes=settings.ACTIVATE_TOKEN_EXPIRE_MINUTES) # 7 days
token_activation: str = await TokenUtils.wrap_user_db_data_into_token(
user_db,
subject=TokenSubject.ACTIVATE,
token_expires_delta=token_activation_expires_delta,
)
action_link: str = f"{settings.FRONTEND_DNS}{settings.FRONTEND_ACTIVATION_PATH}?token={token_activation}"
await background_send_new_account_email(smtp_conn, background_tasks,
user_db.email, action_link)
return UserResponse(
user=UserTokenWrapper(**user_db.dict(), token=token))
async def read_user(username: str, db: DBClient = client):
"""Read user by id, username, or email"""
logging.info(">>> " + __name__ + ":" + read_user.__name__)
user = await crud.get(db, username)
if user:
return utils.create_aliased_response(UserResponse(response=user))
return utils.create_404_response()
async def update_user(ref: str, data: UserUpdate, db: DBClient = client):
"""Update user info"""
logging.info(">>> " + __name__ + ":" + update_user.__name__)
user = await crud.get(db, ref)
if not user:
return utils.create_404_response()
user = await crud.update(db, user["_id"], data)
if user:
return utils.create_aliased_response(UserResponse(response=user))
return utils.create_404_response()
async def login(
user_login: UserLogin = Body(..., embed=True),
conn: AsyncIOMotorClient = Depends(get_database),
) -> UserResponse:
user_db: UserDB = await get_user_by_email(conn,
user_login.email,
raise_bad_request=True)
if not user_db.check_password(user_login.password):
raise StarletteHTTPException(status_code=HTTP_400_BAD_REQUEST,
detail="Invalid credentials")
token: str = await TokenUtils.wrap_user_db_data_into_token(
user_db, subject=TokenSubject.ACCESS)
return UserResponse(user=UserTokenWrapper(**user_db.dict(), token=token))
async def update_current(
user_update: UserUpdate = Body(..., embed=True),
user_current: UserTokenWrapper = Depends(get_current_user),
conn: AsyncIOMotorClient = Depends(get_database),
) -> UserResponse:
user_update.username = (
None if user_update.username == user_current.username else user_update.username
)
user_update.email = (
None if user_update.email == user_current.email else user_update.email
)
await check_availability_username_and_email(
conn, user_update.email, user_update.username
)
user_db: UserDB = await update_user(conn, user_current, user_update)
return UserResponse(user=UserTokenWrapper(**user_db.dict()))
async def create_license(data: UserCreate, db: DBClient = client):
"""Required fields: `fullname`, `username`, `email`, `password`."""
logging.info(">>> " + __name__ + ":" + create_license.__name__)
data = data.dict()
data['type'] = config.USERTYPE_LICENSE
data = UserCreate(**data)
msg = await crud.check_free_email_username(db, data.username, data.email)
if msg:
return utils.error_400_response(msg)
user = await crud.create(db, data)
if user:
return utils.create_aliased_response(UserResponse(response=user))
return utils.create_500_response("User creation failed")
async def activate(
user_current: UserTokenWrapper = Depends(get_current_user),
conn: AsyncIOMotorClient = Depends(get_database),
) -> UserResponse:
token_db: TokenDB = await get_token(conn, user_current.token)
if token_db.subject == TokenSubject.ACTIVATE:
if not token_db.used_at:
user_db: UserDB = await update_user(
conn, user_current, UserUpdate(is_active=True)
)
await update_token(
conn, TokenUpdate(token=token_db.token, used_at=datetime.utcnow())
)
return UserResponse(user=UserTokenWrapper(**user_db.dict()))
raise StarletteHTTPException(
status_code=HTTP_403_FORBIDDEN, detail="Token has expired"
)
raise StarletteHTTPException(
status_code=HTTP_403_FORBIDDEN, detail="Invalid activation"
)
async def join_via_invitation(
user_invitation: UserTokenWrapper = Depends(get_user_from_invitation),
user_current: UserTokenWrapper = Depends(get_current_user),
conn: AsyncIOMotorClient = Depends(get_database),
) -> UserResponse:
# TODO: Create a user_friends entity in database and link them.
# TODO: Create gamification to encourage users to become part of the community
token_db: TokenDB = await get_token(conn, user_invitation.token)
if not token_db.used_at:
if user_current.email == token_db.user_email_invited:
await update_token(
conn, TokenUpdate(token=token_db.token, used_at=datetime.utcnow())
)
return UserResponse(user=UserTokenWrapper(**user_current.dict()))
raise StarletteHTTPException(
status_code=HTTP_403_FORBIDDEN, detail="This user was not invited"
)
raise StarletteHTTPException(
status_code=HTTP_403_FORBIDDEN, detail="Invitation token already used"
)
async def change_password(
user_current: UserTokenWrapper = Depends(get_current_user),
password: AnyStr = Body(..., embed=True),
conn: AsyncIOMotorClient = Depends(get_database),
) -> UserResponse:
token_db: TokenDB = await get_token(conn, user_current.token)
if token_db.subject == TokenSubject.RECOVER:
if not token_db.used_at:
user_db: UserDB = await update_user(
conn, user_current, UserUpdate(password=password)
)
await update_token(
conn, TokenUpdate(token=token_db.token, used_at=datetime.utcnow())
)
return UserResponse(user=UserTokenWrapper(**user_db.dict()))
raise StarletteHTTPException(
status_code=HTTP_403_FORBIDDEN, detail="Token has expired"
)
raise StarletteHTTPException(
status_code=HTTP_403_FORBIDDEN, detail="Invalid recovery"
)
async def update_user_me(
*,
password: str = Body(None),
fullname: str = Body(None),
email: EmailStr = Body(None),
current_user: UserInDB = Depends(get_current_active_user),
db: DBClient = client):
"""
Update own user
"""
# user_in = UserUpdate(**current_user.dict())
user_in = UserUpdate(**current_user)
if password is not None:
user_in.password = password
if fullname is not None:
user_in.fullname = fullname
if user_in.email is not None:
user_in.email = email
user = await crud.update(db, current_user["_id"], user_in)
if user:
return utils.create_aliased_response(UserResponse(response=user))
return utils.create_404_response()
async def current(
user_current: UserTokenWrapper = Depends(get_current_user),
) -> UserResponse:
return UserResponse(user=user_current)