def create(self, request): serializer = UserSerializer( data={ "username": request.data.get("username"), "password": request.data.get("password"), "first_name": request.data.get("firstName"), "last_name": request.data.get("lastName"), "email": request.data.get("email"), }) serializer.is_valid(raise_exception=True) new_user = serializer.save() sponsee_serializer = SponseeCreateSerializer( data={ "user": new_user.pk, "address": request.data.get("address"), "phone": request.data.get("phone"), "birth_certificate": request.data.get("birthCertificate"), "national_id": request.data.get("nationalId"), }) sponsee_serializer.is_valid(raise_exception=True) new_sponsee = sponsee_serializer.save() headers = self.get_success_headers( SponseeCreateSerializer(new_sponsee).data) return Response(SponseeListSerializer(new_sponsee).data, headers=headers)
def get(self, request, *args, **kwargs): queryset = Our_User.objects.filter(Q(first_insurer__isnull=False) | Q(second_insurer__isnull=False)) serialize = UserSerializer(data=queryset, many=True) serialize.is_valid() return Response(data=serialize.data, status=status.HTTP_200_OK)
def signup(request): serializer = UserSerializer(data=request.data) serializer.is_valid(raise_exception=True) user = serializer.save() auth_login(request, user) return Response(UserSerializer(instance=user).data, status=status.HTTP_201_CREATED)
def patch(self, request): user = request.user serializer = UserSerializer(data=request.data, partial=True) serializer.is_valid(raise_exception=True) phone_number = serializer.validated_data.get('phone_number', None) serializer.validated_data.get() if phone_number: user.phone_number = phone_number user.save() return Response(UserSerializer(user).data)
def create(self, request): serializer = UserSerializer( data={ "username": request.data.get("username"), "password": request.data.get("password"), "first_name": request.data.get("firstName"), "last_name": request.data.get("lastName"), "email": request.data.get("email"), }) serializer.is_valid(raise_exception=True) new_user = serializer.save() new_sponser = Sponser.objects.create(user=new_user) headers = self.get_success_headers(SponserSerializer(new_sponser).data) return Response(SponserSerializer(new_sponser).data, headers=headers)
def user_detail(request, pk): """ Retrieve, update or delete a code snippet. """ if request.user.is_authenticated: try: user = User.objects.get(pk=pk) except User.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) if request.method == 'GET': serializer = UserSerializer(user) return Response(serializer.data) elif request.method == 'PUT': request.data['password'] = hashlib.sha256( str(request.data['password']).encode()).hexdigest() serializer = UserSerializer(user, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) elif request.method == 'DELETE': user.delete() return Response({'mgs': "success"}, status=status.HTTP_204_NO_CONTENT) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) return Response({'msg': "login required"}, status=status.HTTP_403_FORBIDDEN)
def post(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.save() return Response(serializer.data) else: return Response(serializer.errors)
def post(self, request): """ Handles the POST request made to the '/accounts/' URL. This view will take the 'data' property from the 'request' object, deserialize it into a 'User' object and store in the DB. IT WILL CREATE NEW USERS and return 201 (successfully created) if the user is successfully created, otherwise returns a 400(bad request) """ serializer = UserSerializer(data=request.data) # Check to see if the data in the `request` is valid. # If the cannot be deserialized into a User object then # a bad request response will be returned. # Else, save the data and return the data and a successfully # created status if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) else: data = serializer.data # Create a new user using the 'username' contained in # the data 'dict' user = User.objects.create(username=data["username"]) # Use the 'set_password' method to create a HASHED password # using the password provided in the 'data' dict user.set_password(data["password"]) user.save() return Response(data, status=status.HTTP_201_CREATED)
def post(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.save() user.roles.add(Role.USER) user.save() to_email = serializer.data.get('email') from_email = settings.EMAIL_HOST_USER token = RefreshToken.for_user(user).access_token domain_name = get_current_site(request).domain relativeLink = reverse('email-verify') final_link = "http://localhost:3000/activate/" + str(token) subject = 'Activate your account' message = 'Hi, ' + user.first_name + ' ' + user.last_name + ' click on this link to activate your account.\n' + final_link send_mail(subject, message, from_email, [ to_email, ]) return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): """ Handles the POST request made to the `/accounts/` URL. This view will take the `data` property from the `request` object, deserialize it into a `User` object and store in the DB. Returns a 201 (successfully created) if the user is successfully created, otherwise returns a 400 (bad request) :param request: :return: """ serializer = UserSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) else: data = serializer.data # Create a new user using the username contained in the data dict user = User.objects.create(username=data["username"]) # User the set password method to create a hashed password # using the password provided in the data dict user.set_password(data["password"]) # Finally save the new user object user.save() return Response(data, status=status.HTTP_201_CREATED)
def create_user(request): """ { "email": "*****@*****.**", "password": "******", "gender": "m", "type": "i" } """ data = request.data data['emoji'], data['nickname'] = get_nickname() serializer = UserSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response( { "status": "success", "message": "회원가입에 성공하였습니다.", "data": { "nickname": data['nickname'], "emoji": data['emoji'] } }, status=status.HTTP_201_CREATED) return Response({ "status": "fail", "message": serializer.errors }, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): """ Handles the POST request made to the `/accounts/` URL. This view will take the `data` property from the `request` object, deserialize it into a `User` object and store in the DB. Returns a 201 (successfully created) if the user is successfully created, otherwise returns a 400 (bad request) """ serializer = UserSerializer(data=request.data) # Check to see if the data in the `request` is valid. # If the cannot be deserialized into a Todo object then # a bad request response will be returned. # Else, save the data and return the data and a successfully # created status if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) else: data = serializer.data # Create a new user using the `username` contained in # the `data` dict user = User.objects.create(username=data["username"]) # Use the `set_password` method to create a hashed password # using the password provided in the `data` dict user.set_password(data["password"]) # Finally, save the new `user` object user.save() return Response(data, status=status.HTTP_201_CREATED)
def update_user_keyword(request): user = request.user keyword1_list = Rating.objects.filter(user_id=user.id).values('keyword1').annotate(key_cnt=Count('keyword1')).order_by('-key_cnt') keyword2_list = Rating.objects.filter(user_id=user.id).values('keyword2').annotate(key_cnt=Count('keyword2')).order_by('-key_cnt') key_cnts = {} for keyword in keyword1_list: if keyword.get('keyword1') in key_cnts.keys(): key_cnts[keyword['keyword1']] += keyword['key_cnt'] else: key_cnts[keyword['keyword1']] = keyword['key_cnt'] for keyword in keyword2_list: if keyword.get('keyword2') in key_cnts.keys(): key_cnts[keyword['keyword2']] += keyword['key_cnt'] else: key_cnts[keyword['keyword2']] = keyword['key_cnt'] import collections sorted_cnts = sorted(key_cnts.items(), key=lambda kv: kv[1], reverse=True) sorted_key_cnts = collections.OrderedDict(sorted_cnts) sorted_key_cnts_keylist = list(sorted_key_cnts) keyword1 = sorted_key_cnts_keylist[0] keyword2 = sorted_key_cnts_keylist[1] serializer = UserSerializer(instance=user, data={'keyword1':keyword1, 'keyword2':keyword2}, partial=True) if serializer.is_valid(): serializer.save() return Response(status=200, data={'message': '평점 작성 성공'})
def post(self, request): data = request.data response_data = {} response_data["success"] = True if not 'email' in data: response_data["message"] = _("email is required ") response_data["success"] = False return Response(data=response_data, status=status.HTTP_400_BAD_REQUEST) existUser = self.getObjectOrNone(User, email=data["email"]) if existUser is not None: response_data["success"] = False response_data["message"] = _("Email already in use") return Response(data=response_data, status=status.HTTP_206_PARTIAL_CONTENT) serializer = UserSerializer(data=data, many=False) if not serializer.is_valid(): response_data["success"] = False response_data["message"] = self.returnSerializerErrors(serializer.errors) return Response(data=response_data, status=status.HTTP_400_BAD_REQUEST) created_user = serializer.save() response_data = ProfileSerializer(created_user, many=False).data return Response(data=response_data, status=status.HTTP_201_CREATED)
def post(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.save() if user: return Response(status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): data = request.data serializer = UserSerializer(data=data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=201) return Response(serializer.errors, status=400)
def post(self, request): """ Handles the POST request made to the '/accounts/' URL This view will take the 'data' property from the 'request' object, desrialize it into a 'User' object and store in the DB Returns a 201 (successfully created) if the user is successfully created. Otherwise returns a 400 (bad request) :param request: :return: """ serializer = UserSerializer(data=request.data) # Check to see if the data in the 'request' is valid # If they cannot be desrialized into a User object then # a bad request response will be returned # Else, save the data and return the data and a # sucessfully created status if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) else: data = serializer.data # Create a new user using the 'username' contained in # the 'data' dict user = User.objects.create(username=data["username"]) # Use the 'set password' method to create a hashed password # using the data provided in the 'data dict user.set_password(data['password']) # Finally, save the new 'user' object user.save() return Response(data, status=status.HTTP_201_CREATED)
def add_user_to_database(data): serializer = UserPaymentSerializer(data=data) if serializer.is_valid(): user = serializer.save() if user: user_data = {} user_phone = data.get('sender_phone') user_phone = format_phone_number(user_phone) user_password = "******" user_data['phone_number'] = user_phone user_data['balance'] = data.get('amount') user_data['password'] = user_password jibambe_user_serializer = UserSerializer(data=user_data) if jibambe_user_serializer.is_valid(): jibambe_user_serializer.save() response = {"status": "01", "description": "Accepted", "subscriber_message": "Welcome to Jibambe na Ma Movie. Your account details are " \ "Phone:{0} Password: {1}".format(user_phone, user_password)} return response, status.HTTP_200_OK else: return jibambe_user_serializer.errors, status.HTTP_400_BAD_REQUEST return serializer.errors, status.HTTP_400_BAD_REQUEST
def userDetailApi(request, *args, **kwargs): if request.method == 'GET': nim = kwargs['pk'] user = CustomUser.objects.filter(nim=nim) if user: serializer = UserSerializer(user[0]) return Response({ 'count': 1, 'results': [ {**serializer.data} ] }) else: return Response({ 'count': 0, 'results': [] }) if request.method == 'PUT': nim = kwargs['pk'] user = get_object_or_404(CustomUser, nim=nim) serializer = UpdateUserSerializer(user, data=request.data) if serializer.is_valid(): serializer.save() return Response( serializer.data, ) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) if request.method == 'DELETE': nim = kwargs['pk'] user = get_object_or_404(CustomUser, nim=nim) user.delete() return Response(status=status.HTTP_200_OK)
def put(self, request, pk, format=None): user = self.get_object(pk) serializer = UserSerializer(user, data=request.DATA) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): """ Handles the POST request made to the `/accounts/` URL. This view will take the `data` property from the `request` object, deserialize it into a `User` object and store in the DB. Returns a 201 (successfully created) if the user is successfully created, otherwise returns a 400 (bad request) """ serializer = UserSerializer(data=request.data) # Check to see if the data in the `request` is valid. # If the cannot be deserialized into a Todo object then # a bad request respose will be returned. # Else, save the data and return the data and a successfully # created status if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) else: data = serializer.data # Create a new user using the `username` contained in # the `data` dict user = User.objects.create(username=data["username"]) # Use the `set_password` method to create a hashed password # using the password provided in the `data` dict user.set_password(data["password"]) # Finally, save the new `user` object user.save() return Response(data, status=status.HTTP_201_CREATED)
def post(self, request): """ Handles the POST request made to the `/accounts/` URL. This view will take the `data` property from the `request` object, deserialize it into a `User` object and store in the DB. Returns a 201 (successfully created) if the user is successfully created, otherwise returns a 400 (bad request) :param request: :return: """ serializer = UserSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) else: data = serializer.data # Create a new user using the username contained in the data dict user = User.objects.create(username=data["username"]) # User the set password method to create a hashed password # using the password provided in the data dict user.set_password(data["password"]) # Finally save the new user object user.save() return Response(data, status=status.HTTP_201_CREATED)
def put(self, request, *args, **kwargs): serializer = UserSerializer(request.user, data=request.data) # user = self.get_object(pk) # serializer = UserSerializer(user, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
def post(self, request): serialized = UserSerializer(data=request.DATA) if serialized.is_valid(): user = User.objects.create_user(**request.DATA) data = {'token': Token.objects.get(user=user).key} return Response(data, status=status.HTTP_201_CREATED) else: return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): data = request.data serializer = UserSerializer(data=data) if serializer.is_valid(raise_exception=True): serializer.save() return Response("""Пользователь успешно зарегистрирован. Для активации аккаунта перейдите по ссылке, которую мы отправили вам на почту""", status=201)
def test_update_preferred_valid_name(self): data = {"first_name": "new_preferred"} serializer = UserSerializer(self.user, data=data, partial=True) self.assertTrue(serializer.is_valid()) serializer.save() self.assertEqual(self.user.preferred_name, "new_preferred") self.assertEqual(self.user.first_name, "First")
def post(self, request, format=None): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.save() user.set_password(request.data['password']) user.save() return Response(serializer.data, status=201) return Response(serializer.errors, status=400)
def register(request, format='json'): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.save() if user: api_key, key = APIKey.objects.create_key(name="remote-access-key") Token.objects.get_or_create(user=user) return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request, *args, **kwargs): serializer = UserSerializer(data=request.data) if serializer.is_valid(): serializer.save() tasks.message.delay('verify', recipient=request.data['email']) return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create_user(request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response({'message': Message.SUCCESS}, status=status.HTTP_201_CREATED) else: return Response({'message': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): serialized = UserSerializer(data=request.DATA) if serialized.is_valid(): user = User.objects.create_user(**request.DATA) data = {'token': Token.objects.get(user=user).key} return Response(data, status=status.HTTP_201_CREATED) else: return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def create_user(request): if request.method == 'POST': serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.save() if user: return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format='json'): serializer = UserSerializer(data=request.data, context={'request': request}) if serializer.is_valid(): user = serializer.save() if user: json = serializer.data return Response(json, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format='json'): serializer = UserSerializer(data=request.data) print('post -> data', request.data) if serializer.is_valid(): user = serializer.save() if user: return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format='json'): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.save() if user: token = Token.objects.create(user=user) json = serializer.data json['token'] = token.key return Response(json, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def register(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = User.objects.create_user(**serializer.validated_data) token = Token.create_token(user.id) data = { 'username': user.username, 'token': token } return Response(data, status=201) return Response(serializer.errors, status=400)
def setUp(self): self.url = reverse('auth') # User info self.username = '******' self.email = '*****@*****.**' self.password = '******' # make sure our example data is valid serializer = UserSerializer(data={'username': self.username, 'email': self.email, 'password': self.password}) if serializer.is_valid(): self.user = serializer.save() else: self.fail()
def setUp(self): # url self.user_list = 'api:user-list' self.user_detail = 'api:user-detail' # User info self.username = '******' self.email = '*****@*****.**' self.password = '******' # make sure our example data is valid serializer = UserSerializer(data={'username': self.username, 'email': self.email, 'password': self.password}) if serializer.is_valid(): self.user = serializer.save() else: self.fail()
def post(self, request): logger.info("UpdatePasswordView.post is called. User: {0}".format(request.user.log_guid)) # TODO: check if front end sends a json file or normal request data = request.data update_password_serializer = self.serializer_class(data=data) if update_password_serializer.is_valid(): password = update_password_serializer.validated_data['password'] account = authenticate(email=request.user.email, password=password) if account is not None: if account.is_active: new_password = update_password_serializer.validated_data['new_password'] try: # we use partial to avoid passing required fields into serializer serializer = UserSerializer(account, data={'password': new_password}, partial=True) if serializer.is_valid(): serializer.save() account = authenticate(email=request.user.email, password=new_password) login(request, account) logger.info(self.msgs['finish_success'].format(request.user.log_guid)) return Response({ 'status': _('Success'), 'message': self.msgs['update_pass_success']}, status=status.HTTP_200_OK) else: logger.error(self.errs['ser_not_valid'].format(data)) return Response({'status': _('Bad request'), 'message': serializer.errors}, status=status.HTTP_400_BAD_REQUEST) except Exception as e: logger.exception(self.errs['exception'].format(e.message)) return Response({'status': _('Bad request'), 'message': self.msgs['internal_server_error']}, status=status.HTTP_400_BAD_REQUEST) else: logger.error(self.errs['user_inactive'].format(request.user.log_guid)) return Response({'status': _('Unauthorized'), 'message': self.msgs['cannot_update_pass']}, status=status.HTTP_401_UNAUTHORIZED) else: logger.error(self.errs['combination_invalid']) return Response({ 'status': _('Unauthorized'), 'message': self.msgs['combination_invalid']}, status=status.HTTP_401_UNAUTHORIZED) else: logger.error(update_password_serializer.errors) return Response({'status': 'Bad request', 'message': self.msgs['password_mismatch'], 'errors': 'Validation error'}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format='json'): serializer = UserSerializer(data=request.data) if serializer.is_valid(): #print("Valid") user = serializer.save() if user: if request.data["isStudent"] == 1: new_student = Student(user=user, contact_no=request.data["contact_no"]) new_student.save() elif request.data["isStudent"] == 0: new_teacher = Teacher(user=user, contact_no=request.data["contact_no"]) new_teacher.save() else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) token = Token.objects.create(user=user) json = serializer.data json['token'] = token.key return Response(json, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def register(request): """ Endpoint for registration. Does not require any permissions, so that anyone can access it. """ USER_FIELDS = ['username', 'password', 'email', 'role'] serialized = UserSerializer(data=request.data) if serialized.is_valid(raise_exception=True): user_data = { field: data for (field, data) in request.data.items() if field in USER_FIELDS } user = User.objects.create_user( **user_data ) return Response( UserSerializer(instance=user, context={'request': request}).data, status=status.HTTP_201_CREATED, )
def setUp(self): self.token_list = 'api:token-list' self.token_detail = 'api:token-detail' # Clients cannot be created via view or serialzier self.name = 'reddit' self.api_url = 'https://oauth.reddit.com/api/v1/' self.authorize_url = 'https://www.reddit.com/api/v1/' self.token_url = 'https://www.reddit.com/api/v1/access_token/' self.client_id = 'some-client-id' self.client_secret = 'some-secret' self.redirect_uri = 'http://*****:*****@example.com' self.password = '******' # make sure our example data is valid serializer = UserSerializer(data={'username': self.username, 'email': self.email, 'password': self.password}) if serializer.is_valid(): self.user = serializer.save() else: self.fail()
def post(self, request): data = json.loads(request.body) guid = data.get('guid', None) logger.info("SetPasswordView.post is called. GUID: {0}".format(guid)) password_serializer = PasswordSerializer(data=data, partial=True) if not password_serializer.is_valid(): return Response({ 'status': _('Bad request'), 'message': self.msgs['password_mismatch'], 'errors': 'Validation error' }, status=status.HTTP_400_BAD_REQUEST) try: user_uid = UserUID.objects.get(guid=guid) except ObjectDoesNotExist: logger.exception(self.errs['GUID_invalid'].format(guid)) return Response({ 'status': _('Bad request'), 'message': self.msgs['activation_invalid'] }, status=status.HTTP_400_BAD_REQUEST) now_offset_aware = timezone.make_aware(datetime.datetime.utcnow(), timezone.get_current_timezone()) if user_uid.expiration_date < now_offset_aware: logger.error(self.errs['GUID_expired'].format(guid, user_uid.expiration_date, now_offset_aware)) return Response({ 'status': _('Bad request'), 'message': self.msgs['activation_invalid'] }, status=status.HTTP_400_BAD_REQUEST) try: account = User.objects.get(id=user_uid.user_id) except ObjectDoesNotExist: logger.exception(self.msgs['GUID_invalid'].format(guid)) return Response({ 'status': _('Fail'), 'message': self.msgs['internal_server_error'] }, status=status.HTTP_500_INTERNAL_SERVER_ERROR) if account is not None: se_data = dict() se_data['password'] = password_serializer.validated_data['new_password'] se_data['confirm_password'] = password_serializer.validated_data['confirm_password'] se_data['email'] = account.email se_data['username'] = account.username se_data['log_guid'] = account.log_guid try: with transaction.atomic(): serializer = UserSerializer(account, data=se_data) if serializer.is_valid(): serializer.save() # We need to mark the forgotpassword GUID as expired uid_data = dict() uid_data['guid'] = guid uid_data['user'] = user_uid.user_id uid_data['expiration_date'] = datetime.datetime.utcnow() uidSerializer = UserUIDSerializer(user_uid, data=uid_data) if uidSerializer.is_valid(): uidSerializer.save() logger.info(self.msgs['finish_success'].format(guid)) return Response({ 'status': _('Success'), 'message': self.msgs['update_pass_success'] }, status=status.HTTP_200_OK) else: logger.error(self.errs['ser_not_valid'].format(guid, user_uid.user_id, uid_data['expiration_date'])) return Response({ 'status': _('Fail'), 'message': self.msgs['internal_server_error'] }, status=status.HTTP_500_INTERNAL_SERVER_ERROR) else: logger.error(self.errs['server_error']) return Response({ 'status': _('Fail'), 'message': self.msgs['internal_server_error'] }, status=status.HTTP_500_INTERNAL_SERVER_ERROR) except Exception as e: logger.exception(self.errs['exception'].format(guid, e.message)) return Response({ 'status': _('Bad request'), 'message': self.msgs['internal_server_error'] }, status=status.HTTP_500_INTERNAL_SERVER_ERROR) else: logger.exception(self.errs['GUID_none'].format(guid)) return Response({ 'status': _('Bad request'), 'message': self.msgs['activation_invalid'] }, status=status.HTTP_400_BAD_REQUEST)