示例#1
0
    def test_view_list_and_retrieve_users(self, new_user_info,
                                          json_user_no_details):
        # Populate the database
        new_user = User.objects.create_user(
            first_name=new_user_info['first_name'],
            last_name=new_user_info['last_name'],
            email=new_user_info['email'],
            country=new_user_info['country'],
            mobile_number=new_user_info['mobile_number'],
            goal=new_user_info['goal'],
            password=new_user_info['password'])

        # Create another user via posting data
        post_view = UserViewSet.as_view({'post': 'create'})
        post_request = factory.post(USERS_URI,
                                    data=json.dumps(json_user_no_details),
                                    content_type='application/json')
        post_response = post_view(post_request)

        # Assert it was created
        assert post_response.status_code == 201
        assert post_response.data.get('id')
        assert post_response.data.get('email') == json_user_no_details['email']
        assert post_response.data.get('details')

        # FIX WHEN USERS GROUPS AND PERMISSIONS ADDED

        # # List all users and make sure there are 2, one populated by the db and one from posted data
        # get_view = UserViewSet.as_view({'get': 'list'})
        # get_request = factory.get(USERS_URI)
        # get_response = get_view(get_request)

        # assert get_response.status_code == 200
        # assert len(get_response.data) == 2
        # # Make sure they are users with id's and the same emails
        # assert get_response.data[0].get('id')
        # assert get_response.data[0].get('email') == new_user_info['email']
        # assert get_response.data[1].get('id')
        # assert get_response.data[1].get('email') == json_user_no_details['email']

        # Retrieve the user populated from teh database
        retrieve_view = UserViewSet.as_view({'get': 'retrieve'})
        retrieve_request = factory.get(USERS_URI + '/{}'.format(new_user.id),
                                       HTTP_AUTHORIZATION=get_jwt_header(
                                           new_user_info['email'],
                                           new_user_info['password']))
        retrieve_response = retrieve_view(retrieve_request, pk=new_user.id)

        assert retrieve_response.status_code == 200
        assert retrieve_response.data.get('id') == new_user.id
        assert retrieve_response.data.get('email') == new_user.email
示例#2
0
    def test_jwt_return_on_login(self, json_user_with_details):
        register_view = UserViewSet.as_view({'post': 'create'})
        register_request = factory.post(
            USERS_URI,
            data=json.dumps(json_user_with_details),
            content_type='application/json')
        register_response = register_view(register_request)

        assert register_response.status_code == 201
        assert register_response.data.get('id')

        login_view = LoginAPIView.as_view()
        login_data = {
            'email': json_user_with_details['email'],
            'password': json_user_with_details['password']
        }
        login_request = factory.post(LOGIN_URI,
                                     data=json.dumps(json_user_with_details),
                                     content_type='application/json')
        login_response = login_view(login_request)

        assert login_response.status_code == 200
        assert login_response.data.get(
            'user_id') == register_response.data.get('id')
        assert login_response.data.get('email') == register_response.data.get(
            'email')
        assert login_response.data.get('token')
示例#3
0
    def test_user_register_with_details(self, json_user_with_details):
        view = UserViewSet.as_view({'post': 'create'})
        request = factory.post(USERS_URI,
                               data=json.dumps(json_user_with_details),
                               content_type='application/json')
        response = view(request)

        json_user_first_name = json_user_with_details['first_name']
        json_user_last_name = json_user_with_details['last_name']
        json_user_email = json_user_with_details['email']
        json_user_country = json_user_with_details['details']['country']
        json_user_mobile_number = json_user_with_details['details'][
            'mobile_number']

        assert response.status_code == 201
        assert response.data.get('id')
        assert not response.data.get('password')
        assert response.data.get('email') == json_user_email
        assert response.data.get('first_name') == json_user_first_name
        assert response.data.get('last_name') == json_user_last_name
        assert response.data.get('username') == '{}{}-{}'.format(
            json_user_first_name, json_user_last_name, response.data.get('id'))
        assert response.data.get('details',
                                 {}).get('country') == json_user_country
        assert response.data.get(
            'details', {}).get('mobile_number') == json_user_mobile_number
示例#4
0
    def test_user_update_other_user(self, json_user_with_details,
                                    other_json_user_with_details):
        user = User.objects.create_user(
            first_name=json_user_with_details['first_name'],
            last_name=json_user_with_details['last_name'],
            email=json_user_with_details['email'],
            country=json_user_with_details['details']['country'],
            mobile_number=json_user_with_details['details']['mobile_number'],
            password=json_user_with_details['password'])

        other_user = User.objects.create_user(
            first_name=other_json_user_with_details['first_name'],
            last_name=other_json_user_with_details['last_name'],
            email=other_json_user_with_details['email'],
            country=other_json_user_with_details['details']['country'],
            mobile_number=other_json_user_with_details['details']
            ['mobile_number'],
            password=other_json_user_with_details['password'])

        view = UserViewSet.as_view({'put': 'update'})
        request = factory.put(USERS_URI,
                              data=json.dumps({
                                  'email': '*****@*****.**',
                                  'password': '******',
                                  'details': {}
                              }),
                              content_type='application/json',
                              HTTP_AUTHORIZATION=get_jwt_header(
                                  other_user.email))
        response = view(request, pk=user.id)

        assert response.status_code == 403
示例#5
0
    def test_view_bad_permissions(self, new_user_info):
        u1 = User.objects.create_user(
            first_name=new_user_info['first_name'],
            last_name=new_user_info['last_name'],
            email=new_user_info['email'],
            country=new_user_info['country'],
            mobile_number=new_user_info['mobile_number'],
            goal=new_user_info['goal'],
            password=new_user_info['password'])

        onui = other_new_user_info()
        u2 = User.objects.create_user(first_name=onui['first_name'],
                                      last_name=onui['last_name'],
                                      email=onui['email'],
                                      country=onui['country'],
                                      mobile_number=onui['mobile_number'],
                                      goal=onui['goal'],
                                      password=onui['password'])

        retrieve_view = UserViewSet.as_view({'get': 'retrieve'})
        retrieve_request = factory.get(USERS_URI + '/{}'.format(u1.id),
                                       HTTP_AUTHORIZATION=get_jwt_header(
                                           onui['email'], onui['password']))
        retrieve_response = retrieve_view(retrieve_request, pk=u1.id)

        assert retrieve_response.status_code == 403

        edited_user_info = new_user_info
        edited_user_info['first_name'] = 'Jack'

        put_view = UserViewSet.as_view({'put': 'update'})
        put_request = factory.put(USERS_URI + '/{}'.format(u1.id),
                                  data=json.dumps(edited_user_info),
                                  content_type='application/json',
                                  HTTP_AUTHORIZATION=get_jwt_header(
                                      onui['email'], onui['password']))
        put_response = put_view(put_request, pk=u1.id)

        assert put_response.status_code == 403

        delete_view = UserViewSet.as_view({'delete': 'destroy'})
        delete_request = factory.get(USERS_URI + '/{}'.format(u1.id),
                                     HTTP_AUTHORIZATION=get_jwt_header(
                                         onui['email'], onui['password']))
        delete_response = delete_view(delete_request, pk=u1.id)

        assert delete_response.status_code == 405
示例#6
0
 def test_destroy_user_with_unauthorized_user(self):
     request = self.factory.delete(self.url)
     force_authenticate(request, user=self.user)
     view = UserViewSet.as_view({'delete': 'destroy'})
     response = view(request, pk=self.users[0].id)
     users_count = len(User.objects.all())
     self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
     self.assertEqual(users_count, 3)
示例#7
0
    def test_user_get_other_user(self, new_user, other_user):
        view = UserViewSet.as_view({'get': 'retrieve'})
        request = factory.get(USERS_URI,
                              HTTP_AUTHORIZATION=get_jwt_header(
                                  new_user.email))
        response = view(request, pk=other_user.id)

        assert response.status_code == 403
示例#8
0
 def test_destroy_user_with_admin_user(self):
     request = self.factory.delete(self.url)
     force_authenticate(request, user=self.admin_user)
     view = UserViewSet.as_view({'delete': 'destroy'})
     response = view(request, pk=self.users[0].id)
     users_count = len(User.objects.all())
     self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
     self.assertEqual(users_count, 2)
示例#9
0
 def test_edit_user_with_admin_user(self):
     phone_before = self.user.profile.phone
     request = self.factory.patch(self.url, self.user_data, format='json')
     force_authenticate(request, user=self.admin_user)
     view = UserViewSet.as_view({'patch': 'partial_update'})
     response = view(request, pk=self.user.id)
     phone_after = User.objects.filter(id=self.user.id)[0].profile.phone
     self.assertEqual(response.status_code, status.HTTP_200_OK)
     self.assertNotEqual(phone_before, phone_after)
示例#10
0
    def test_user_get_self(self, new_user):
        view = UserViewSet.as_view({'get': 'retrieve'})
        request = factory.get(USERS_URI,
                              HTTP_AUTHORIZATION=get_jwt_header(
                                  new_user.email))
        response = view(request, pk=new_user.id)

        assert response.status_code == 200
        assert response.data.get('id') == new_user.id
        assert response.data.get('email') == new_user.email
        assert response.data.get('username') == new_user.username
示例#11
0
    def test_user_get_all_users(self, new_user):
        user_list_view = UserViewSet.as_view({'get': 'list'})

        unauthenticated_request = factory.get(USERS_URI)
        unauthenticated_response = user_list_view(unauthenticated_request)
        assert unauthenticated_response.status_code == 401

        authenticated_request = factory.get(USERS_URI,
                                            HTTP_AUTHORIZATION=get_jwt_header(
                                                new_user.email))
        authenticated_response = user_list_view(unauthenticated_request)
        assert authenticated_response.status_code == 401
示例#12
0
    def test_user_register_without_details(self, json_user_with_details):
        json_user_with_details['details']['country'] = None
        json_user_with_details['details']['mobile_number'] = None

        view = UserViewSet.as_view({'post': 'create'})
        request = factory.post(USERS_URI,
                               data=json.dumps(json_user_with_details),
                               content_type='application/json')
        response = view(request)

        assert response.status_code == 201
        assert response.data.get('id')
        assert response.data.get('details')
        assert response.data.get('details',
                                 {}).get('user_id') == response.data.get('id')
        assert not response.data.get('details', {}).get('country')
        assert not response.data.get('details', {}).get('mobile_number')
示例#13
0
    def test_user_update_self(self, json_user_with_details,
                              other_json_user_with_details):
        user = User.objects.create_user(
            first_name=json_user_with_details['first_name'],
            last_name=json_user_with_details['last_name'],
            email=json_user_with_details['email'],
            country=json_user_with_details['details']['country'],
            mobile_number=json_user_with_details['details']['mobile_number'],
            password=json_user_with_details['password'])

        assert user.id
        assert user.email == json_user_with_details['email']
        assert user.username == '{}{}-{}'.format(
            json_user_with_details['first_name'],
            json_user_with_details['last_name'], user.id)

        other_json_user_with_details['password'] = json_user_with_details[
            'password']

        view = UserViewSet.as_view({'put': 'update'})
        request = factory.put(USERS_URI,
                              data=json.dumps(other_json_user_with_details),
                              content_type='application/json',
                              HTTP_AUTHORIZATION=get_jwt_header(user.email))
        response = view(request, pk=user.id)

        assert response.status_code == 200
        assert response.data.get('id') == user.id
        assert User.objects.get(
            id=response.data.get('id')) == User.objects.get(id=user.id)
        assert response.data.get(
            'first_name') == other_json_user_with_details['first_name']
        assert response.data.get(
            'last_name') == other_json_user_with_details['last_name']
        assert response.data.get(
            'email') == other_json_user_with_details['email']
        assert response.data.get('username') == '{}{}-{}'.format(
            other_json_user_with_details['first_name'],
            other_json_user_with_details['last_name'], response.data.get('id'))
        assert response.data.get('details', {}).get(
            'country') == other_json_user_with_details['details']['country']
        assert response.data.get(
            'details',
            {}).get('mobile_number') == other_json_user_with_details[
                'details']['mobile_number']
示例#14
0
文件: tests.py 项目: OHopiak/WebShop
    def test_create(self):
        data = self.data
        username = data.get('username')
        password = data.get('password')

        request = APIRequestFactory().post('', data)
        force_authenticate(request, user=self.superuser)
        user_create = UserViewSet.as_view({'post': 'create'})
        response = user_create(request)
        self.assertEqual(response.status_code, 201,
                         'failed to create the user')

        new_user = User.objects.filter(pk=response.data.get('id')).first()
        self.assertIsNotNone(new_user, 'no user created')
        self.assertEqual(new_user.username, username,
                         'username is not the same')
        self.assertTrue(check_password(password, new_user.password),
                        'authentication failed')
示例#15
0
    def test_get_user_by_admin(self):
        """admin user(s) can get a complete list of users"""
        # prepare user test data
        administrator = UserFactory(email="*****@*****.**",
                                    nickname="tester",
                                    is_active=True,
                                    is_admin=True)

        dummy_user = UserFactory()
        dummy_user = UserFactory()
        dummy_user = UserFactory()

        # ready for the request
        factory = APIRequestFactory()

        # https://www.django-rest-framework.org/api-guide/routers/#simplerouter
        user_list = UserViewSet.as_view({'get': 'list'})

        url = "".join([reverse('users-list')])
        request = factory.get(url)
        force_authenticate(request, user=administrator)
        response = user_list(request)
        response_data = response.data

        print(response_data)
        assert response.status_code == 200, "HTTP status code 200"
        assert response_data[
            'count'] == 4, "whole user data including dummy users"

        # test fields must exist
        assert 'email' in response_data['results'][0].keys(
        ), "email field test."
        assert 'nickname' in response_data['results'][0].keys(
        ), "nickname field test."

        # test fields key check
        assert 'date_joined' not in response_data['results'][0].keys(
        ), "date_joined field test."
        assert 'is_active' not in response_data['results'][0].keys(
        ), "is_active field test."
        assert 'is_admin' not in response_data['results'][0].keys(
        ), "is_admin field test."
示例#16
0
    def test_view_delete_user(self, new_user_info):
        new_user = User.objects.create_user(
            first_name=new_user_info['first_name'],
            last_name=new_user_info['last_name'],
            email=new_user_info['email'],
            country=new_user_info['country'],
            mobile_number=new_user_info['mobile_number'],
            goal=new_user_info['goal'],
            password=new_user_info['password'])

        # Delete the user with new_user.id
        view = UserViewSet.as_view({'delete': 'destroy'})
        request = factory.delete(USERS_URI + '/{}'.format(new_user.id),
                                 HTTP_AUTHORIZATION=get_jwt_header(
                                     new_user_info['email'],
                                     new_user_info['password']))
        response = view(request, pk=new_user.id)

        assert response.status_code == 204
        assert User.objects.filter(id=new_user.id).count() == 0
        assert Details.objects.filter(user=new_user).count() == 0
示例#17
0
 def test_retrieve_logged_in_user_information(self):
     request = self.factory.get(self.url)
     force_authenticate(request, user=self.user)
     view = UserViewSet.as_view({'get': 'retrieve'})
     response = view(request, pk=self.user.id)
     self.assertEqual(response.status_code, status.HTTP_200_OK)
示例#18
0
 def test_retrieve_user_with_non_admin_user(self):
     request = self.factory.get(self.url)
     force_authenticate(request, user=self.user)
     view = UserViewSet.as_view({'get': 'retrieve'})
     response = view(request, pk=self.users[0].id)
     self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
示例#19
0
 def test_get_users_with_authenticated_adim_user(self):
     request = self.factory.get(self.url)
     force_authenticate(request, user=self.admin_user)
     view = UserViewSet.as_view({'get': 'list'})
     response = view(request)
     self.assertEqual(response.status_code, status.HTTP_200_OK)
示例#20
0
 def test_get_users_with_unauthorized_user(self):
     request = self.factory.get(self.url)
     force_authenticate(request, user=self.user)
     view = UserViewSet.as_view({'get': 'list'})
     response = view(request)
     self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
示例#21
0
 def test_get_users_without_authenticated_user(self):
     request = self.factory.get(self.url)
     view = UserViewSet.as_view({'get': 'list'})
     response = view(request)
     self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
示例#22
0
    def test_user_view(self):
        view = UserViewSet.as_view({'get': 'list'})
        request = factory.get(USERS_URI)
        response = view(request)

        assert response.status_code == 401
示例#23
0
    url(r'^me/$', Me.as_view({'get': 'retrieve'}), name="me"),
    url(r'^me/favorites$',
        MyFavorites.as_view({'get': 'retrieve'}),
        name="myFavorties"),
    url(r'^me/motions$',
        MyMotions.as_view({'get': 'retrieve'}),
        name="myMotions"),
    url(r'^me/votes$', MyVotes.as_view({'get': 'retrieve'}), name="myVotes"),
    url(r'^(?P<user_pk>\d+)/favorites/$',
        UserFavoriteMotionsViewSet.as_view({
            'get': 'retrieve',
            'post': 'create',
            'delete': 'destroy'
        }),
        name="user_favorites"),
    url(
        r'^oauth/',
        include(('oauth2_provider.urls', 'oauth'),
                namespace='oauth2_provider')),
    url(r'^activate/(?P<uidb64>[0-9A-Za-z_\-]+)/(?P<token>[0-9A-Za-z]{1,13}-[0-9A-Za-z]{1,20})/$',
        UserViewSet.as_view({'get': 'activate'}),
        name='activate'),
    url(r'^forgot-password/$',
        UserViewSet.as_view({'post': 'forgot'}),
        name='activate'),
    url(r'^change-password/(?P<uidb64>[0-9A-Za-z_\-]+)/(?P<token>[0-9A-Za-z]{1,13}-[0-9A-Za-z]{1,20})/$',
        UserViewSet.as_view({'put': 'changePassword'}),
        name='activate'),
]

urlpatterns += router.urls
示例#24
0
from django.urls import path
from rest_framework.urlpatterns import format_suffix_patterns

from users.views import UserListViewSet, UserViewSet, activate_user

user_list = UserListViewSet.as_view({
    'get': 'list',
    'post': 'create',
})

user_detail = UserViewSet.as_view({
    'get': 'retrieve',
    'put': 'update',
    'delete': 'destroy'
})

urlpatterns = format_suffix_patterns([
    path('users/', user_list, name='user-list'),
    path('user/<int:id>', user_detail, name='user-detail'),
    path('activate_email/<int:id>/<str:activate>', activate_user, name='user-activate'),
])
示例#25
0
    def test_view_create_user_with_details(
            self, json_user_with_details,
            json_user_with_details_with_one_null_detail, json_user_no_details):
        # Create user with json details
        view = UserViewSet.as_view({'post': 'create'})
        request = factory.post(USERS_URI,
                               data=json.dumps(json_user_with_details),
                               content_type='application/json')
        response = view(request)

        # Check if all the attributes match and if password doesn't show
        assert response.status_code == 201
        assert response.data.get('id')
        assert not response.data.get('password')
        assert response.data.get(
            'first_name') == json_user_with_details['first_name']
        assert response.data.get(
            'last_name') == json_user_with_details['last_name']
        assert response.data.get('email') == json_user_with_details['email']
        assert response.data.get(
            'first_name') == json_user_with_details['first_name']

        instances = User.objects.filter(
            first_name=json_user_with_details['first_name'],
            last_name=json_user_with_details['last_name']).count()

        # Check if username is correct
        if instances != 1:
            assert response.data.get('username') == '{}{}-{}'.format(
                json_user_with_details['first_name'],
                json_user_with_details['last_name'], instances)
        else:
            assert response.data.get('username') == '{}{}'.format(
                json_user_with_details['first_name'],
                json_user_with_details['last_name'])

        # Check details
        assert response.data.get(
            'details',
            {}).get('country') == json_user_with_details['details']['country']
        assert response.data.get(
            'details',
            {}).get('goal') == json_user_with_details['details']['goal']
        assert response.data.get(
            'details',
            {}).get('mobile_number'
                    ) == json_user_with_details['details']['mobile_number']

        # Create another user with one detail as null
        request = factory.post(
            USERS_URI,
            data=json.dumps(json_user_with_details_with_one_null_detail),
            content_type='application/json')
        response = view(request)

        # Assert new user exists but it goal is empty while other details are the same
        assert response.status_code == 201
        assert response.data.get('id')
        assert not response.data.get('details', {}).get('goal')
        assert response.data.get(
            'details',
            {}).get('country') == json_user_with_details_with_one_null_detail[
                'details']['country']
        assert response.data.get('details', {}).get(
            'mobile_number') == json_user_with_details_with_one_null_detail[
                'details']['mobile_number']

        # Create another user with no details
        request = factory.post(USERS_URI,
                               data=json.dumps(json_user_no_details),
                               content_type='application/json')
        response = view(request)

        # Assert it exists and has no details
        assert response.status_code == 201
        assert response.data.get('id')
        assert response.data.get('details')
示例#26
0
    def test_view_update_user(self, new_user_info, json_user_with_details,
                              json_user_no_details):
        # Populate the database
        new_user = User.objects.create_user(
            first_name=new_user_info['first_name'],
            last_name=new_user_info['last_name'],
            email=new_user_info['email'],
            country=new_user_info['country'],
            mobile_number=new_user_info['mobile_number'],
            goal=new_user_info['goal'],
            password=new_user_info['password'])

        user_password = new_user_info['password']

        # Assert user was created with same fields
        assert new_user.id
        assert new_user.first_name == new_user_info['first_name']
        assert new_user.last_name == new_user_info['last_name']
        assert new_user.email == new_user_info['email']
        assert new_user.password != user_password
        assert new_user.details.country == new_user_info['country']
        assert new_user.details.mobile_number == new_user_info['mobile_number']
        assert new_user.details.goal == new_user_info['goal']

        # Update the user with new_user.id
        view = UserViewSet.as_view({'put': 'update'})
        request = factory.put(USERS_URI + '/{}'.format(new_user.id),
                              data=json.dumps(json_user_with_details),
                              content_type='application/json',
                              HTTP_AUTHORIZATION=get_jwt_header(
                                  new_user_info['email'], user_password))
        response = view(request, pk=new_user.id)

        # Get User with the same new_user.id
        edited_user = User.objects.get(id=new_user.id)

        # Assert response is the same as the fixture value which is also
        # the same with the newly created and edited user
        assert response.data.get('id') == edited_user.id
        assert response.data.get('first_name') == json_user_with_details[
            'first_name'] == edited_user.first_name
        assert response.data.get('last_name') == json_user_with_details[
            'last_name'] == edited_user.last_name
        assert response.data.get(
            'email') == json_user_with_details['email'] == edited_user.email
        assert response.data.get(
            'details', {}).get('country') == json_user_with_details['details'][
                'country'] == edited_user.details.country
        assert response.data.get(
            'details',
            {}).get('mobile_number') == json_user_with_details['details'][
                'mobile_number'] == edited_user.details.mobile_number
        assert response.data.get(
            'details', {}).get('goal') == json_user_with_details['details'][
                'goal'] == edited_user.details.goal

        # Edit the same user again but this time removing the details
        view = UserViewSet.as_view({'put': 'update'})
        request = factory.put(USERS_URI + '/{}'.format(new_user.id),
                              data=json.dumps(json_user_no_details),
                              content_type='application/json',
                              HTTP_AUTHORIZATION=get_jwt_header(
                                  json_user_with_details['email'],
                                  user_password))
        response = view(request, pk=new_user.id)

        edited_user = User.objects.get(id=new_user.id)

        # Assert response is the same as the fixture value which is also
        # the same with the newly created and edited user but having no details
        assert response.data.get('id') == edited_user.id
        assert response.data.get('first_name') == json_user_no_details[
            'first_name'] == edited_user.first_name
        assert response.data.get('last_name') == json_user_no_details[
            'last_name'] == edited_user.last_name
        assert response.data.get(
            'email') == json_user_no_details['email'] == edited_user.email
        assert response.data.get('details')
        assert not response.data.get('details', {}).get('country')
        assert not response.data.get('details', {}).get('goal')
        assert not response.data.get('details', {}).get('mobile_number')
示例#27
0
from django.urls import path
# from rest_framework_jwt.views import obtain_jwt_token
from users.views import RegisterViewSet, ProfileViewSet, UserViewSet
from rest_framework import routers
from rest_framework_jwt.views import obtain_jwt_token

urlpatterns = [
    path('login/', obtain_jwt_token),
    path('profile/',
         ProfileViewSet.as_view({
             'get': 'retrieve',
             'put': 'update'
         }),
         name='profile-detail'),
    path('delete/',
         UserViewSet.as_view({'delete': 'destroy'}),
         name='delete-user'),
]
router = routers.DefaultRouter()
router.register('register', RegisterViewSet, base_name='users')
urlpatterns += router.urls
示例#28
0
from django.urls import path, include

from rest_framework.routers import DefaultRouter
from rest_framework_simplejwt.views import (
    TokenRefreshView,
    TokenVerifyView
)

from users.views import UserViewSet, CustomTokenObtainViewSet

router = DefaultRouter()
router.register('', UserViewSet, basename='users')

token_patterns = [
    path('', CustomTokenObtainViewSet.as_view(), name='token_obtain_pair'),
    path('refresh/', TokenRefreshView.as_view(), name='token_refresh'),
    path('verify/', TokenVerifyView.as_view(), name='token_verify'),
]

urlpatterns = [
    path('analytics/', UserViewSet.as_view({'get': 'analytics'})),
    path('token/', include(token_patterns)),
    path(route='api-auth/', view=include('rest_framework.urls', namespace='rest_framework')),
]
urlpatterns += router.urls
示例#29
0
from rest_framework import renderers

status_list = StatusViewSet.as_view({
    'get': 'list',
    'post': 'create'
})

status_detail = StatusViewSet.as_view({
    'get': 'retrieve',
    'put': 'update',
    'patch': 'partial_update',
    'delete': 'destroy'
})

user_list = UserViewSet.as_view({
    'get': 'list',
    'post': 'create'
})

user_detail = UserViewSet.as_view({
    'get': 'retrieve',
    'put': 'update',
    'patch': 'partial_update'
})

cur_user = CurUser.as_view({
    'get': 'retrieve'
})


urlpatterns = format_suffix_patterns([
    url(r'^api/$', api_root),
示例#30
0
from django.conf.urls import url, include
from rest_framework.routers import DefaultRouter
from users import views
from users.views import UserViewSet



# Create a router and register our viewsets with it.
router = DefaultRouter()
router.register(r'users', views.UserViewSet, base_name="user")

user_list = UserViewSet.as_view({
    'get': 'list'
})
user_detail = UserViewSet.as_view({
    'get': 'retrieve'
})

urlpatterns = [
    url(r'^register_verification/', views.register_verification, name='register_verification'),
    url(r'^register/', views.register, name='register'),
    url(r'^login/', views.login, name='login'),
    url(r'^logout/$', views.logout, name='logout'),
    url(r'^register_login_success/', views.register_login_success, name='register_login_success'),
    url(r'^my_info/$', views.my_info, name='my_info'),
    url(r'^update_user_info/$', views.update_user_info, name='update_user_info'),
    url(r'^headimg_setting/$', views.headimg_setting, name='headimg_setting'),

    #url(r'^permission/$', views.show_permission, name='show_permission'),
    #url(r'^(?P<user_id>[0-9]+)/follow/$', views.follow, name='follow'),
    #url(r'^(?P<user_id>[0-9]+)/unfollow/$', views.unfollow, name='unfollow'),
示例#31
0
# -*- coding: utf-8 -*-
from django.conf.urls import url, include

from utils.func import SelfRouter, SimpleRouter
from users.views import (UserViewSet, forget_password, user_login, check_user,
                         LogoutView, UploadAvatarView, UploadImageView,
                         send_code, google_login)
from users.vertify_backend import VerifyViewSet

self_router = SelfRouter()
router = SimpleRouter()
router.register('auth_verify', VerifyViewSet, base_name='auth_verify')
self_router.register('', UserViewSet, base_name='users')

urlpatterns = [
    url(r'^login/?$', user_login, name='login'),
    url(r'^google_login/?$', google_login, name='google_login'),
    url(r'^check_user/?$', check_user, name='check_user'),
    url(r'^send_code/?$', send_code, name='send_code'),
    url(r'^forget_password/?$', forget_password, name='forget_password'),
    url(r'^upload_avatar/?$', UploadAvatarView.as_view(),
        name='upload_avatar'),
    url(r'^upload_image/?$', UploadImageView.as_view(), name='upload_image'),
    url(r'^logout/?$', LogoutView.as_view(), name='logout'),
    url(r'^reset_password/?$', UserViewSet.as_view({'put': 'reset_password'})),
    url(r'^help_center/?$', UserViewSet.as_view({'get': 'help_center'})),
    url(r'^', include(self_router.urls)),
    url(r'^', include(router.urls)),
]