def change_password(self, request):
"""
api to change user password
''
"""
user = request.user
serializer_class = self.get_serializer_class()
serializer_data = serializer_class(data=request.data)
if serializer_data.is_valid():
old_password = request.data.get('old_password')
if user.check_password(old_password):
new_password = request.data.get('new_password')
user.set_password(new_password)
user.save()
success = True
data = []
response_data = success_response(data=data)
else:
success = False
error = {'old_password': "******"}
response_data = error_response(error)
else:
success = False
error = get_serializer_errors(serializer_data.errors)
response_data = error_response(error)
return Response(response_data, status=response_data.get("code"))
def reset_password(self, request, pk):
"""
api to change forgot password
''
"""
forgot_pass_token = pk
response_data = success_response()
if request.method == 'GET':
user_object = auth_model.objects.filter(
is_deleted=False,
forgot_pass_verify_code=forgot_pass_token).first()
if user_object:
data = {'valid': True, 'user_id': user_object.pk}
response_data = success_response(data=data)
else:
error = {'valid': False}
response_data = error_response(error)
elif request.method == 'POST':
serializer_class = self.get_serializer_class()
serializer_data = serializer_class(data=request.data)
if serializer_data.is_valid():
user_object = auth_model.objects.filter(
is_deleted=False,
pk=serializer_data.data.get('user_id'),
forgot_pass_verify_code=forgot_pass_token).first()
if user_object:
new_password = request.data.get('new_password')
user_object.set_password(new_password)
user_object.forgot_pass_verify_code = None # TODO
user_object.save()
data = dict()
message = api_message['success_password_changed']
response_data = success_response(data=data,
message=message)
else:
error = {
'token':
'Forgot password token is not valid, try again'
}
response_data = error_response(error)
else:
error = get_serializer_errors(serializer_data.errors)
response_data = error_response(error)
return Response(response_data, status=response_data.get("code"))
def login(self, request):
"""
user login api
"""
print("\n=====> Login Data:", request.data)
serializer_class = self.get_serializer_class()
serializer_data = serializer_class(data=request.data)
if serializer_data.is_valid():
user_email = serializer_data.data.get('email')
user_password = serializer_data.data.get('password')
get_user = auth_model.objects.filter(is_deleted=False,
email=user_email).first()
if get_user:
if get_user.is_active:
if get_user.check_password(user_password):
token = Token.objects.get_or_create(
user=get_user)[0] # TokenAuthentication
# get_user.is_online = True
get_user.save()
data = get_login_user_dict(request, get_user, token)
message = api_message['login_success']
response_data = success_response(data=data,
message=message)
else:
# Here email is exist but password is wrong so success is True but code is 400
error = {'password': api_message['wrong_password']}
response_data = error_response(error)
else:
error = {'email': api_message['account_deactivated']}
response_data = error_response(error)
else:
error = {'email': api_message['email_not_exist']}
response_data = error_response(error)
else:
print("serializer_data:", serializer_data.errors)
error = get_serializer_errors(serializer_data.errors)
response_data = error_response(error)
return Response(response_data, status=response_data.get("code"))
def post(self, request, role_id):
"""
for Update profile data
"""
serializer_data = self.serializer_class(data=request.data)
if serializer_data.is_valid():
permission_ids = serializer_data.data.get('permission_ids', list())
print("\n ==> permission_ids: ", permission_ids)
models.RolePermission.objects.filter(role_id=role_id).delete()
for perm_id in permission_ids:
data_obj = dict()
data_obj['role_id'] = role_id
data_obj['permission_id'] = perm_id
data_obj['created_by'] = request.user.pk
data_obj['updated_by'] = request.user.pk
models.RolePermission.objects.create(**data_obj)
data = permission_ids
response_data = success_response(data=data)
else:
error = get_serializer_errors(serializer_data.errors)
response_data = error_response(error)
return Response(response_data, status=response_data.get("code"))
def get(self, request, pk):
"""
for Retrieve product data
"""
obj = models.Product.objects.filter(pk=pk, is_deleted=False, is_active=True).first()
if obj:
data_info = dict()
data_info['id'] = obj.pk
data_info['title'] = obj.title
data_info['image'] = obj.get_image_url()
data_info['glace'] = obj.glace
data_info['description'] = obj.description
data_info['extra_note'] = obj.extra_note
data_info['importing'] = obj.get_importing()
data_info['category'] = obj.get_category()
data_info['subcategory'] = obj.get_subcategory()
data_info['is_favorite'] = obj.is_favorite
data_info['type'] = obj.get_type()
data_info['sizes'] = obj.get_size()
data_info['price'] = obj.price
response_data = success_response(data=data_info)
else:
response_data = error_response(code=404)
return Response(response_data, status=response_data["code"])
def view(self, request, pk):
"""
Retrieve object by Id for view.
"""
get_instance = self.get_object(pk)
if get_instance:
data = self.get_object_view_data(get_instance)
response_data = success_response(data=data)
else:
error = {'id': response_text[603]}
response_data = error_response(error)
return Response(response_data, status=response_data["code"])
def destroy(self, request, pk):
"""
Delete object by pk.
"""
instance = self.get_object(pk)
if instance:
self.perform_destroy(instance, request)
response_data = success_response()
else:
error = {'id': response_text[603]}
response_data = error_response(error)
return Response(response_data, status=response_data["code"])
def update(self, request, pk):
"""
Update object by Id.
"""
if settings.DEBUG:
print("\n============ PUT ==>: request.data =============\n")
print("DEBUG: ", settings.DEBUG)
print("\nrequest.data: ", request.data)
print("\n=================================================\n")
get_instance = self.get_object(pk)
extra_context = self.update_serializer_context(request)
if get_instance:
serializer_class = self.get_serializer_class()
serializer = serializer_class(get_instance,
data=request.data,
context=extra_context)
if serializer.is_valid():
self.perform_update(serializer, request)
data = []
response_data = success_response(data=data)
else:
if settings.DEBUG:
print("\nSerializer Errors: ", serializer.errors, "\n")
error = get_serializer_errors(serializer.errors)
response_data = error_response(error)
else:
error = {'id': response_text[603]}
response_data = error_response(error)
return Response(response_data, status=response_data["code"])
return Response(response_data, status=response_data["code"])
def forgot_password(self, request):
"""
api to change forgot password
''
"""
serializer_class = self.get_serializer_class()
serializer_data = serializer_class(data=request.data)
if serializer_data.is_valid():
user_object = auth_model.objects.filter(
is_deleted=False,
email=serializer_data.data.get('email')).first()
if not user_object:
error = {'email': 'The contact email is not registered'}
response_data = error_response(error)
elif not user_object.is_active:
error = {
'email':
'The contact email is not active or verified, Please contact admin'
}
response_data = error_response(error)
else:
password_reset_email(request, user_object)
data = dict()
message = "Reset password link has been sent your registered email id, Please check your mail"
response_data = success_response(data=data, message=message)
else:
error = get_serializer_errors(serializer_data.errors)
response_data = error_response(error)
return Response(response_data, status=response_data.get("code"))
def get(self, request, key):
cms_obj = models.Cms.objects.filter(is_deleted=False,
is_active=True,
key=key).first()
if cms_obj:
data_info = dict()
data_info['key'] = cms_obj.key
data_info['title'] = cms_obj.title
data_info['content'] = cms_obj.content
response_data = success_response(data_info)
else:
response_data = error_response()
return Response(response_data, status=response_data["code"])
def favorite(self, request, pk):
"""
favorite/Unfavorite product by id.
"""
serializer_class = self.get_serializer_class()
serializer = serializer_class(data=request.data)
if serializer.is_valid():
self.model.objects.filter(pk=pk).update(
is_favorite=serializer.data.get('is_favorite'))
response_data = success_response()
else:
error = get_serializer_errors(serializer.errors)
response_data = error_response(error)
return Response(response_data, status=response_data["code"])
def partial_update(self, request, pk):
"""
Change active status (active/inactive) of object by Id.
"""
instance = self.get_object(pk)
if instance:
instance.is_active = False if instance.is_active else True
instance.updated_by = request.user.id
instance.save()
data = {'is_active': instance.is_active}
response_data = success_response(data=data)
else:
error = {'id': response_text[603]}
response_data = error_response(error)
return Response(response_data, status=response_data["code"])
def check_user_token(self, request):
"""
api to check user token
''
"""
token = request.META.get('HTTP_AUTHORIZATION').split(' ')[1]
user = request.user
token_obj = Token.objects.filter(key=token, user_id=user.id).first()
if token_obj:
success = True
data = get_login_user_dict(request, user, token_obj)
response_data = success_response(data=data)
else:
success = False
error = {'token': api_message['login_again']}
response_data = error_response(error=error)
return Response(response_data, status=response_data.get("code"))
def post(self, request):
"""
for Update profile data
"""
serializer_data = self.serializer_class(request.user,
data=request.data)
if serializer_data.is_valid():
user_obj = serializer_data.save()
user_obj.updated_by = request.user.pk
user_obj.save()
data = get_profile_data(user_obj)
response_data = success_response(data=data)
else:
error = get_serializer_errors(serializer_data.errors)
response_data = error_response(error)
return Response(response_data, status=response_data.get("code"))
def create(self, request):
"""
Create a new object.
"""
if settings.DEBUG:
p_print("POST ==>: request.data", request.data)
extra_context = self.update_serializer_context(request)
serializer_class = self.get_serializer_class()
serializer = serializer_class(data=request.data, context=extra_context)
if serializer.is_valid():
self.perform_create(serializer, request)
data = []
response_data = success_response(data=data)
else:
if settings.DEBUG:
print("\nSerializer Errors: ", serializer.errors, "\n")
error = get_serializer_errors(serializer.errors)
response_data = error_response(error)
return Response(response_data, status=response_data["code"])
