def test_refresh_jwt(self):
        """
        Test getting a refreshed token from original token works

        No date/time modifications are neccessary because it is assumed
        that this operation will take less than 300 seconds.
        """
        client = APIClient(enforce_csrf_checks=True)
        orig_token = self.get_token()
        orig_token_decoded = utils.jwt_decode_handler(orig_token)

        expected_orig_iat = timegm(datetime.utcnow().utctimetuple())

        # Make sure 'orig_iat' exists and is the current time (give some slack)
        orig_iat = orig_token_decoded['orig_iat']
        self.assertLessEqual(orig_iat - expected_orig_iat, 1)

        time.sleep(1)

        # Now try to get a refreshed token
        response = client.post('/auth-token-refresh/', {'token': orig_token},
                               format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        new_token = response.data['token']
        new_token_decoded = utils.jwt_decode_handler(new_token)

        # Make sure 'orig_iat' on the new token is same as original
        self.assertEquals(new_token_decoded['orig_iat'], orig_iat)
        self.assertGreater(new_token_decoded['exp'], orig_token_decoded['exp'])

    def test_refresh_jwt(self):
        """
        Test getting a refreshed token from original token works
        """
        client = APIClient(enforce_csrf_checks=True)

        with freeze_time('2015-01-01 00:00:01'):
            orig_token = self.get_token()
            orig_token_decoded = utils.jwt_decode_handler(orig_token)

            expected_orig_iat = timegm(datetime.utcnow().utctimetuple())

            # Make sure 'orig_iat' exists and is the current time (give some slack)
            orig_iat = orig_token_decoded['orig_iat']
            self.assertLessEqual(orig_iat - expected_orig_iat, 1)

            with freeze_time('2015-01-01 00:00:03'):

                # Now try to get a refreshed token
                response = client.post('/auth-token-refresh/', {'token': orig_token},
                                       format='json')
            self.assertEqual(response.status_code, status.HTTP_200_OK)

            new_token = response.data['token']
            new_token_decoded = utils.jwt_decode_handler(new_token)

        # Make sure 'orig_iat' on the new token is same as original
        self.assertEquals(new_token_decoded['orig_iat'], orig_iat)
        self.assertGreater(new_token_decoded['exp'], orig_token_decoded['exp'])

    def test_jwt_refresh(self):
        """
        This test verifies that an existing user can refresh their JWT token
        :return:
        """
        # NOTE: Only unexpired tokens can be refreshed.
        login_credentials = {
            'username': self.username,
            'password': self.password
        }
        response = self.api_client.post('/auth/api-token-auth/', login_credentials, format='json')
        jwt_token = response.data['token']

        decoded_payload = utils.jwt_decode_handler(jwt_token)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertIsNotNone(jwt_token)
        decoded_payload = utils.jwt_decode_handler(jwt_token)

        refresh_payload = {
            'token': jwt_token
        }
        response = self.api_client.post('/auth/api-token-refresh/', refresh_payload, format='json')
        new_jwt_token = response.data['token']
        new_decoded_payload = utils.jwt_decode_handler(jwt_token)
        self.assertEqual(decoded_payload['orig_iat'], new_decoded_payload['orig_iat'])
        self.assertEqual(decoded_payload['exp'], new_decoded_payload['exp'])

    def test_jwt_decode_verify_exp(self):
        api_settings.JWT_VERIFY_EXPIRATION = False

        payload = utils.jwt_payload_handler(self.user)
        payload['exp'] = 1
        token = utils.jwt_encode_handler(payload)
        utils.jwt_decode_handler(token)

        api_settings.JWT_VERIFY_EXPIRATION = True

    def authenticate(self, request):
        """
        Returns a two-tuple of `User` and token if a valid signature has been
        supplied using JWT-based authentication.  Otherwise returns `None`.
        """
        jwt_value = self.get_jwt_value(request)
        if jwt_value is None:
            raise exceptions.NotAuthenticated()

        try:
            payload = jwt_decode_handler(jwt_value)
        except jwt.ExpiredSignature:  # pragma: no cover
            msg = 'Signature has expired.'
            raise exceptions.AuthenticationFailed(msg)
        except jwt.DecodeError:  # pragma: no cover
            msg = 'Error decoding signature.'
            raise exceptions.AuthenticationFailed(msg)
        except jwt.InvalidTokenError:  # pragma: no cover
            raise exceptions.AuthenticationFailed()
        except Exception as ex:
            raise exceptions.AuthenticationFailed(ex.message)

        user = User(**payload)

        return user, jwt_value

    def test_login(self):
        """Test the login endpoint"""
        user = get_user_model().objects.create_user(
            username='testuser',
            email='[email protected]',
            password='password',
            )

        data = dict(
            username=user.username,
            email=user.email,
            password='password',
            )

        response = self.client.post(
            '/api/v1/auth/login',
            data=data,
            format='json',
            )

        self.assertEqual(response.status_code, status.HTTP_200_OK,
                         'Got error: {}'.format(response.content))

        decoded_payload = utils.jwt_decode_handler(response.data['token'])

        self.assertEqual(decoded_payload['username'], user.username)
        self.assertEqual(decoded_payload['email'], user.email)
        self.assertEqual(decoded_payload['user_id'], user.pk)

    def post(self, request):
        '''
        a known issue now...
        a segment fault happens if you login and then logout and login again..
        '''
        serializer = testSignin.serializer_class(data=request.DATA)

        if serializer.is_valid():

            payload = utils.jwt_decode_handler(serializer.object['token'])
            user = self.jwt.authenticate_credentials(payload)

            # below is a tric for authenticate..
            # due to the authentication in django -- it need username and password,
            # however, decode of jwt doesn't contain password.
            user.backend = 'django.contrib.auth.backends.ModelBackend'
            # user = authenticate(username=user, nopass=True)
            if user is not None:
                if user.is_active:
                    login(request, user)
                    return HttpResponseRedirect('/home/')
                else:
                    raise Exception('user not active')

            else:
                raise Exception('not valid user')

        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

def token_payload(token, user=None, request=None):
    decoded = jwt_decode_handler(token)
    return {
        'token': token,
        'orig_iat': decoded.get('orig_iat'),
        'user': ReferenceUserSerializer(user, context={'request': request}).data
    }

    def testuserJwtLogin(self):
        """Authenticate a test user, and prepare JWT token based authentification.

        POST user credentials to the JWT login url using the default
        :class:`django.test.TestCase.Client` client.

        Capture the JWT token from the request response,
        store it in :attr:`testuserdata['jwtToken']`,
        and setup the method :meth:`api_client()` of this instance
        to authenticate using this JWT token.

        Returns:
            The HTTP status code.
        """

        # https://docs.djangoproject.com/en/1.8/releases/1.8/:
        #   Passing a dotted path to reverse() and url
        #
        #   Reversing URLs by Python path is an expensive operation as it
        #   causes the path being reversed to be imported.
        #   This behavior has also resulted in a security issue.
        #   Use named URL patterns for reversing instead.
        #
        # See also:
        # https://docs.djangoproject.com/en/1.8/topics/auth/passwords/

        # url = reverse('rest_framework_jwt.views.obtain_jwt_token')
        url = reverse('jwt_token_auth')
        response = self.client.post(url, self.data, format='json')
        jwtToken = response.data['token']
        self.testuserdata['jwtToken'] = jwtToken
        self.testuserdata['decodedJwtToken'] = jwt_decode_handler(jwtToken)
        authHeader = 'JWT ' + self.testuserdata['jwtToken']
        self.api_client.credentials(HTTP_AUTHORIZATION=authHeader)
        return response.status_code

    def post(self, request, model, app_label, object_id, field_name, score, **kwargs):
        user = utils.jwt_decode_handler(request.auth)['user_id']

        user = CustomUser.objects.get(id=user)

        addRating = AddRatingFromModel()

        return addRating(request, model, app_label, object_id, field_name, score, user)

def grant(request):
    authKey = request.data.get('authKey')
    try:
        jwt_decode_handler(authKey)
        authenticated = True
    except:
        authenticated = False

    channels = request.data.get('channels')
    channels += [channel + '-pnpres' for channel in channels]
    channels = ','.join(channels)

    try:
        pubnub.grant(channel=channels, auth_key=authKey, read=True, write=authenticated, ttl=604800)
        return Response({'message': 'Granted!'})
    except:
        return Response({'message': 'Failed!'}, status=status.HTTP_401_UNAUTHORIZED)

    def test_create(self):
        serializer = JSONWebTokenSerializer(data=self.data)
        is_valid = serializer.is_valid()

        token = serializer.object['token']
        decoded_payload = utils.jwt_decode_handler(token)

        self.assertTrue(is_valid)
        self.assertEqual(decoded_payload['username'], self.username)

    def test_jwt_login_json(self):
        """
        Ensure JWT login view using JSON POST works.
        """
        client = APIClient(enforce_csrf_checks=True)

        response = client.post('/auth-token/', self.data, format='json')

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        decoded_payload = utils.jwt_decode_handler(response.data['token'])
        self.assertEqual(decoded_payload['user_id'], str(self.user.id))

    def test_jwt_login_form(self):
        """
        Ensure JWT login view using form POST works.
        """
        client = APIClient(enforce_csrf_checks=True)

        response = client.post("/auth-token/", self.data)

        decoded_payload = utils.jwt_decode_handler(response.data["token"])

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(decoded_payload["username"], self.username)

 def get(self, request, format=None, pk=None):
     if request.user.is_authenticated():
         user_id = request.user.pk
     else:
         try:
             token = request.META['HTTP_AUTHORIZATION'][3:]
             decode = jwt_decode_handler(token)
             user_id = decode['user_id']
         except KeyError:
             return Response({"detail": "Authorization Token not provided or user Not Authenticated"}, status=401)
     playlists = PlayLists.objects.filter(user__pk=user_id)
     serializer = PlaylistSerializer(playlists, many=True)
     return Response(serializer.data)

    def test_can_login_and_get_token(self):
        (http_status, response_json) = self._post(
            '/api-token-auth/',
            {'username': 'user_001',
             'password': 'correct_password'})

        assert_equal(200, http_status)
        assert_in('token', response_json)
        decoded_token = jwt_decode_handler(response_json['token'])
        assert_equal({
            'email': '',
            'exp': 1420156800,
            'user_id': 1,
            'username': 'user_001'},
            decoded_token)

    def test_jwt_auth(self):
        """
        This test verifies that an existing user can get an auth token using a JSON post
        :return:
        """
        login_credentials = {
            'username': self.username,
            'password': self.password
        }
        response = self.api_client.post('/auth/api-token-auth/', login_credentials, format='json')
        jwt_token = response.data['token']
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertIsNotNone(jwt_token)

        decoded_payload = utils.jwt_decode_handler(jwt_token)
        self.assertEqual(decoded_payload['username'], self.username)
        self.assertEqual(decoded_payload['email'], self.email)

    def test_jwt_login_with_expired_token(self):
        """
        Ensure JWT login view works even if expired token is provided
        """
        payload = utils.jwt_payload_handler(self.user)
        payload['exp'] = 1
        token = utils.jwt_encode_handler(payload)

        auth = 'JWT {0}'.format(token)
        client = APIClient(enforce_csrf_checks=True)
        response = client.post(
            '/auth-token/', self.data,
            HTTP_AUTHORIZATION=auth, format='json')

        decoded_payload = utils.jwt_decode_handler(response.data['token'])

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(decoded_payload['username'], self.username)

    def update(self, request, pk=None):
        if request.auth is not None:
            permission_classes = (IsAuthenticated,)
            authentication_classes = (JSONWebTokenAuthentication,)
            user_id = utils.jwt_decode_handler(request.auth)
            user_id = user_id["user_id"]
            if user_id == int(pk):

                customuser = CustomUser.objects.get(pk=pk)
                serializer = CustomUserSerializer(customuser, data=request.data, partial=True)
                if serializer.is_valid():
                    serializer.save()
                    return Response(serializer.data, status=status.HTTP_200_OK)
                else:
                    return Response(serializer.data, status=status.HTTP_400_BAD_REQUEST)
            else:
                return Response(status=status.HTTP_401_UNAUTHORIZED)
        else:
            return Response(status=status.HTTP_401_UNAUTHORIZED)

 def put(self, request, format=None, pk=None):
     if request.user.is_authenticated():
         user_id = request.user.pk
     else:
         try:
             token = request.META['HTTP_AUTHORIZATION'][3:]
             decode = jwt_decode_handler(token)
             user_id = decode['user_id']
         except KeyError:
             return Response({"detail": "Authorization Token not provided or user Not Authenticated"}, status=401)
     user = User.objects.get(pk=user_id);
     name = request.POST['name']
     description = request.POST['description']
     songs = request.POST.getlist('songs[]')
     songs = Song.objects.filter(pk__in=songs)
     playlist = PlayLists(user=user, name=name, description=description)
     playlist.save()
     playlist.songs.add(*songs)
     playlist.save()
     return Response({"inserted": playlist.pk}, status=200)