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))
