def post(self, request, *args, **kwargs):
"""
:param request: POST request for registering a new user
:return: returns the 'true' response if the activation link is successfully sent to the registered mail
"""
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user_data = serializer.validated_data
username = user_data['username']
password = user_data['password']
email = user_data['email']
user = User.objects.create_user(username=username,
password=password,
email=email,
is_active=False)
user.save()
mail_subject = 'Activate your user account.'
# Get current site
current_site = get_current_site(request)
jwt_token = encode_token(username, password)
token = get_surl(jwt_token).split('/s')[1]
activation_link = 'http://' + str(current_site.domain) + reverse(
'email-activation', args=('token', )) + token + '/'
stat = eventemitter.ee.emit('event', activation_link, mail_subject,
email)
smd = smd_response(
success=str(stat),
message=
"the user is registered successfully,the activation link is successfully sent to the user email",
data=user_data,
status=status.HTTP_200_OK)
return smd
def post(self, request):
email = request.POST.get('email')
try:
user = User.objects.filter(email=email)
useremail = user.values()[0]['email']
username = user.values()[0]["username"]
id = user.values()[0]["id"]
if useremail is not None:
token = token_activation(username, id)
url = str(token)
surl = get_surl(url)
slug_url = surl.split('/')
mail_subject = "reset your account password by clicking below link"
mail_message = render_to_string(
'UserTemplates/reset_password_token_link.html', {
'user': username,
'domain': get_current_site(request).domain,
'surl': slug_url[2]
})
print(mail_message)
recipientemail = useremail
email = EmailMessage(mail_subject,
mail_message,
to=[recipientemail])
email.send()
return HttpResponse("Check your mail")
except TypeError:
print("Type error")
def post(self, request):
"""
This api is for user registration to this application
@param request: user registration data like username, email and password
@return: account verification link to registered email once registration is successful
"""
data = request.data
username = data.get('username')
email = data.get('email')
password1 = data.get('password1')
password2 = data.get('password2')
if len(password1) < 4 or len(password2) < 4:
logger.error(
"length of the password must be greater than 4, from post()")
return Response("length of the password must be greater than 4",
status=status.HTTP_400_BAD_REQUEST)
elif password1 != password2:
logger.error("passwords are not matching, from post()")
return Response("passwords are not matching",
status=status.HTTP_400_BAD_REQUEST)
check_name = User.objects.filter(Q(username__iexact=username))
check_email = User.objects.filter(Q(email__iexact=email))
if check_name.exists():
logger.error(
"already user id present with this username, from post()")
return Response("already user id present with this username ")
elif check_email.exists():
logger.error(
"already user id present with this email, from post()")
return Response("already user id present with this email")
else:
user = User.objects.create(username=username, email=email)
user.set_password(password1)
user.is_active = False
user.save()
payload = jwt_payload_handler(user)
token = jwt_encode_handler(payload)
# user is unique then we will send token to his/her email for validation
# token = token_activation(user.username, user.password)
url = str(token)
surl = get_surl(url)
short_token = surl.split("/")
mail_subject = "Activate your account by clicking below link"
mail_message = render_to_string(
'email_validation.html', {
'user': user.username,
'domain': get_current_site(request).domain,
'surl': short_token[2]
})
recipient_email = user.email
subject, from_email, to = 'greeting from fundoo,Activate your account by clicking below link', settings.EMAIL_HOST, recipient_email
msg = EmailMultiAlternatives(subject, mail_message, from_email,
[to])
msg.attach_alternative(mail_message, "text/html")
msg.send()
logger.info("verify through your email, from post()")
return Response({"details": "verify through your email"},
status=status.HTTP_201_CREATED)
def post(self, request):
email = request.data['email']
if email == "":
return HttpResponse('enter_email')
else:
try:
validate_email(email)
except ValidationError:
return HttpResponse('enter_valid_email')
try:
user = User.objects.filter(email=email)
username = user.values()[0][
'username'] #Fetch username still if user is not logedin
payload = {
'username': username,
}
token = generate_token(payload)
current_site = get_current_site(request)
domain_name = current_site.domain
surl = get_surl(str(token))
final_url = surl.split("/")
mail_subject = "Reset Your password by clicking below link"
msg = render_to_string(
'accounts/reset_password.html', {
'username': username,
'domain': domain_name,
'surl': final_url[2],
})
send_mail(mail_subject,
msg,
EMAIL_HOST_USER, [email],
fail_silently=False)
return HttpResponse('success')
except SMTPException:
return Response('Bad request, please try again later.')
def post(self, request, *args, **kwargs):
email = request.data.get('email')
try:
validate_email(email)
except ValidationError:
return Response({'code': 404, 'msg': response_code[404]})
user = User.objects.filter(email=email)
try:
username = user.values()[0]['username']
except IndexError:
return Response({'code': 303, 'msg': response_code[303]})
payload = {
'username': username,
}
token = generate_token(payload)
current_site = get_current_site(request)
domain_name = current_site.domain
surl = get_surl(str(token))
final_url = surl.split("/")
mail_subject = static_data.PASSWORD_RESET_MESSAGE
msg = render_to_string('account/forgot_password.html', {
'username': username,
'domain': domain_name,
'surl': final_url[2],
})
try:
send_mail(mail_subject,
msg,
EMAIL_HOST_USER, [email],
fail_silently=False)
return Response({'code': 200, 'msg': response_code[200]})
except SMTPException:
return Response({'code': 301, 'msg': response_code[301]})
def post(self, request):
form = ForgotPasswordForm(data=request.data)
response = {"success": False, "message": "User not Found", "data": []}
email = request.data['email']
username = request.data['username']
user = User.objects.get(username=username, email=email)
token = jwt.encode({
'id': user.id
}, 'secret', algorithm='HS256').decode('utf-8')
surl = get_surl(token)
surl = surl.split('/')
message = render_to_string(
'forgot.html', {
'user': user,
'domain': get_current_site(request).domain,
'token': surl[2]
})
subject = f'Reset Password Link from {get_current_site(request).domain}'
send_mail(subject,
message,
os.getenv("EMAIL"), ['*****@*****.**'],
fail_silently=False)
response["success"] = True
response[
"message"] = "We have sent you a TOKEN,Please check your registered E-Mail ID"
response["data"] = token
return JsonResponse(data=response, status=status.HTTP_200_OK)
def post(self, request):
email = request.data('email')
try:
user = User.objects.filter(email=email)
if user.count() == 0:
return Response("Not Found mail in database")
else:
username = user.values()[0]["username"]
current_site = get_current_site(request)
domain_name = current_site.domain
token = token_activation(username=username)
url = str(token)
surl = get_surl(url)
short_token = surl.split('/')
mail_subject = "Click link for activating "
msg = render_to_string(
'email_validation.html', {
'user': username,
'domain': domain_name,
'surl': short_token[2]
})
recipients = email
email = EmailMessage(mail_subject, msg, to=[recipients])
email.send()
print('confirmation mail sent')
return Response(
'Please confirm your email address to reset password')
except KeyError:
return Response("Key error")
def post(self, request, *args, **kwargs):
try:
serializer = ForgotPasswordSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
user_data = serializer.data
email = user_data['email']
username = user_data['username']
user = User.objects.get(username=username)
mail_subject = 'Confirmation mail,hello user,forgot password? this is your token to' \
' reset your password'
jwt_token = encode_token(user.username, email)
token = get_surl(jwt_token).split('/s/')[1]
reset_message = token
eventemitter.ee.emit('forgot_password', reset_message,
mail_subject, email)
smd = smd_response(
success=True,
message=
"The forgot password mail has been sent successfully to your mail",
data=user_data,
status=status.HTTP_200_OK)
return smd
except User.DoesNotExist:
return Response({
'error':
'The user is not registered with the respective credentials'
})
except SMTPException as e:
print('There was an error sending an email: ', e)
def post(self, request):
global response
email = request.data["email"]
response = {
'success': False,
'message': "not a vaild email ",
'data': []
}
# email validation is done here
if email == "":
response[
'message'] = 'email field is empty please provide vaild input'
return HttpResponse(json.dumps(response), status=400)
else:
try:
validate_email(email)
except Exception:
return HttpResponse(json.dumps(response), status=400)
try:
# pdb.set_trace()
user = User.objects.filter(email=email)
useremail = user.values()[0]["email"]
username = user.values()[0]["username"]
id = user.values()[0]["id"]
# here user is not none then token is generated
if useremail is not None:
token = token_activation(username, id)
url = str(token)
surl = get_surl(url)
z = surl.split("/")
# email is generated where it is sent the email address entered in the form
mail_subject = "Activate your account by clicking below link"
mail_message = render_to_string(
'user/email_validation.html', {
'user': username,
'domain': get_current_site(request).domain,
'surl': z[2]
})
recipientemail = email
ee.emit('send_email', recipientemail, mail_message)
response = {
'success': True,
'message': "check email for vaildation ",
'data': []
}
# here email is sent to user
return HttpResponse(json.dumps(response), status=201)
except Exception as e:
print(e)
response['message'] = "something went wrong"
return HttpResponse(json.dumps(response), status=400)
def post(self, request, *args, **kwargs):
if request.user.is_authenticated:
return Response({'code': 410, 'msg': response_code[410]})
first_name = request.data.get('first_name')
last_name = request.data.get('last_name')
username = request.data.get('username')
email = request.data.get('email')
password = request.data.get('password')
confirm_password = request.data.get('confirm_password')
try:
validate_email(email)
except ValidationError:
return Response({'code': 404, 'msg': response_code[404]})
try:
validate_password_match(password, confirm_password)
validate_password_pattern_match(password)
except PasswordDidntMatched as e:
return Response({"code": e.code, "msg": e.msg})
except PasswordPatternMatchError as e:
return Response({"code": e.code, "msg": e.msg})
try:
validate_duplicat_username_existance(username)
except UsernameAlreadyExistsError as e:
return Response({"code": e.code, "msg": e.msg})
try:
validate_duplicate_email_existance(email)
except EmailAlreadyExistsError as e:
return Response({"code": e.code, "msg": e.msg})
user_obj = User.objects.create_user(first_name=first_name,
last_name=last_name,
username=username,
email=email,
password=password)
user_obj.is_active = False
user_obj.save()
payload = {'username': username, 'password': password}
token = generate_token(payload)
surl = get_surl(str(token))
final_url = surl.split('/')
curren_site = get_current_site(request)
domain = curren_site.domain
subject = static_data.ACCOUNT_ACTIVATION_SUBJECT
msg = render_to_string('account/account_activation.html', {
'username': username,
'domain': domain,
'surl': final_url[2],
})
try:
send_mail(subject,
msg,
EMAIL_HOST_USER, [email],
fail_silently=False)
except SMTPException:
return Response({'code': 301, 'msg': response_code[301]})
return Response({"code": 201, "msg": response_code[201]})
def post(self, request):
try:
userName = request.data['username']
email = request.data['email']
password = request.data['password']
confirm_password = request.data['confirm_password']
if userName == "" or email == "" or password == "":
return Response("You can not put empty fields",
status=status.HTTP_406_NOT_ACCEPTABLE)
if password == confirm_password:
try:
validate_email(email)
user = User.objects.create_user(username=userName,
email=email,
password=password)
user.is_active = False
user.save()
current_site = get_current_site(request)
domain_name = current_site.domain
token = token_activation(username=userName,
password=password)
url = str(token)
surl = get_surl(url)
short_token = surl.split('/')
mail_subject = "Click link for activating "
msg = render_to_string(
'email_validation.html', {
'user': userName,
'domain': domain_name,
'surl': short_token[2]
})
recipients = email
print(msg)
email = EmailMessage(mail_subject, msg, to=[recipients])
email.send()
print('confirmation mail sent')
return Response(
'Please confirm your email address to complete the registration',
status=status.HTTP_200_OK)
except ValidationError:
return Response("Email not found",
status=status.HTTP_404_NOT_FOUND)
else:
return Response("Password Missmatch",
status=status.HTTP_400_BAD_REQUEST)
except IntegrityError:
return Response("User Already exist")
def post(self, request):
if request.user.is_authenticated:
return HttpResponse("your are already registred,please do login")
data = request.POST
username = data.get('username')
email = data.get('email')
password1 = data.get('password1')
password2 = data.get('password2')
if password1 != password2:
return HttpResponse("passwords are not matching")
qs_name = User.objects.filter(Q(username__iexact=username))
qs_email = User.objects.filter(Q(email__iexact=email))
if qs_name.exists():
return HttpResponse("already user id pret with this username ")
elif qs_email.exists():
return HttpResponse("already user id present with this email")
else:
user = User.objects.create(username=username, email=email)
user.set_password(password1)
user.is_active = False
user.save()
token = token_activation(user.username, password1)
current_site = get_current_site(request)
domain = current_site.domain
url = str(token)
surl = get_surl(url)
slug_url = surl.split('/')
#print(slug_url[2])
mail_subject = "Click below link for activate your acount"
message = render_to_string(
'UserTemplates/account_activation_link.html', {
'user': user.username,
'domain': domain,
'surl': slug_url[2]
})
recipients = email
email = EmailMessage(mail_subject, message, to=[recipients])
print(message)
email.send()
return HttpResponse("Check your mail and activate your accout")
def post(self, request):
"""
This api is used to send reset password request to server
@param request: user registered email id
@return: sends a password reset link to user validated email id
"""
email = request.data['email']
if email == "":
logger.error('email should not be empty')
return Response({'details': 'email should not be empty'})
else:
try:
validate_email(email)
except Exception:
logger.error('not a valid email')
return Response({'details': 'not a valid email'})
try:
user = User.objects.filter(email=email)
user_email = user.values()[0]['email']
user_username = user.values()[0]['username']
user_id = user.values()[0]['id']
if user_email:
token = token_activation(user_username, user_id)
url = str(token)
surl = get_surl(url)
short_token = surl.split('/')
mail_subject = "Activate your account by clicking below link"
mail_message = render_to_string(
'email_validate.html', {
'user': user_username,
'domain': get_current_site(request).domain,
'surl': short_token[2]
})
recipient_email = user_email
subject, from_email, to = 'greeting from fundoo,Activate your account by clicking below link', settings.EMAIL_HOST, recipient_email
msg = EmailMultiAlternatives(subject, mail_message,
from_email, [to])
msg.attach_alternative(mail_message, "text/html")
msg.send()
logger.info(
'please check your email,link has sent your email, from forgotpassword'
)
return Response(
{
'details':
'please check your email,link has sent your email'
},
status=status.HTTP_200_OK)
except Exception as e:
logger.error('something went wrong')
return Response({'details': 'something went wrong'})
def post(self, request):
"""
This api is for user registration to this application
@param request: user registration data like username, email and password
@return: account verification link to registered email once registration is successful
"""
data = request.data
username = data.get('username')
email = data.get('email')
password = data.get('password')
confirm_password = data.get('confirm_password')
if password != confirm_password:
logger.error("password mismatch")
return Response("password mismatch ",
status=status.HTTP_400_BAD_REQUEST)
user_name = User.objects.filter(Q(username__iexact=username))
user_email = User.objects.filter(Q(email__iexact=email))
if user_name.exists():
logger.error("Username already exist")
return Response("Username already exist",
status=status.HTTP_400_BAD_REQUEST)
elif user_email.exists():
logger.error("Email id already exist")
return Response("Email id already exist",
status=status.HTTP_400_BAD_REQUEST)
else:
user = User.objects.create(username=username, email=email)
user.set_password(password)
user.is_active = False
user.save()
payload = jwt_payload_handler(user)
token = jwt_encode_handler(payload)
url = str(token)
surl = get_surl(url)
short_token = surl.split("/")
msg = "Activate your account by clicking below link"
mail_message = render_to_string(
'email_validation.html', {
'user': user.username,
'domain': get_current_site(request).domain,
'surl': short_token[2]
})
recipient_email = user.email
recipients = email
email = EmailMessage(msg, mail_message, to=[recipients])
email.send()
logger.info("Confirmation email sent")
return Response(
'Please confirm your email address to complete the registration',
status=status.HTTP_200_OK)
def post(self, request):
"""
:param request: take user email address for sending reset password link
:return:
"""
# todo use body in place of request.data : DONE (but now i am using serializer)
# pdb.set_trace()
try:
serialized_data = ForgotPasswordSerializer(data=request.data)
if not 'email' in serialized_data.initial_data:
logger.error('email field not present')
raise KeyError('email field not present')
if serialized_data.is_valid():
email = serialized_data.data['email']
# data = json.loads(request.body)
# print(data['email'])
# email = data['email']
if not util.valid_email(email):
logger.error('Invalid Email')
raise ValueError('Email address is not valid')
if not User.objects.filter(email=email).exists():
logger.error('Email does not exist.')
raise ValueError('You are not register user!')
mail_subject = 'Reset your Password account.'
payload = {'email': email}
jwt_token = util.create_token(payload)
mail_url = get_surl(jwt_token)
short_token = mail_url.split("/")
# todo not use underscore in url : DONE
mail_url = request.build_absolute_uri(
reverse('userlogin:resetpassword', kwargs={'token': short_token[2]}))
ee.emit('messageEvent', mail_subject, email, mail_url)
response = util.smd_response(success=True, message='Check your mail and reset your password',
http_status=status.HTTP_200_OK)
logger.info('password link send on email')
else:
logger.error('ForgotPasswordSerializer serializer data not valid')
response = util.smd_response(message='serializer data not valid',
http_status=status.HTTP_400_BAD_REQUEST)
except Exception as exception_detail:
response = util.smd_response(message=str(exception_detail),
http_status=status.HTTP_404_NOT_FOUND)
return response
def post(self, request, *args, **kwargs):
# import pdb
# pdb.set_trace()
response = {
"success": False,
"message": "Something Went Wrong!",
"data": []
}
print(request.data)
username = request.data['username']
email = request.data['email']
password = request.data['password']
user = User.objects.create_user(username=username,
password=password,
email=email)
user.set_password(password)
token = jwt.encode({
'id': user.id
}, 'secret', algorithm='HS256').decode('utf-8')
surl = get_surl(token)
surl = surl.split("/")
message = render_to_string(
'activation.html', {
'user': user,
'domain': get_current_site(request).domain,
'token': surl[2]
})
subject = f'Activation Link from {get_current_site(request).domain}'
send_mail(subject,
message,
os.getenv("EMAIL"), ['*****@*****.**'],
fail_silently=False)
response["message"] = "Successfully Registered"
response["success"] = True
return JsonResponse(data=response, status=status.HTTP_201_CREATED)
def post(self, request):
form = ForgotPasswordForm(data=request.data)
# import pdb
# pdb.set_trace()
response = {"success": False, "message": "User not Found", "data": []}
try:
email = request.data['email']
username = request.data['username']
user = User.objects.get(username=username, email=email)
token = jwt.encode({
'id': user.id
}, 'secret', algorithm='HS256').decode('utf-8')
surl = get_surl(token)
surl = surl.split('/')
message = render_to_string(
'forgot_mail.html', {
'user': user,
'domain': get_current_site(request).domain,
'token': surl[2]
})
subject = f'Reset Password Link from {get_current_site(request).domain}'
send_mail(subject,
message,
settings.EMAIL_HOST_USER, [user.email],
fail_silently=False)
response["success"] = True
response[
"message"] = "We have sent you a TOKEN,Please check your registered E-Mail ID"
response["data"] = token
except Exception:
response = response
# return JsonResponse(data=response, status=status.HTTP_200_OK)
return render(request, 'response.html',
{'response': response["message"]})
def post(self, request):
"""
:purpose: in this function we register a new user via sending jwt token on email
:param request: here we get post request
:return:in this function we take user input for registration and sent mail to email id
"""
try:
# import pdb
# pdb.set_trace()
username = request.data['username']
email = request.data['email']
password = request.data['password']
if password != '':
User = get_user_model()
if User.objects.filter(username=username).exists():
messages.info(request, "Username Already Exists")
smd = SMD_Response(message="Username Already Exists!!Please enter a different username")
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
else:
user = User.objects.create_user(username=username, email=email, password=password)
token = TokenGeneration.encode_token(self, user)
surl = get_surl(token)
url = surl.split("/")
message = render_to_string('users/activate.html',
{'user': user.username,
'domain': get_current_site(request).domain,
'token': url[2]})
recipient_list = [email, ]
email_event.emit("Account_Activate_Event", message, recipient_list)
smd = SMD_Response(True, 'Thank You For Registering to our site, '
'Please check mail to activate your account', data=[])
return Response(smd, status=201)
else:
smd = SMD_Response(message="Password is Not Correct")
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error("Something Went Wrong" + str(e))
smd = SMD_Response(message="Registration Failed")
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""
:param request: here is post request por set password
:return: in this function we take email from user and send token for verification
"""
try:
username = request.data['username']
email = request.data['email']
User = get_user_model()
user = User.objects.get(username=username, email=email)
if user:
payload = {
'username': user.username,
'email': user.email
}
token = jwt.encode(payload, 'SECRET_KEY', algorithm='HS256').decode('utf-8')
surl = get_surl(token)
url = surl.split('/')
message = render_to_string('users/reset_password.html',
{
'user': user.username,
'domain': get_current_site(request).domain,
'token': url[2]
})
recipient_list = [email, ]
email_event.emit("Reset_Password_Event", message, recipient_list)
smd = SMD_Response(True, 'We have sent an email, '
'please click there on link to reset password', data=[])
return Response(smd, status=status.HTTP_200_OK)
else:
smd = SMD_Response(False, 'Reset Password Process Failed', data=[])
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error("Something Went Wrong" + str(e))
smd = SMD_Response(status=False, message="Failed!!!")
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
def short_url(self, key):
url = str(key)
surl = get_surl(url)
short = surl.split("/")
return short
def post(self, request):
# pdb.set_trace()
username = request.data['username']
email = request.data['email']
password = request.data['password']
smd = {
'success': False,
'message': "not registered yet",
'data': [],
}
try:
validate_email(email)
except Exception as e:
smd['message'] = "please enter vaild email address"
logger.error(
"error: %s while as email entered was not a vaild email address",
str(e))
return HttpResponse(json.dumps(smd), status=400)
# user input is checked
if username == "" or email == "" or password == "":
smd['message'] = "one of the details missing"
logger.error("one of the details missing logging in")
return HttpResponse(json.dumps(smd), status=400)
# if email exists it will show error message
elif User.objects.filter(email=email).exists():
smd['message'] = "email address is already registered "
logger.error(
"email address is already registered while logging in")
return HttpResponse(json.dumps(smd), status=400)
else:
try:
user_created = User.objects.create_user(username=username,
email=email,
password=password,
is_active=True)
user_created.save()
# user is unique then we will send token to his/her email for validation
if user_created is not None:
token = token_activation(username, password)
url = str(token)
surl = get_surl(url)
z = surl.split("/")
mail_subject = "Activate your account by clicking below link"
mail_message = render_to_string(
'user/email_validation.html', {
'user': user_created.username,
'domain': get_current_site(request).domain,
'surl': z[2]
})
recipient_email = user_created.email
email = EmailMessage(mail_subject,
mail_message,
to=[recipient_email])
email.send()
smd = {
'success': True,
'message':
'please check the mail and click on the link for validation',
'data': [token],
}
logger.info("email was sent to %s email address ",
username)
return HttpResponse(json.dumps(smd), status=201)
except Exception as e:
smd["success"] = False
smd["message"] = "username already taken"
logger.error("error: %s while loging in ", str(e))
return HttpResponse(json.dumps(smd), status=400)
def post(self, request):
"""
:param request: user request for send information for register the user
request parameters are username, email and password
:return: we send a activation link on user given mail if user input is valid
"""
# check user enter any empty field or not if any field is empty then give error
try:
serialized_data = RegistrationSerializer(data=request.data)
if not 'username' in serialized_data.initial_data or not 'password' in serialized_data.initial_data or \
not 'email' in serialized_data.initial_data:
logger.error("username/password/email field is not present")
raise KeyError('username and password field is not present')
if not serialized_data.is_valid():
logger.error('RegistrationSerializer data is not valid.')
raise ValueError('please enter valid', [k for k in serialized_data.errors.keys()])
username = serialized_data.initial_data['username']
email = serialized_data.initial_data['email']
password = serialized_data.initial_data['password']
if username == "":
logger.error('Empty username field')
raise ValueError("Error :username field should not be empty.")
elif email == "":
logger.error('Empty email field')
raise ValueError("Error :email field should not be empty.")
elif password == "":
logger.error('Empty password field')
raise ValueError("Error :password field should not be empty.")
elif not util.password_validator(password):
logger.error('password length is short.')
raise ValueError("Error :password should be at least 5 character's")
elif not util.valid_email(email):
logger.error('Email is not valid')
raise ValueError("Email is not valid")
# if all user input data is correct then create user profile with given name, email and password and
# then save in database
user = User.objects.create_user(username=username, email=email, password=password, is_active=False)
user.save()
# create jwt token this token is in byte form therefor we decode and convert into string format
payload = {
user.username: user.email
}
jwt_token = util.create_token(payload)
mail_url = get_surl(jwt_token)
short_token = mail_url.split("/")
mail_subject = 'Activate your account'
# Todo request schema for reverse url : DONE
# print(request.build_absolute_uri(reverse('userlogin:activate', kwargs={'token': short_token[2]})))
mail_url = request.build_absolute_uri(reverse('userlogin:activate', kwargs={'token': short_token[2]}))
ee.emit('messageEvent', mail_subject, email, mail_url)
response = util.smd_response(success=True, message='You are successfully registered',
http_status=status.HTTP_201_CREATED)
logger.info('User successfully registered')
except (KeyError, ValueError) as error:
response = util.smd_response(message=str(error), http_status=status.HTTP_400_BAD_REQUEST)
except Exception as exception_detail:
logger.error(exception_detail)
response = util.smd_response(message=str(exception_detail), http_status=status.HTTP_404_NOT_FOUND)
return response
def post(self, request, *args, **kwargs):
if request.user.is_authenticated:
return HttpResponse(
"Someone is already logged in, please logout first to register new user."
)
data = request.data
username = data.get('username')
email = data.get('email')
password = data.get('password')
password2 = data.get('password2')
try:
validate_email(email)
except ValidationError:
return Response('validated_email')
qs = User.objects.filter(Q(username__iexact=username))
if qs.exists():
return HttpResponse('user_exists')
'''
Password validation
'''
if password != password2:
return HttpResponse('password_not_matched')
elif len(password) < 8:
return HttpResponse('check_password')
elif re.search('[A-Za-z]', password) == None or re.search(
'[0-9]', password) == None:
return HttpResponse('check_password')
try:
user = User.objects.create(username=username, email=email)
user.set_password(password)
user.is_active = False
user.save()
payload = {
'username': username,
'password': password,
}
token = generate_token(payload)
current_site = get_current_site(request)
domain_name = current_site.domain
surl = get_surl(str(token))
final_url = surl.split("/")
mail_subject = "Activate your account"
msg = render_to_string(
'accounts/email_validation.html', {
'username': username,
'domain': domain_name,
'surl': final_url[2],
})
send_mail(
mail_subject,
msg,
EMAIL_HOST_USER,
[email],
fail_silently=False,
)
return HttpResponse("success")
except ValueError:
return HttpResponse("valueError")
except SMTPException:
return Response('Bad request, please try again later.')
except Exception:
return HttpResponse(
"something went wrong, please try again later.")
def post(self, request):
username = request.data['username']
email = request.data['email']
password1 = request.data['password1']
password2 = request.data['password2']
sms = {
'success': False,
'message': "not registered yet",
'data': [],
}
# if Entered email_id not valied show error
try:
validate_email(email)
except Exception as e:
sms['message'] = "please enter vaild email address"
logger.error(
"error: %s while as email entered was not a vaild email address",
str(e))
return HttpResponse(json.dumps(sms), status=400)
# if user input is black show error
if username == "" or email == "" or password1 == "" or password2 == "":
sms['message'] = "one of the details missing, please enter carefully."
logger.error(
"one of the details missing while registration process.")
return HttpResponse(json.dumps(sms), status=400)
# if email already exists it will show error message
elif User.objects.filter(email=email).exists():
sms['message'] = "email address is already registered, please enter other Email_Id!"
logger.error(
"email address is already registered registration process")
return HttpResponse(json.dumps(sms), status=400)
# if both passwords not matches then show error message
elif not password1 == password2:
sms['message'] = "Both password is not matched, please password enter carefully !"
logger.error(
"email address is already registered registration process")
return HttpResponse(json.dumps(sms), status=400)
# else valied details then create New user after Registration processes
else:
try:
user_created = User.objects.create_user(username=username,
email=email,
password=password1,
is_active=False)
user_created.save()
if user_created is not None:
# call create token and short it and send to email id.
token = str(token_activation(username, password1))
short_url = get_surl(token)
short_token = short_url.split("/")[2]
mail_subject = "Activate your account by clicking below link..!"
mail_message = render_to_string(
'Loginregistration/email_validation.html', {
'user': user_created.username,
'domain': get_current_site(request).domain,
'short_token': short_token,
})
recipient_email = user_created.email
subject, from_email, to = mail_subject, EMAIL_HOST_USER, recipient_email
#email = EmailMessage(mail_subject, mail_message, to=[recipient_email])
text_content = 'This is an important message.'
html_content = mail_message
msg = EmailMultiAlternatives(subject, text_content,
from_email, [to])
msg.attach_alternative(html_content, "text/html")
msg.send()
sms = {
'success': True,
'message':
'please check the mail and click on the link for validation',
'data': [token],
}
logger.info("email was sent to %s email address ",
username)
return HttpResponse(
'<h1>please check the mail and click on the link for validation</h1>',
status=201)
# if above conditions are failed then return error
except Exception as e:
sms["success"] = False
sms["message"] = "username already taken"
logger.error("error: %s while registration ", str(e))
return HttpResponse(json.dumps(sms), status=400)
def post(self, request):
email = request.POST.get('email')
sms = {
'success': False,
'message': "password not set yet ",
'data': []
}
# if email value is empty while forgot password return error
if email == "":
sms['message'] = 'email field is empty please provide vaild input'
logger.error('email field is empty please provide vaild input')
return HttpResponse(json.dumps(sms), status=400)
# else validate entered mail & filter mail is exists or not
else:
try:
validate_email(email)
except Exception:
sms['message'] = 'email field value is not vaild input, please provide valid email id.'
logger.error('email field value is not vaild input')
return HttpResponse(json.dumps(sms), status=400)
try:
query_user = User.objects.filter(email=email)
useremail = query_user.values()[0]["email"]
username = query_user.values()[0]["username"]
id = query_user.values()[0]["id"]
# generate token while forgot password reset process
if useremail is not None:
token = str(token_activation(username, id))
surl = get_surl(token)
short_token = surl.split("/")[2]
# email send to user for reset their password.
mail_subject = "Reset your account Password by clicking below link..!"
mail_message = render_to_string(
'Loginregistration/reset_pass_token.html', {
'user': username,
'domain': get_current_site(request).domain,
'short_token': short_token
})
recipient_email = email
subject, from_email, to = mail_subject, EMAIL_HOST_USER, recipient_email
text_content = 'This is an important message.'
html_content = mail_message
msg = EmailMultiAlternatives(subject, text_content,
from_email, [to])
msg.attach_alternative(html_content, "text/html")
msg.send()
sms = {
'success': True,
'message':
'please check the mail and click on the link for Reset password',
'data': [token],
}
logger.info("email was sent to %s email address ",
username)
return HttpResponse(
'<h1>please check the mail and click on the link for Reseting your password</h1>',
status=201)
except Exception as e:
print(e)
sms['message'] = "something went wrong, please try again."
logger.error("something went wrong")
return HttpResponse(json.dumps(sms), status=400)
def register_user(self, request):
"""
:param request: to register the user
:return: registers the user
"""
try:
username = request.data['username']
email = request.data['email']
password = request.data['password']
is_valid = validate_email(email)
if is_valid == False:
response = self.smd_response(False, 'Email is Invalid', [])
else:
"""
checking whether the user name or email exists or not
"""
if ((User.objects.filter(username=username).exists())
or (User.objects.filter(email=email).exists())):
response = self.smd_response(
False, 'Username or email alredy exists', [])
return response
elif username == "" or password == '' or email == '':
response = self.smd_response(False,
'Username or email is empty',
[])
return response
else:
"""
Inserting a new row into the database
"""
user = User.objects.create_user(username=username,
email=email,
password=password)
user.is_active = False
user.save()
"""
storing username and email as payload in dictionary format
"""
payload = {'username': user.username, 'email': user.email}
"""
creating the token
"""
token = jwt.encode(payload, "secret",
algorithm="HS256").decode('utf-8')
currentsite = get_current_site(request)
"""
getting the shortened token using get_surl method
"""
shortedtoken = get_surl(token)
"""
converting shortened token to string format
"""
stringshortedtoken = str(shortedtoken)
"""
splitting string
"""
splittedshortedtokenstr = stringshortedtoken.split('/')
mail_subject = 'Link to activate the account'
mail_message = render_to_string(
'activate.html', {
'user': user.username,
'domain': get_current_site(request).domain,
'token': splittedshortedtokenstr[2],
})
recipient_email = os.getenv('EMAILID')
"""
sending the mail
"""
ee.emit('send_mail', recipient_email, mail_message)
#email = EmailMessage(mail_subject, mail_message, to=[recipient_email])
#email.send()
response = self.smd_response(
True, 'Please check your mail for activating', [])
return response
except SMTPException:
response = self.smd_response(False, 'Exception while sending mail',
[])
except User.DoesNotExist:
response = self.smd_response(
False, 'Exception while getting the user using filter', [])
except DecodeError:
response = self.smd_response(
False, 'Exception while generating the token', [])
return response
def post(self, request):
username = request.data['username']
email = request.data['email']
password = request.data['password']
smd = {
'success': False,
'message': "not registered yet",
'data': [],
}
try:
validate_email(email)
except Exception as e:
smd['message'] = "please enter vaild email address"
logger.error(
"error: %s while as email entered was not a vaild email address",
str(e))
return HttpResponse(json.dumps(smd), status=400)
#return Response(smd, status=status.HTTP_400_BAD_REQUEST)
# user input is checked
if username == "" or email == "" or password == "":
smd['message'] = "one of the details missing"
logger.error("one of the details missing logging in")
return HttpResponse(json.dumps(smd), status=400)
#return Response(smd, status=status.HTTP_400_BAD_REQUEST)
# if email exists it will show error message
elif User.objects.filter(email=email).exists():
smd['message'] = "email address is already registered "
logger.error(
"email address is already registered while logging in")
return HttpResponse(json.dumps(smd), status=400)
#return Response(smd, status=status.HTTP_400_BAD_REQUEST)
else:
try:
user_created = User.objects.create_user(username=username,
email=email,
password=password,
is_active=True)
user_created.save()
# user is unique then we will send token to his/her email for validation
if user_created is not None:
#token = Token(username, password)
token = RefreshToken.for_user(user_created).access_token
url = str(token)
surl = get_surl(url)
#relativeLink = reverse('activate',kwargs={'surl':surl})
mail_subject = "Activate your account by clicking the link"
mail_message = {
'user': '******' + user_created.username,
'domain': get_current_site(request).domain,
'surl': surl
}
recipient_email = user_created.email
data = EmailMessage(mail_subject,
mail_message,
to=[recipient_email])
Util.send_email(data)
smd = {
'success': True,
'message':
'please check the mail and click on the link for validation',
'data': [token],
}
logger.info("email was sent to %s email address ",
username)
return HttpResponse(json.dumps(smd), status=201)
except Exception as e:
smd["success"] = False
smd["message"] = "username already taken"
logger.error("error: %s while loging in ", str(e))
return HttpResponse(json.dumps(smd), status=400)
def post(self, request, *args, **kwargs):
# import pdb
# pdb.set_trace()
response = {
"success": False,
"message": "Something Went Wrong!",
"data": []
}
try:
username = request.data['username']
email = request.data['email']
password = request.data['password']
# checking each field is filled
if username is '' or password is '' or email is '':
response["message"] = "All fields are mandatory"
raise Exception
# validating username
if not valid.username_validate(username):
response[
"message"] = "Length of Username should be greater than 3 and less than 16 and it can not be a number"
raise ValueError
# validating email
if not valid.email_validate(email):
response["message"] = "Not a valid email id"
raise ValueError
# validating password
if not valid.password_validate(password):
response["message"] = "Length of password must be 8 or more!!!"
raise ValueError
list_of_all_usernames = []
list_of_all_email = []
present_users = User.objects.all()
for i in present_users:
list_of_all_usernames.append(i.username)
list_of_all_email.append(i.email)
# checking if username exists
for j in list_of_all_usernames:
if j == username:
response["message"] = "User Already Exist..."
raise ValueError
# checking if email exists
for k in list_of_all_email:
if k == email:
response["message"] = "Email Already Exist..."
raise ValueError
# result = User.objects.get(username=username)
# if result:
# response["message"] = "User Already Exist..."
# raise ValueError
# moving ahead if data is correct
user = User.objects.create_user(username=username,
password=password,
email=email)
if user:
# setting password in encrypted form
user.set_password(password)
user.is_active = False
user.save()
response["success"] = True
response["message"] = "Successfully Registered"
# generating token with jwt using user id
token = jwt.encode({
'id': user.id
},
'secret',
algorithm='HS256').decode('utf-8')
# converting token in short url to send in the activation email
surl = get_surl(token)
surl = surl.split("/")
# message to send in email
message = render_to_string(
'activation.html', {
'user': user,
'domain': get_current_site(request).domain,
'token': surl[2]
})
# subject of the email
subject = f'Activation Link from {get_current_site(request).domain}'
# sending mail to the user who got registered to get activated
send_mail(subject,
message,
settings.EMAIL_HOST_USER, [user.email],
fail_silently=False)
# catching exceptions
except ValueError:
response = response
except Exception:
response = response
# return JsonResponse(data=response, status=status.HTTP_201_CREATED)
# return render(request, 'register.html', {'form': form})
return render(request, 'response.html',
{'response': response["message"]})
