def list(self,
request,
custom_queryset=None,
custom_query_params=None,
*args,
**kwargs):
if not custom_queryset and not custom_queryset.__class__.__name__ == 'QuerySet':
queryset = self.filter_queryset(self.get_queryset())
else:
queryset = self.filter_queryset(custom_queryset)
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_response_serializer(page, many=True)
general_response = rsp.Response(
True,
self.get_paginated_response(
serializer.data).data).generate_response()
if custom_query_params:
data = self.get_data_from_response(general_response)
general_response = self.apply_custom_query_params(
general_response, data, custom_query_params)
return Response(general_response, status=status.HTTP_200_OK)
serializer = self.get_response_serializer(queryset, many=True)
general_response = rsp.Response(True,
serializer.data).generate_response()
return Response(general_response, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
user = request.user
if user.is_authenticated:
TokenUser.objects.filter(user=user, token=request.auth).delete()
general_response = rsp.Response(True, message="logout success", data=None).generate_response()
return Response(general_response, status=status.HTTP_200_OK)
def update(self,
request,
custom_instance=None,
custom_data=None,
*args,
**kwargs):
if custom_instance:
instance = custom_instance
else:
instance = self.get_object()
partial = kwargs.pop('partial', False)
if custom_data:
serializer = self.get_request_serializer(instance,
data=custom_data,
partial=partial)
else:
serializer = self.get_request_serializer(instance,
data=request.data,
partial=partial)
serializer.is_valid(raise_exception=True)
instance_res = self.perform_update(serializer)
if getattr(instance, '_prefetched_objects_cache', None):
# If 'prefetch_related' has been applied to a queryset, we need to
# forcibly invalidate the prefetch cache on the instance.
instance._prefetched_objects_cache = {}
serializer = self.get_response_serializer(instance_res)
general_response = rsp.Response(True,
serializer.data).generate_response()
return Response(general_response, status=status.HTTP_200_OK)
def custom_exception_handler(exc, context):
response = exception_handler(exc, context)
exception_class = exc.__class__.__name__
if response:
if exception_class == 'ParseError':
message = 'JSON parse error'
elif exception_class == "ValidationError":
try:
list_errors = list(exc.detail.items())
data_error = []
for error in list_errors:
data_error.append("{} : {}".format(error[0], error[1][0]))
message = ', '.join(data_error)
except Exception:
message = 'Invalid ' + list(
list(exc.detail.items())[0][1][0].items())[0][0]
else:
message = exc.detail
try:
status_code = exc.status_code
except Exception:
status_code = status.HTTP_400_BAD_REQUEST
else:
status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
message = exc.args[0]
general_response = rsp.Response(False, message=message,
data=None).generate_response()
response = Response(data=general_response, status=status_code)
return response
def retrieve(self, request, custom_object=None, *args, **kwargs):
if not custom_object and custom_object.__class__.__name__ == 'NoneType':
instance = self.get_object()
else:
instance = custom_object
serializer = self.get_response_serializer(instance)
general_response = rsp.Response(serializer.data).generate_response()
return Response(general_response, status=status.HTTP_200_OK)
def create(self, request, *args, **kwargs):
serializer = self.get_request_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
instance = self.perform_create(serializer)
if isinstance(instance, (list, )):
serializer = self.get_response_serializer(instance, many=True)
else:
serializer = self.get_response_serializer(instance)
general_response = rsp.Response(serializer.data).generate_response()
return Response(general_response, status=status.HTTP_201_CREATED)
def make_token(self, status):
payload = {
'user_id': self.user.id,
'time_create': self.token,
}
token = jwt_encode_handler(payload)
response_data = {
'token': token
}
general_response = rsp.Response(response_data).generate_response()
response = Response(general_response, status=status)
return response
def post(self, request, *args, **kwargs):
serializer = LoginSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = serializer.validated_data
token_jwt = jwt.encode({
'user_id': user.id,
'exp': datetime.utcnow() + JWT_AUTH.get('JWT_EXPIRATION_DELTA'),
}, SECRET_KEY)
TokenUser.objects.create(token=token_jwt.decode(), user=user)
general_response = rsp.Response(True, message="User logged in successfully", data=token_jwt).generate_response()
return Response(general_response, status=status.HTTP_201_CREATED)
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
instance = self.perform_create(serializer)
mail_template = EmailTemplate()
mail_template.send_activation_email(instance)
general_response = rsp.Response(
UserResponseSerializer(instance).data).generate_response()
response = Response(general_response,
status=status.HTTP_201_CREATED)
return response
def custom_response(self, data, message=None, message_param=None):
general_response = rsp.Response(True, data).generate_response()
return Response(general_response, status=status.HTTP_200_OK)
def destroy(self, request, *args, **kwargs):
instance = self.get_object()
self.perform_destroy(instance)
general_response = rsp.Response(True, None).generate_response()
return Response(general_response, status=status.HTTP_200_OK)
def make_response(self, status_code):
general_response = rsp.Response(
data=None,
error_code=self.error_code,
custom_message=self.custom_message).generate_response()
return Response(data=general_response, status=status_code)
def custom_response(self, data):
general_response = rsp.Response(data).generate_response()
return Response(general_response, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
token = request.auth.token
Token.objects.filter(user=request.user, token=token).delete()
general_response = rsp.Response(None).generate_response()
return Response(general_response, status=status.HTTP_200_OK)
def check_auth_code(self, request, *args, **kwargs):
serializer = CheckOTPCodeSerializer(data=request.data, **kwargs)
if serializer.is_valid(raise_exception=True):
serializer.save()
general_response = rsp.Response({}).generate_response()
return Response(general_response, status=status.HTTP_200_OK)
def check_exist_company(self, request, *args, **kwargs):
serializer = CheckCompanySerializer(data=request.data, **kwargs)
if serializer.is_valid(raise_exception=True):
general_response = rsp.Response({}).generate_response()
return Response(general_response, status=status.HTTP_200_OK)
