Esempio n. 1
0
 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)
Esempio n. 2
0
 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)
Esempio n. 3
0
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
Esempio n. 4
0
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)
Esempio n. 5
0
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)
Esempio n. 6
0
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': '평점 작성 성공'})
Esempio n. 7
0
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)
Esempio n. 8
0
 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)
Esempio n. 9
0
 def post(self, request):
     data = request.data
     serializer = UserSerializer(data=data)
     if serializer.is_valid(raise_exception=True):
         serializer.save()
         return Response("""Пользователь успешно зарегистрирован. 
         Для активации аккаунта перейдите по ссылке, которую мы отправили вам на почту""",
                         status=201)
Esempio n. 10
0
    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")
Esempio n. 11
0
    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)
Esempio n. 12
0
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)
Esempio n. 13
0
    def test_preferred_same_as_first(self):
        data = {"first_name": "First2"}
        serializer = UserSerializer(self.user_preferred_name,
                                    data=data,
                                    partial=True)

        self.assertTrue(serializer.is_valid())
        serializer.save()
        self.assertEqual(self.user_preferred_name.preferred_name, "")
        self.assertEqual(self.user_preferred_name.first_name, "First2")
Esempio n. 14
0
 def patch(request):
     user = request.user
     serializer = UserSerializer(user,
                                 data=request.data,
                                 context={'request': request},
                                 partial=True)
     if serializer.is_valid():
         serializer.save()
         return Response(serializer.data)
         # return JsonResponse(user, safe=False)
     return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
Esempio n. 15
0
 def post(self, request):
     data = request.data
     serializer = UserSerializer(data=data)
     if serializer.is_valid():
         # user validation success
         serializer.save()
         data = {"message": "User got Registered successfully"}
         return Response(data=data)
     else:
         # user validation failed
         status_code = status.HTTP_400_BAD_REQUEST
         return Response(serializer.errors, status=status_code)
Esempio n. 16
0
 def post(self, request, format=None):
     user_client_serializer = UserSerializer(data=request.data)
     #print(serializer)
     if user_client_serializer.is_valid():
         user_client_serializer.save()
         # user = user_client_serializer.create
         # print(user)
         data_dict = {
             "status": 201,
             "data": user_client_serializer.data,
             'id': user_client_serializer.data['id']
         }
         return Response(data_dict, status=status.HTTP_201_CREATED)
     return Response(user_client_serializer.errors,
                     status=status.HTTP_400_BAD_REQUEST)
Esempio n. 17
0
 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)
Esempio n. 18
0
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)
Esempio n. 19
0
    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)
Esempio n. 20
0
    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)
Esempio n. 21
0
 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)
Esempio n. 22
0
 def update(self, request, pk):
     """
     Actualiza el usuario con pk <pk> si existe.
     :param request: objeto de tipo HttpRequest
     :param pk: pk del usuario que queremos actualizar
     :return: 202 si OK o 400 con errores
     """
     user = get_object_or_404(User, pk=pk)
     self.check_object_permissions(request, user)
     serializer = UserSerializer(user, data=request.data)
     if serializer.is_valid():
         serializer.save()
         return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
     else:
         return Response(serializer.errors,
                         status=status.HTTP_400_BAD_REQUEST)
Esempio n. 23
0
    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)
Esempio n. 24
0
 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)
Esempio n. 25
0
def user_register(request, format=None):
    """
    register an account with username and password parameters
    """

    username = request.query_params.get('username', None)
    password = request.query_params.get('password', None)

    user = Users(Username=username, Password=password)
    serializer = UserSerializer(user)
    serializer = UserSerializer(data=serializer.data)

    if serializer.is_valid():
        serializer.save()
        return Response(serializer.data, status=status.HTTP_201_CREATED)
    print(serializer.errors)
    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
Esempio n. 26
0
def userListApi(request):
    if request.method == 'GET':
        pagination_class = api_settings.DEFAULT_PAGINATION_CLASS
        paginator = pagination_class()
        queryset = CustomUser.objects.filter(is_staff=False).order_by('nim')
        page = paginator.paginate_queryset(queryset, request)
        serializer = UserSerializer(page, many=True)

        return paginator.get_paginated_response(serializer.data)

    if request.method == 'POST':
        data = request.data
        serializer = RegisterSerializer(data=data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        else:
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
Esempio n. 27
0
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)
Esempio n. 28
0
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)
Esempio n. 29
0
    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)
Esempio n. 30
0
 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)
Esempio n. 31
0
 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)
Esempio n. 32
0
def sign_up(request, format='json'):
    """ 
    Creates the user. 
    """
    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(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)
Esempio n. 34
0
    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()
Esempio n. 35
0
    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, 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)
Esempio n. 37
0
    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()
Esempio n. 38
0
    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)