def login(self, request): """ To authenticate a user login :param request: :return: """ try: username = request.data.get('email', None) password = request.data.get('password', None) if username is None or password is None: raise err.ValidationError(*("Email or password is not given", 400)) user = authenticate(username=username, password=password) if user is not None: payload = jwt_payload_handler(user) token = jwt_encode_handler(payload) user_logged_in.send(sender=User, request=request, user=user) return Response({ "token": token, "status": "success", }) else: user_login_failed.send(None, request=request, credentials={'username': username}) return Response({ "status": "failure", "msg": "Invalid parameters" }) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def post(self, request): username = request.POST.get('username') password = request.POST.get('password') grant_type = request.POST.get('grant_type') try: if username is None: raise User.DoesNotExist user = User.objects.get(email=username) # Deleting existing user token for our web client application # If enbaled it will logout all other active web browser logins # AccessToken.objects.filter(user=user, application=Application.objects.get(name="Web Client")).delete() except Exception as e: raise err.ValidationError(*err.m.EMAIL_NOT_EXISTS) self.delete_calendar_credentials(user) url, headers, body, status_code = self.create_token_response(request) if status_code == 200: token = json.loads(body) token['rocket_chat'] = get_rocket_chat_token(user) token['contact'] = ContactRefSerializer(user.get_contact_profile, many=False).data token = json.dumps(token) else: raise err.ValidationError(*err.m.PASSWORD_WRONG) response = HttpResponse(content=token, status=status_code) for k, v in headers.items(): response[k] = v return response
def verify_birthday(self, birthday=None): """ Verify birthday to find whether adult or not :param birthday: :return: """ try: if not birthday: raise err.ValidationError(*("Birthday is not given", 400)) if not is_adult(birthday): raise err.ValidationError(*("You are not an adult", 400)) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def random_word(self, length): try: letters = string.ascii_lowercase return ''.join(random.choice(letters) for i in range(length)) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def signup(self, request): """ To signup a new user in the system :param request: :return: """ try: self.verify_birthday(request.data.get('birthday', None)) first_name = request.data.get('first_name', None) last_name = request.data.get('last_name', None) email = request.data.get('email', None) password = request.data.get('password', None) username = request.data.get('username', None) params = { 'first_name': first_name, 'last_name': last_name, 'email': email, 'password': make_password(password), 'username': username } self.verify_password(**params) serializer = UserSerializer(data=params) if serializer.is_valid(raise_exception=True): user = serializer.save() return Response({ "success": True, "msg": "User successfully registered" }) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def time_zones(self, request): try: timezones = pytz.all_timezones return Response({"data": timezones}) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def currencies(self, request): try: url = 'https://openexchangerates.org/api/currencies.json' result = requests.get(url=url) return Response({"data": json.loads(result.text)}) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def destroy(self, request, *args, **kwargs): try: instance = self.get_object() instance.delete(force=True) return Response(status=status.HTTP_204_NO_CONTENT) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def phone_codes(self, request): try: url = 'https://gist.githubusercontent.com/Goles/3196253/raw/9ca4e7e62ea5ad935bb3580dc0a07d9df033b451/CountryCodes.json' result = requests.get(url=url) return Response({"data": json.loads(result.text)}) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def countries(self, request): try: url = 'http://country.io/names.json' result = requests.get(url=url) return Response({"data": json.loads(result.text)}) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def languages(self, request): try: languages = Languages.objects.all() return Response( {"data": LanguagesSerializer(languages, many=True).data}) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def delete_user_language(self, request): try: user_language_id = request.data.get('user_language_id', None) UserLanguages.objects.filter(pk=user_language_id).first().delete( force=True) return Response({"data": "Success"}) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def add_languages(self): try: url = 'https://pkgstore.datahub.io/core/language-codes/language-codes_json/data/734c5eea7e10548144a18241e8f931f8/language-codes_json.json' result = requests.get(url=url) formatted_result = json.loads(result.text) for lang in formatted_result: Languages.objects.create(code=lang.get('alpha2', None), name=lang.get('English', None)) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def get(self, request, token): try: invitation = Invitations.objects.get(reference=token) if invitation.is_accepted: raise err.ValidationError(*err.m.INVALID_URL) else: status_code = status.HTTP_200_OK content = { 'status': 'Valid', 'email': invitation.contact.email } response = dict(data=content) content = json.dumps(response) except: raise err.ValidationError(*err.m.INVALID_URL) response = HttpResponse(content=content, status=status_code) return response
def create_or_update_user_profile(sender, instance, created, **kwargs): try: if created: UserProfile.objects.create(user=instance) from .constants import NotificationTypes NotificationTypes = helper.prop2pair(NotificationTypes) for k, v in NotificationTypes: Notification.objects.create(user=instance, notification_type=k) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def post(self, request): self.delete_calendar_credentials(request.user) logout_rocket_chat(request) url, headers, body, status_code = self.create_revocation_response( request) if status_code == 200: response = HttpResponse(content='', status=status_code) return response else: raise err.ValidationError(*err.m.PASSWORD_WRONG)
def list_user_languages(self, request): try: user_languages = UserLanguages.objects.filter( user=request.user).all() return Response({ "data": UserLanguagesSerializer(user_languages, many=True).data }) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def post(self, request, format=None): """ Generates password reset key and send email :param str email: Email address """ try: User.objects.generate_password_reset_key(request.data.get('email')) values = {"status": "Success"} return Response(dict(data=values), status=status.HTTP_201_CREATED) except Exception as e: raise err.ValidationError(*err.m.EMAIL_NOT_EXISTS)
def verify_password(self, **params): try: if not params['first_name'] or not params['last_name']: raise err.ValidationError( *("First name and last name cant be empty", 400)) if len(params['password']) < 9: raise err.ValidationError(*("At least 8 characters", 400)) invalid_chars = set(string.punctuation.replace("_", "")) if not any(char.isdigit() for char in params['password']) \ and not any(char in invalid_chars for char in params['password']): raise err.ValidationError(*("Must contains a number or symbol", 400)) if params['first_name'] in params['password'] \ or params['last_name'] in params['password'] or \ params['email'] in params['password']: raise err.ValidationError( *("Password cannot contain your name or email address", 400)) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def add_user_language(self, request): try: user = request.user language = Languages.objects.filter( pk=request.data.get('language', None)).first() user_language = UserLanguages.objects.create(user=user, language=language) return Response( {"data": UserLanguagesSerializer(user_language).data}) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def add_notifications(self): try: from apps.account.constants import NotificationTypes NotificationTypes = helper.prop2pair(NotificationTypes) for individual_user in User.objects.all(): if Notification.objects.filter( user=individual_user).count() == 0: for k, v in NotificationTypes: Notification.objects.create(user=individual_user, notification_type=k) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def reset_password(self, request): """ To reset forget password with new password :param request: :return: """ try: token = request.query_params.get('token', None) password = request.data.get('password', None) reset_password = ResetPassword.objects.filter(token=token).first() if reset_password and (timezone.now() - reset_password.created_at ).days > 0 or reset_password.expired: raise err.ValidationError(*("Reset password link is expired", 400)) if check_password(password, reset_password.user.password) or not password: raise err.ValidationError( *("New password cant be the old password or empty", 400)) params = { 'first_name': reset_password.user.first_name, 'last_name': reset_password.user.last_name, 'email': reset_password.user.email, 'password': make_password(password), 'username': reset_password.user.username } self.verify_password(**params) reset_password.user.set_password(password) reset_password.user.save() ResetPassword.objects.filter(user=reset_password.user).exclude( pk=reset_password.pk).all().delete() reset_password.expired = True reset_password.save() return Response({ "success": True, "msg": "Password successfully changed" }) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def forget_password(self, request): """ To reset password for forget password functionality :param request: :return: """ try: email = request.data.get('email', None) if not email: raise err.ValidationError(*("Email is not given", 400)) user = User.objects.filter(email=email).first() if not user: raise err.ValidationError( *("User does not exist for this given email", 400)) token = self.random_word(8) ResetPassword.objects.create(email=email, user=user, token=token) link = request.get_host() + "/reset_password?token=" + token mail.send( email, # List of email addresses also accepted '*****@*****.**', template= 'forget_password', # Could be an EmailTemplate instance or name context={ 'user': user.first_name, 'link': link }, priority='now', ) return Response({ "success": True, "msg": "Reset password link is " "successfully send to your email" }) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def change_password(self, request): """ To change password of an existing user :param request: :return: """ try: new_password = request.data.get('new_password', None) old_password = request.data.get('old_password', None) if not new_password or not old_password: raise err.ValidationError(*("Password details are not entered", 400)) if check_password(old_password, request.user.password): request.user.set_password(new_password) request.user.save() return Response({ "success": True, "msg": "Password successfully changed" }) else: raise err.ValidationError(*("Current password is false", 400)) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def attempts(self, request): """ To list audit login details for a user :param request: :return: """ try: audit_entries = AuditEntry.objects.filter( username=request.user.username).order_by('-created_at')[:5] serialized_data = AuditEntrySerializer(audit_entries, many=True).data return Response({"data": serialized_data}) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def user_login_failed_callback(request, credentials, **kwargs): """ Track user logged out details :param sender: :param credentials: :param kwargs: :return: """ try: ip = request.META.get('REMOTE_ADDR') AuditEntry.objects.create(action='user_login_failed', ip=ip, username=credentials.get('username', None)) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def put(self, request, format=None): """ Reset Password request with password reset key :param str email: Email address :param str reset_key: Password Rest Key :param str new_password: New Password """ try: serializer = ResetPasswordSerializer(data=request.data) serializer.is_valid(True) User.objects.reset_password(**serializer.data) values = {"status": "Success"} return Response(dict(data=values), status=status.HTTP_201_CREATED) except Exception as e: raise err.ValidationError(*err.m.INVALID_URL)
def post(self, request, format=None): """ Register new user with key :param str password: Password\n :param str first_name: First name\n :param str last_name: Last Name\n :param str invitation_ref: Invitation Token """ try: serializer = SignUpSerializer(data=request.data) if serializer.is_valid(raise_exception=True): serializer.save() values = {"status": "Success"} response = dict(data=values) return Response(response, status=status.HTTP_201_CREATED) except Exception as e: raise err.ValidationError(*err.m.INVALID_DATA)
def user_logged_out_callback(sender, request, user, **kwargs): """ Track user logged out details :param sender: :param request: :param user: :param kwargs: :return: """ try: ip = request.META.get('REMOTE_ADDR') AuditEntry.objects.create(action='user_logged_out', ip=ip, username=user.username) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))
def logout(self, request): """ To change password of an existing user :param reques :return: """ try: # TODO url = "http://" + request.get_host() + "/api-token-refresh/" post_data = {"token": request.auth.decode("utf-8")} headers = {'Content-Type': 'application/json'} result = requests.post(url=url, headers=headers, data=post_data) user_logged_out.send(sender=User, request=request, user=request.user) logout(request) return Response(status=status.HTTP_200_OK) except Exception as e: logger.error(e) raise err.ValidationError(*(e, 400))