예제 #1
0
    def form_valid(self, form):

        role = form.cleaned_data['role']

        if role == 'user':
            if self.user_role:
                self.user_role.delete()

        else:

            if not self.user_role:
                self.user_role = AppUserRole(
                    app=self.request.app,
                    user=self.user,
                )

            self.user_role.role = form.cleaned_data['role']
            self.user_role.save()

        context = self.get_context_data(**self.kwargs)
        context['success'] = True
        context['new_role'] = role
        context['form'] = form

        return self.render_to_response(context)
예제 #2
0
class ManageAppUserRole(AdminOnlyMixin, FormView):

    template_name = 'app_admin/manage_app_user_role.html'
    form_class = AppUserRoleForm

    @method_decorator(ajax_required)
    def dispatch(self, request, *args, **kwargs):
        self.user = User.objects.get(pk=kwargs['user_id'])
        self.user_role = AppUserRole.objects.filter(app=self.request.app,
                                                    user=self.user).first()
        return super().dispatch(request, *args, **kwargs)

    def get_initial(self):
        initial = super().get_initial()
        if self.user_role:
            initial['role'] = self.user_role.role
        else:
            initial['role'] = 'user'
        return initial

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['app_user'] = self.user
        return context

    def form_valid(self, form):

        role = form.cleaned_data['role']

        if role == 'user':
            if self.user_role:
                self.user_role.delete()

        else:

            if not self.user_role:
                self.user_role = AppUserRole(
                    app=self.request.app,
                    user=self.user,
                )

            self.user_role.role = form.cleaned_data['role']
            self.user_role.save()

        context = self.get_context_data(**self.kwargs)
        context['success'] = True
        context['new_role'] = role
        context['form'] = form

        return self.render_to_response(context)
    def setUp(self):
        super().setUp()
        self.factory = RequestFactory()

        self.user = self.create_user()

        self.role = AppUserRole(
            app=self.app,
            user=self.user,
            role='admin',
        )

        self.superuser = self.create_superuser()

        self.role.save()
    def setUp(self):
        super().setUp()

        self.user = self.create_user()

        self.role = AppUserRole(
            app=self.app,
            user=self.user,
            role='admin',
        )

        self.role.save()

        self.superuser = self.create_superuser()

        self.client.login(username=self.test_superuser_username,
                          password=self.test_password)
class TestSearchAppUser(WithApp, WithUser, TestCase):
    def setUp(self):
        super().setUp()

        self.user = self.create_user()

        self.role = AppUserRole(
            app=self.app,
            user=self.user,
            role='admin',
        )

        self.role.save()

        self.superuser = self.create_superuser()

        self.client.login(username=self.test_superuser_username,
                          password=self.test_password)

    def test_get(self):

        view_kwargs = {
            'app_uid': self.app.uid,
        }

        get_data = {
            'searchtext': 'test',
        }

        response = self.client.get(reverse('appadmin:search_app_user',
                                           kwargs=view_kwargs), {},
                                   HTTP_X_REQUESTED_WITH='XMLHttpRequest')

        self.assertEqual(response.status_code, 200)
        self.assertEqual(json.loads(response.content), [])

        response = self.client.get(reverse('appadmin:search_app_user',
                                           kwargs=view_kwargs),
                                   get_data,
                                   HTTP_X_REQUESTED_WITH='XMLHttpRequest')

        self.assertEqual(response.status_code, 200)

        content = json.loads(response.content)
        self.assertEqual(content[0]['name'], self.user.username)
예제 #6
0
    def test_save(self):

        user = self.create_user()

        for role_tuple in APP_USER_ROLES:
            role = role_tuple[0]

            user_role = AppUserRole(
                app=self.app,
                user=user,
                role=role,
            )

            user_role.save()

            user_role = AppUserRole.objects.get(user=user, app=self.app)
            self.assertEqual(user_role.role, role)

            user_role.delete()
class TestManageAppUserRole(WithUser, WithApp, TestCase):
    def setUp(self):
        super().setUp()
        self.factory = RequestFactory()

        self.user = self.create_user()

        self.role = AppUserRole(
            app=self.app,
            user=self.user,
            role='admin',
        )

        self.role.save()

        self.superuser = self.create_superuser()

        self.client.login(username=self.test_superuser_username,
                          password=self.test_password)

    def get_view(self):
        url_kwargs = {
            'app_uid': self.app.uid,
            'user_id': self.user.id,
        }
        request = self.factory.get(
            reverse('appadmin:manage_app_user_role', kwargs=url_kwargs))
        request.user = self.user
        request.app = self.app
        request.session = self.client.session
        request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'

        view = ManageAppUserRole()
        view.request = request
        view.kwargs = url_kwargs

        return view

    def test_dispatch(self):

        url_kwargs = {
            'app_uid': self.app.uid,
            'user_id': self.user.id,
        }
        request = self.factory.get(
            reverse('appadmin:manage_app_user_role', kwargs=url_kwargs))
        request.user = self.user
        request.app = self.app
        request.session = self.client.session
        request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'

        view = ManageAppUserRole()
        view.request = request

        response = view.dispatch(request, **url_kwargs)

        self.assertEqual(response.status_code, 200)
        self.assertEqual(view.user, self.user)
        self.assertEqual(view.user_role, self.role)

    def test_get_initial(self):

        view = self.get_view()

        view.user = self.user
        view.user_role = self.role
        initial = view.get_initial()

        self.assertEqual(initial['role'], self.role.role)

        view.user_role = None
        initial = view.get_initial()

        self.assertEqual(initial['role'], 'user')

    def test_get_context_data(self):

        view = self.get_view()

        view.user = self.user
        view.user_role = self.role

        context = view.get_context_data(**{})

        self.assertEqual(context['app_user'], self.user)

    def test_form_valid(self):

        view = self.get_view()

        view.user = self.user
        view.user_role = self.role

        post_data = {
            'role': 'expert',
        }

        form = view.form_class(post_data)
        self.assertTrue(form.is_valid())

        response = view.form_valid(form)
        self.assertEqual(response.status_code, 200)

        self.role.refresh_from_db()
        self.assertEqual(self.role.role, 'expert')
        self.assertEqual(response.context_data['new_role'], 'expert')
        self.assertEqual(response.context_data['success'], True)

    def test_get(self):

        view_kwargs = {
            'app_uid': self.app.uid,
            'user_id': self.user.id,
        }

        response = self.client.get(reverse('appadmin:manage_app_user_role',
                                           kwargs=view_kwargs), {},
                                   HTTP_X_REQUESTED_WITH='XMLHttpRequest')

        self.assertEqual(response.status_code, 200)

    def test_post(self):

        view_kwargs = {
            'app_uid': self.app.uid,
            'user_id': self.user.id,
        }

        self.assertEqual(self.role.role, 'admin')

        post_data = {'role': 'expert'}
        response = self.client.post(reverse('appadmin:manage_app_user_role',
                                            kwargs=view_kwargs),
                                    post_data,
                                    HTTP_X_REQUESTED_WITH='XMLHttpRequest')

        self.role.refresh_from_db()
        self.assertEqual(self.role.role, 'expert')

        post_data = {'role': 'user'}
        response = self.client.post(reverse('appadmin:manage_app_user_role',
                                            kwargs=view_kwargs),
                                    post_data,
                                    HTTP_X_REQUESTED_WITH='XMLHttpRequest')

        self.assertFalse(
            AppUserRole.objects.filter(app=self.app, user=self.user).exists())
class TestAdminHome(WithApp, WithUser, WithDataset, TestCase):
    def setUp(self):
        super().setUp()
        self.factory = RequestFactory()

        self.user = self.create_user()

        self.role = AppUserRole(
            app=self.app,
            user=self.user,
            role='admin',
        )

        self.superuser = self.create_superuser()

        self.role.save()

    def test_get_context_data(self):
        url_kwargs = {
            'app_uid': self.app.uid,
        }
        request = self.factory.get(reverse('appadmin:home', kwargs=url_kwargs))
        request.user = self.user
        request.app = self.app
        request.session = self.client.session

        view = AdminHome()
        view.request = request

        context = view.get_context_data()

        self.assertEqual(len(context['review_datasets']), 0)
        self.assertEqual(len(context['no_taxon_datasets']), 0)

    def test_get_context_data_with_datasets(self):
        dataset = self.create_dataset()

        dataset.validation_step = HUMAN_INTERACTION_CLASSES[0]
        dataset.save()

        dataset_notaxon = self.create_notaxon_dataset()

        url_kwargs = {
            'app_uid': self.app.uid,
        }
        request = self.factory.get(reverse('appadmin:home', kwargs=url_kwargs))
        request.user = self.user
        request.app = self.app
        request.session = self.client.session

        view = AdminHome()
        view.request = request

        context = view.get_context_data()

        self.assertEqual(context['review_datasets'].first(), dataset)
        self.assertEqual(context['no_taxon_datasets'].first(), dataset_notaxon)

    def test_get(self):
        url_kwargs = {
            'app_uid': self.app.uid,
        }

        response = self.client.get(reverse('appadmin:home', kwargs=url_kwargs))
        self.assertEqual(response.status_code, 302)
        self.assertIn(reverse('log_in'), response.url)

        self.client.login(username=self.test_username,
                          password=self.test_password)
        response_2 = self.client.get(
            reverse('appadmin:home', kwargs=url_kwargs))
        self.assertEqual(response_2.status_code, 200)

        # expert access
        self.role.role = 'expert'
        self.role.save()

        response_3 = self.client.get(
            reverse('appadmin:home', kwargs=url_kwargs))
        self.assertEqual(response_3.status_code, 200)

        # no access
        self.role.delete()
        response_4 = self.client.get(
            reverse('appadmin:home', kwargs=url_kwargs))
        self.assertEqual(response_4.status_code, 403)
class TestUserList(WithUser, WithApp, TestCase):
    def setUp(self):
        super().setUp()
        self.factory = RequestFactory()

        self.user = self.create_user()

        self.role = AppUserRole(
            app=self.app,
            user=self.user,
            role='admin',
        )

        self.role.save()

        self.superuser = self.create_superuser()

        self.client.login(username=self.test_superuser_username,
                          password=self.test_password)

    def test_get_context_data_AND_get(self):
        url_kwargs = {
            'app_uid': self.app.uid,
        }
        request = self.factory.get(
            reverse('appadmin:user_list', kwargs=url_kwargs))
        request.user = self.user
        request.app = self.app
        request.session = self.client.session

        view = UserList()
        view.request = request

        # one admin
        context = view.get_context_data()

        self.assertEqual(context['app_admins'].first().user, self.user)
        self.assertEqual(len(context['app_experts']), 0)
        self.assertEqual(len(context['app_users']), 0)

        self.assertIn('search_app_user_form', context)

        response = self.client.get(
            reverse('appadmin:user_list', kwargs=url_kwargs))
        self.assertEqual(response.status_code, 200)

        # one expert
        self.role.role = 'expert'
        self.role.save()

        context = view.get_context_data()

        self.assertEqual(context['app_experts'].first().user, self.user)
        self.assertEqual(len(context['app_admins']), 0)
        self.assertEqual(len(context['app_users']), 0)

        response_2 = self.client.get(
            reverse('appadmin:user_list', kwargs=url_kwargs))
        self.assertEqual(response_2.status_code, 200)

        # one user
        self.role.delete()

        request.user = self.superuser

        context = view.get_context_data()

        self.assertEqual(len(context['app_experts']), 0)
        self.assertEqual(len(context['app_admins']), 0)
        self.assertEqual(context['app_users'].first(), self.user)

        response_3 = self.client.get(
            reverse('appadmin:user_list', kwargs=url_kwargs))
        self.assertEqual(response_3.status_code, 200)