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"]})