def test_email_verification(new_user_email_unverified, api_key):
link = auth.generate_email_verification_link(new_user_email_unverified.email)
assert isinstance(link, str)
query_dict = _extract_link_params(link)
user_email = _verify_email(query_dict['oobCode'], api_key)
assert new_user_email_unverified.email == user_email
assert auth.get_user(new_user_email_unverified.uid).email_verified
def verify_email():
data = request.json
email = data.get("email")
verification_link = None
try:
# TODO: Add ActionCodeSetting for custom link/redirection back to main page
verification_link = firebase_admin_auth.generate_email_verification_link(
email)
except ValueError:
msg = "Invalid email"
logger.info(msg)
return create_response(status=422, message=msg)
except FirebaseError as e:
msg = e.message
logger.info(msg)
return create_response(status=422, message=msg)
if not send_email(
recipient=email,
subject="Mentee Email Verification",
data={"link": verification_link},
template_id=USER_VERIFICATION_TEMPLATE,
):
msg = "Could not send email"
logger.info(msg)
return create_response(status=422, message=msg)
return create_response(message="Sent verification link to email")
def register(request):
register_serializer = RegisterSerializer(data=request.data)
register_serializer.is_valid(raise_exception=True)
data = register_serializer.data
action_code_settings = auth.ActionCodeSettings(
url='https://buildevents.today/#login', )
try:
user = auth.create_user(email=data['email'],
phone_number=data['phone_number'],
display_name=data['name'],
password=data['password'])
link = auth.generate_email_verification_link(
user.email, action_code_settings)
email_success = AuthViewSet.send_verification_email(
user.email, link)
if not email_success:
return Response(
{
'detail':
'Something went wrong, we are unable to send a verification link to your '
'email'
},
status=status.HTTP_503_SERVICE_UNAVAILABLE)
else:
return Response(
"Verification link has been sent to {}.".format(
user.email),
status=status.HTTP_200_OK)
except (ValueError, exceptions.FirebaseError) as e:
return Response({'detail': str(e)},
status=status.HTTP_400_BAD_REQUEST)
def email_verification_link():
action_code_settings = init_action_code_settings()
# [START email_verification_link]
email = '*****@*****.**'
link = auth.generate_email_verification_link(email, action_code_settings)
# Construct email from a template embedding the link, and send
# using a custom SMTP server.
send_custom_email(email, link)
def test_email_verification_no_settings(self, user_mgt_app):
_, recorder = _instrument_user_manager(user_mgt_app, 200, '{"oobLink":"https://testlink"}')
link = auth.generate_email_verification_link('*****@*****.**', app=user_mgt_app)
request = json.loads(recorder[0].body.decode())
assert link == 'https://testlink'
assert request['requestType'] == 'VERIFY_EMAIL'
self._validate_request(request)
def test_email_verification_with_settings(new_user_email_unverified, api_key):
action_code_settings = auth.ActionCodeSettings(ACTION_LINK_CONTINUE_URL)
link = auth.generate_email_verification_link(new_user_email_unverified.email,
action_code_settings=action_code_settings)
assert isinstance(link, str)
query_dict = _extract_link_params(link)
assert query_dict['continueUrl'] == ACTION_LINK_CONTINUE_URL
user_email = _verify_email(query_dict['oobCode'], api_key)
assert new_user_email_unverified.email == user_email
assert auth.get_user(new_user_email_unverified.uid).email_verified
def create_user(data: Dict[str, str]):
name = data["name"]
username = data["username"]
email = data["email"]
password = data["password"]
terms_and_conditions_checked = data["terms_and_conditions_checked"]
existing_user = UserModel.find_by_username(username)
if existing_user:
return {"message": "Acount already exists with this username"}, 400
try:
user = auth.create_user(
email=email,
email_verified=False,
password=password,
display_name=name,
disabled=False,
)
link = auth.generate_email_verification_link(
email, action_code_settings=None)
""" To implement, send verification link usingg # send_verification_link(email,link) """
except Exception as e:
return {"message": str(e)}, 400
try:
firebase_details = auth.get_user_by_email(email)
uid = firebase_details.uid
firebase_email = firebase_details.email
user = UserModel(name, uid, username, email, password,
terms_and_conditions_checked)
user.save_to_db()
except Exception as e:
return {"message": str(e)}, 400
return {
"verify_link":
link,
"message":
"User was created successfully. Please check your email to verify the account",
}, 201
def create(self, validated_data):
"""Create new user with encrypted password and return it"""
print('creating user: '******'email'])
try:
firebase_user = auth.create_user(**validated_data)
firebase_uid = firebase_user.uid
except auth.EmailAlreadyExistsError:
print('Firebase user already exists')
raise serializers.ValidationError(
'firebase user could not be created')
if firebase_user:
print('sending verification link to: ', validated_data['email'])
link = auth.generate_email_verification_link(
validated_data['email'])
print(link)
email_body_text = "Thanks for registering your account with Workbound\n" + \
f"Please verify your email address by visiting this link: {link}"
email_body_html = (
"<html>\n"
"<body>\n"
"<p>Thanks for registering your account with Workbound<br />"
f"Please verify your email address by visiting this link: <a href={link}>{link}</a>"
"</p>"
"</body>"
"</html>")
send_email(validated_data['email'],
'Workbound Email verification link', email_body_text,
email_body_html)
if get_user_model().objects.filter(
email=validated_data['email']).exists():
raise serializers.ValidationError(
{'error': 'Email already exists'})
else:
user = get_user_model().objects.create_user(**validated_data)
user.firebase_uid = firebase_uid
user.save()
return user
def create_user(data: Dict[str, str]):
"""Creates a new user"""
name = data['name']
email = data['email']
password = data['password']
role = data['role']
existing_user = UserModel.find_by_email(email.lower())
if existing_user and existing_user.firebase_id != "":
return {"message": "User already exists"}, 400
if existing_user and existing_user.firebase_id == "" and role != 2:
return {"message": "User is invited as a moderator. Please sign up as a moderator with unique code"}, 400
if role == 2:
if "otp" in data:
invitation = InvitesModel.find_by_mod_email(email.lower())
if invitation:
if data["otp"] != invitation.unique_code:
return {"message": "Code is incorrect"}, 401
else:
return {"message": "Sorry! Invite is needed to be a moderator"}, 400
else:
return {"message": "Please send unique code"}, 400
print("Passed")
try:
user = auth.create_user(
email=email,
email_verified=False,
password=password,
display_name=name,
disabled=False
)
link = auth.generate_email_verification_link(email, action_code_settings=None)
''' To implement, send verification link usingg # send_verification_link(email,link) '''
except Exception as e:
return {"message": str(e)}, 400
try:
firebase_details = auth.get_user_by_email(email)
uid = firebase_details.uid
firebase_email = firebase_details.email
''' Existing user is a temporary moderator user '''
if existing_user:
existing_user.firebase_id = uid
existing_user.name = name
existing_user.email = firebase_email
existing_user.save_to_db()
else:
user = UserModel(uid, name, firebase_email, password, role)
user.save_to_db()
except Exception as e:
print(e)
send_email_verification_message(link, email)
return {"verify_link": link,
"message" : "User was created successfully. Please check your email to verify the account"
}, 201
