wbcore 1.59.9__py2.py3-none-any.whl

wbcore/contrib/authentication/tests/signals.py

@@ -0,0 +1,18 @@
+from django.dispatch import receiver
+
+from wbcore.test.signals import custom_update_kwargs, get_custom_factory
+
+from ..factories import UserFactory
+from ..viewsets import UserActivityTable, UserActivityUserChart
+
+
+@receiver(get_custom_factory, sender=UserActivityTable)
+def receive_factory_user_activity(sender, *args, **kwargs):
+    return UserFactory
+
+
+@receiver(custom_update_kwargs, sender=UserActivityUserChart)
+def receive_kwargs_user_activity(sender, *args, **kwargs):
+    if obj := kwargs.get("obj_factory"):
+        return {"user_id": obj.user.id}
+    return {}

wbcore/contrib/authentication/tests/test_configs.py

@@ -0,0 +1,6 @@
+from wbcore.configs.registry import ConfigRegistry
+
+
+def test_authentication_config(config_registry: ConfigRegistry):
+    authentication = config_registry.get_config_dict()["authentication"]
+    assert authentication

wbcore/contrib/authentication/tests/test_serializers.py

@@ -0,0 +1,6 @@
+import pytest
+
+
+@pytest.mark.django_db
+class TestSpecificSerializers:
+    pass

wbcore/contrib/authentication/tests/test_tasks.py

@@ -0,0 +1,34 @@
+from datetime import timedelta
+
+import pytest
+from faker import Faker
+
+from wbcore.contrib.authentication.tasks import delete_unregistered_user_account
+
+from ..models import User
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+def test_delete_unregistered_user_account(user_factory):
+    val_datetime = fake.date_time()
+
+    registered_user = user_factory.create(is_register=True, is_active=True)
+    unregistered_but_active_user = user_factory.create(
+        is_register=False, is_active=True
+    )  # in case we have (but we shouldn't) unregistered but active user, we don't clean them
+    unregistered_user_in_retention_period = user_factory.create(
+        is_register=False, is_active=False, date_joined=val_datetime
+    )  # unregistered user created within the retention period
+    unregistered_user_obselete = user_factory.create(
+        is_register=False, is_active=False, date_joined=val_datetime - timedelta(seconds=1)
+    )  # unregistered user created outside of the retention period
+    delete_unregistered_user_account(prune_user_account_before_datetime=val_datetime)
+    assert set(User.objects.exclude(email="AnonymousUser")) == {
+        registered_user,
+        unregistered_but_active_user,
+        unregistered_user_in_retention_period,
+    }
+    with pytest.raises(User.DoesNotExist):
+        unregistered_user_obselete.refresh_from_db()

wbcore/contrib/authentication/tests/test_tokens.py

@@ -0,0 +1,127 @@
+import urllib
+from datetime import datetime, timedelta
+
+import pytest
+from django.urls import resolve
+from django.utils import timezone
+from faker import Faker
+from rest_framework import exceptions
+from rest_framework.test import APIRequestFactory
+
+from wbcore.contrib.authentication.authentication import inject_short_lived_token
+from wbcore.contrib.authentication.models import Token, User
+
+fake = Faker()
+now = datetime.now()
+
+
+class TestTokenUnitTests:
+    @pytest.fixture
+    def request_with_user(self: User):
+        request = APIRequestFactory().get("/")
+        request.user = self
+        return request
+
+    def setup_method(self):
+        self.token = Token()
+
+    @pytest.mark.parametrize("is_valid", [True, False])
+    def test_check_validity_for_endpoint_for_infinite_token(self, is_valid, mocker):
+        mocker.patch.object(self.token, "is_valid", is_valid)
+        if self.token.is_valid:
+            assert self.token.check_validity_for_endpoint(fake.sentence(), fake.date_time())
+        else:
+            with pytest.raises(exceptions.AuthenticationFailed) as exc_info:
+                assert self.token.check_validity_for_endpoint(fake.sentence(), fake.date_time())
+            assert str(exc_info.value) == "Token is not valid anymore"
+
+    def test_check_invalidity_for_endpoint_for_expired_token(self, mocker):
+        mocker.patch.object(self.token, "valid_until", now)
+        assert self.token.check_validity_for_endpoint(
+            self.token.protected_view_name, self.token.valid_until - timedelta(minutes=1)
+        )
+        with pytest.raises(exceptions.AuthenticationFailed) as exc_info:
+            self.token.check_validity_for_endpoint(
+                self.token.protected_view_name, self.token.valid_until + timedelta(minutes=1)
+            )
+        assert str(exc_info.value) == "Token has expired"
+
+    def test_check_invalidity_for_endpoint_for_exhausted_token(self, mocker):
+        mocker.patch.object(self.token, "number_usage_left", 2)
+        mocker.patch.object(self.token, "save")
+        while self.token.number_usage_left > 0:
+            assert self.token.check_validity_for_endpoint(self.token.protected_view_name, fake.date_time())
+        with pytest.raises(exceptions.AuthenticationFailed) as exc_info:
+            self.token.check_validity_for_endpoint(self.token.protected_view_name, fake.date_time())
+        assert str(exc_info.value) == "Token usage exhausted"
+
+    def test_check_unvalidity_for_endpoint_for_wrong_endpoint(self, mocker):
+        mocker.patch.object(self.token, "protected_view_name", "Some View Name")
+        with pytest.raises(exceptions.AuthenticationFailed) as exc_info:
+            self.token.check_validity_for_endpoint("wbcore:authentication:wrongview", fake.date_time())
+        assert str(exc_info.value) == "Token has limited scope that doesn't match the requested endpoint"
+
+    @pytest.mark.django_db
+    @pytest.mark.parametrize("view_name", [(None, "wbcore:authentication:user")])
+    def test_generate_token_for_user(self, user, view_name):
+        d1 = fake.date_time()
+        n1 = fake.pyint()
+        token = Token.generate_token_for_user(user, protected_view_name=view_name, valid_until=d1, number_of_usages=n1)
+        assert token.user == user
+        assert token.protected_view_name == view_name
+        assert token.valid_until == d1
+        assert token.number_usage_left == n1
+        token.is_valid = False
+        token.save()  # invalid token to check that retrieving it will enable it
+
+        d2 = fake.date_time()
+        n2 = fake.pyint()
+        new_token = Token.generate_token_for_user(
+            user, protected_view_name=view_name, valid_until=d2, number_of_usages=n2
+        )
+        assert new_token == token  # check that the uniqueness on schema work
+        assert new_token.valid_until == d2
+        assert new_token.number_usage_left == n2
+        assert new_token.is_valid is True
+
+    @pytest.mark.django_db
+    @pytest.mark.parametrize(
+        "endpoint,creation_time",
+        [
+            ("http://localhost:5000/wbcore/authentication/user/", now),
+            ("http://localhost:5000/wbcore/authentication/user/?some_param=True", now),
+            ("/wbcore/authentication/user/?some_param=True&other_param=foo", now),
+        ],
+    )
+    def test_generate_shareable_link(self, user, endpoint, creation_time):
+        creation_time = timezone.make_aware(creation_time)
+        parse_url = urllib.parse.urlsplit(urllib.parse.unquote(endpoint))
+        base_params = dict(urllib.parse.parse_qsl(parse_url.query))
+        link = self.token.generate_shareable_link(endpoint, user, creation_time=creation_time)
+        res_params = dict(urllib.parse.parse_qsl(urllib.parse.urlsplit(urllib.parse.unquote(link)).query))
+
+        assert endpoint in link  # check that the resulting endpoint is not modified
+        for k, v in base_params.items():  # check that the base query parameters weren't touched
+            assert res_params[k] == v
+        assert (
+            res_params["token"]
+            == Token.objects.get(user=user, protected_view_name=resolve(parse_url.path).view_name).key
+        )  # check that the token was injected as query parameter
+
+    @pytest.mark.django_db
+    @pytest.mark.parametrize("view_name", [("wbcore:authentication:user", None)])
+    def test_inject_short_lived_token(self, user, view_name, request_with_user):
+        link = fake.url() + "?a=a&b=b"
+
+        @inject_short_lived_token(view_name=view_name)
+        def dummy_resources(serializer, instance, request, user, **kwargs):
+            return {"resource": link}
+
+        res = dummy_resources(None, None, request_with_user, user)
+        res_params = dict(urllib.parse.parse_qsl(urllib.parse.urlsplit(urllib.parse.unquote(res["resource"])).query))
+        assert link in res["resource"]  # check that the resulting endpoint is not modified
+        assert res_params["a"] == "a"
+        assert res_params["b"] == "b"
+        assert (
+            res_params["token"] == Token.objects.get(user=user, protected_view_name=view_name).key
+        )  # check that the token was injected as query parameter

wbcore/contrib/authentication/tests/test_users.py

@@ -0,0 +1,338 @@
+import pytest
+from django.core import mail
+from django.db.utils import IntegrityError
+from faker import Faker
+from pytest_mock import MockerFixture
+from rest_framework.reverse import reverse
+from rest_framework.test import APIRequestFactory
+
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.contrib.authentication.models import User
+from wbcore.contrib.authentication.viewsets.users import (
+    activate_user,
+    register_user,
+    reset_password_email,
+)
+from wbcore.contrib.directory.models import Person
+
+fake = Faker()
+
+
+class TestUser:
+    @pytest.fixture
+    def test_user(self):
+        return User()
+
+    @pytest.fixture
+    def test_user_data(self):
+        return {
+            "email": "john.neumann@intellineers.com",
+            "password": "fake_password",
+            "first_name": "John",
+            "last_name": "Neumann",
+        }
+
+    def test_get_short_name(self, test_user_data):
+        person = Person(first_name=test_user_data["first_name"], last_name=test_user_data["last_name"])
+        user = User(profile=person)
+        assert user.get_short_name() == test_user_data["first_name"]
+
+    @pytest.mark.parametrize("is_valid", [True, False])
+    def test_reset_password(self, is_valid: bool, mocker: MockerFixture, test_user, test_user_data):
+        # Arrange
+        mocker.patch.object(test_user, "email", test_user_data["email"])
+        mock_password_reset_form = mocker.patch("django.contrib.auth.forms.PasswordResetForm")
+        mock_instance = mock_password_reset_form.return_value
+        mock_instance.is_valid.return_value = is_valid
+
+        # Act
+        test_user.reset_password(request="mocked_request")
+
+        # Assert
+        mock_password_reset_form.assert_called_once_with(data={"email": test_user_data["email"]})
+        mock_instance.is_valid.assert_called_once()
+        if is_valid:
+            mock_instance.save.assert_called_once_with(
+                request="mocked_request",
+                email_template_name="password_reset_email.html",
+                html_email_template_name="password_reset_email_html.html",
+            )
+        else:
+            mock_instance.save.assert_not_called()
+
+    def test_generate_and_verify_temporary_toke(self, mocker: MockerFixture, test_user):
+        # Arrange
+        other_user = User()
+        # We need to mock an id, otherwise the generated tokens will be the same
+        mocker.patch.object(test_user, "id", 1)
+        mocker.patch.object(other_user, "id", 2)
+
+        # Act
+        user_token = test_user.generate_temporary_token()
+        other_user_token = other_user.generate_temporary_token()
+
+        # Assert
+        assert test_user.verify_temporary_token(user_token)
+        assert not test_user.verify_temporary_token(other_user_token)
+        assert other_user.verify_temporary_token(other_user_token)
+        assert not other_user.verify_temporary_token(user_token)
+
+    @pytest.mark.django_db
+    @pytest.mark.parametrize("first_name, last_name", [("John", "Neumann")])
+    def test_generate_username(self, first_name: str, last_name: str, user_factory: UserFactory):
+        username = User.generate_username(first_name, last_name)
+        assert username == f"{first_name.lower()}-{last_name.lower()}"
+        user_factory.create(username=username)
+        username_1 = User.generate_username(first_name, last_name)
+        assert username_1 == f"{first_name.lower()}-{last_name.lower()}-2"
+        user_factory.create(username=username_1)
+        assert User.generate_username(first_name, last_name) == f"{first_name.lower()}-{last_name.lower()}-3"
+
+    def test_create_with_attributes(self, test_user_data, mocker: MockerFixture):
+        # Arrange
+        user_name = f"{test_user_data['first_name']}-{test_user_data['last_name']}"
+        mock_user = mocker.Mock(spec=User)
+        generate_user_name = mocker.patch(
+            "wbcore.contrib.authentication.models.User.generate_username", return_value=user_name
+        )
+        create_user_mock = mocker.patch(
+            "wbcore.contrib.authentication.models.User.objects.create_user", return_value=mock_user
+        )
+
+        # Act
+        user = User.create_with_attributes(
+            test_user_data["email"],
+            test_user_data["password"],
+            first_name=test_user_data["first_name"],
+            last_name=test_user_data["last_name"],
+        )
+
+        # Assert
+        assert user.check_password(test_user_data["password"])
+        generate_user_name.assert_called_once_with(test_user_data["first_name"], test_user_data["last_name"])
+        create_user_mock.assert_called_once_with(
+            user_name,
+            test_user_data["email"],
+            test_user_data["password"],
+            is_staff=False,
+            is_superuser=False,
+            is_active=False,
+            is_register=False,
+        )
+
+
+class TestRegistrationAndActivationViews:
+    @pytest.fixture
+    def test_user(self):
+        return User(
+            password="fake_password",
+            email="john.neumann@intellineers.com",
+        )
+
+    @pytest.fixture
+    def registration_data(self, test_user):
+        return {
+            "email": test_user.email,
+            "password": test_user.password,
+            "first_name": "John",
+            "last_name": "Neumann",
+        }
+
+    @pytest.fixture
+    def missing_data_msg(self):
+        return "email, first_name, last_name and password must be provided"
+
+    @pytest.fixture
+    def api_factory(self):
+        return APIRequestFactory()
+
+    @pytest.fixture
+    def register_url(self):
+        return reverse("wbcore:authentication:register")
+
+    @pytest.mark.parametrize("should_fail", [True, False])
+    def test_reset_password_with_user(self, should_fail, mocker: MockerFixture, test_user, api_factory):
+        # Arrange
+        mock_get_user = mocker.patch(
+            "wbcore.contrib.authentication.models.users.UserManager.get",
+            return_value=None if should_fail else test_user,
+        )
+        mock_reset_password = mocker.patch.object(test_user, "reset_password")
+        url = reverse("wbcore:authentication:reset_password_email")
+
+        # Act
+        request = api_factory.post(url, {"email": test_user.email})
+        response = reset_password_email(request)
+
+        # Assert
+        mock_get_user.assert_called_once_with(email="john.neumann@intellineers.com")
+
+        if should_fail:
+            mock_reset_password.assert_not_called()
+        else:
+            mock_reset_password.assert_called_once()
+            assert response.data["status"] == "ok"
+            assert (
+                response.data["msg"]
+                == "If the email matches a user, it will receive an email inviting him to reset his password."
+            )
+        assert response.status_code == 200
+
+    @pytest.mark.parametrize("user_is_already_registered,", [True, False])
+    def test_registration(
+        self,
+        user_is_already_registered,
+        mocker: MockerFixture,
+        test_user,
+        api_factory,
+        register_url,
+        registration_data,
+    ):
+        # Arrange
+        mocker.patch.object(test_user, "id", 1)
+        patch_path = "wbcore.contrib.authentication.models.users.User.create_with_attributes"
+        if user_is_already_registered:
+            mock_create_with_attributes = mocker.patch(patch_path, side_effect=IntegrityError)
+        else:
+            mock_create_with_attributes = mocker.patch(patch_path, return_value=test_user)
+        current_mailbox_count = len(mail.outbox)
+
+        # Act
+        request = api_factory.post(register_url, registration_data)
+        response = register_user(request)
+
+        # Assert
+        mock_create_with_attributes.assert_called_once_with(
+            registration_data["email"],
+            registration_data["password"],
+            first_name=registration_data["first_name"],
+            last_name=registration_data["last_name"],
+        )
+        if user_is_already_registered:
+            assert response.status_code == 409
+            assert response.data["status"] == "fail"
+            assert response.data["msg"] == "Your account already exists"
+            assert len(mail.outbox) == current_mailbox_count
+        else:
+            assert response.status_code == 200
+            assert response.data["status"] == "success"
+            assert response.data["msg"] == "Please confirm your email address to complete the registration"
+            assert len(mail.outbox) == current_mailbox_count + 1
+
+            sent_mail = mail.outbox[-1]
+            assert sent_mail.subject == "Activate your account."
+            assert sent_mail.to == [test_user.email]
+
+    @pytest.mark.parametrize("password", ["", "a" * 255])
+    def test_registration_with_invalid_password(
+        self, password, api_factory, register_url, registration_data, missing_data_msg
+    ):
+        # Arrange
+        current_mailbox_count = len(mail.outbox)
+
+        # Act
+        request = api_factory.post(
+            register_url,
+            {
+                "email": registration_data["email"],
+                "password": password,
+                "first_name": registration_data["first_name"],
+                "last_name": registration_data["last_name"],
+            },
+        )
+        response = register_user(request)
+
+        # Assert
+        assert response.status_code == 400
+        assert response.data["status"] == "fail"
+        if not password:
+            assert response.data["msg"] == missing_data_msg
+        else:
+            assert (
+                response.data["msg"] == "password is too long. please provider a password shorter than 128 characters."
+            )
+        assert len(mail.outbox) == current_mailbox_count
+
+    @pytest.mark.parametrize("email", ["", "a" * 255 + "@test.com"])
+    def test_registration_with_invalid_email(
+        self, email, api_factory, register_url, registration_data, missing_data_msg
+    ):
+        # Arrange
+        current_mailbox_count = len(mail.outbox)
+
+        # Act
+        request = api_factory.post(
+            register_url,
+            {
+                "email": email,
+                "password": registration_data["password"],
+                "first_name": registration_data["first_name"],
+                "last_name": registration_data["last_name"],
+            },
+        )
+        response = register_user(request)
+
+        # Assert
+        assert response.status_code == 400
+        assert response.data["status"] == "fail"
+        if not email:
+            assert response.data["msg"] == missing_data_msg
+        else:
+            assert response.data["msg"] == "email is too long. please provider an email shorter than 255 characters."
+        assert len(mail.outbox) == current_mailbox_count
+
+    @pytest.mark.parametrize(
+        "first_name, last_name", [("", ""), ("a" * 101, ""), ("", "b" * 101), ("a" * 101, "b" * 101)]
+    )
+    def test_registration_with_invalid_name(
+        self, first_name, last_name, api_factory, register_url, registration_data, missing_data_msg
+    ):
+        # Arrange
+        current_mailbox_count = len(mail.outbox)
+
+        # Act
+        request = api_factory.post(
+            register_url,
+            {
+                "email": registration_data["email"],
+                "password": registration_data["password"],
+                "first_name": first_name,
+                "last_name": last_name,
+            },
+        )
+        response = register_user(request)
+
+        # Assert
+        assert response.status_code == 400
+        assert response.data["status"] == "fail"
+        if len(first_name) > 100 or len(last_name) > 100:
+            assert response.data["msg"] == "first and last name are too long. please provider a shorter name."
+        else:
+            assert response.data["msg"] == missing_data_msg
+        assert len(mail.outbox) == current_mailbox_count
+
+    @pytest.mark.parametrize("should_fail", [True, False])
+    def test_activation(self, should_fail, mocker: MockerFixture, test_user, api_factory):
+        # Assert
+        test_uuid = "test_uuid"
+        test_token = "wrong_token" if should_fail else test_user.generate_temporary_token()
+        mocker.patch.object(test_user, "is_active", False)
+        mocker.patch.object(test_user, "is_register", False)
+        mocker.patch("wbcore.contrib.authentication.viewsets.users.get_object_or_404", return_value=test_user)
+        test_user.save = mocker.MagicMock()
+        url = reverse("wbcore:authentication:activate", args=[test_uuid, test_token])
+
+        # Act
+        request = api_factory.get(url)
+        response = activate_user(request, test_uuid, test_token)
+
+        # Assert
+        if should_fail:
+            assert response.status_code == 400
+            assert test_user.is_active is False
+            assert test_user.is_register is False
+        else:
+            assert response.status_code == 200
+            assert test_user.is_active is True
+            assert test_user.is_register is True
+            test_user.save.assert_called_once()

wbcore/contrib/authentication/tests/test_viewsets.py

@@ -0,0 +1,6 @@
+import pytest
+
+
+@pytest.mark.django_db
+class TestSpecificSViewsets:
+    pass

wbcore/contrib/authentication/tests/tests.py

@@ -0,0 +1,15 @@
+import pytest
+from rest_framework.test import APIRequestFactory
+
+from .. import resolve_profile
+from ..factories import UserFactory
+
+
+@pytest.mark.django_db
+class TestSpecifics:
+    def test_resolve_profile(self):
+        request = APIRequestFactory().get("")
+        request.user = UserFactory(is_active=True, is_superuser=True)
+        result = resolve_profile(request)
+        assert result
+        assert result.get("endpoint")

wbcore/contrib/authentication/urls.py

@@ -0,0 +1,94 @@
+from django.contrib.auth import views as auth_views
+from django.urls import include, path, reverse_lazy
+from rest_framework_simplejwt.views import (  # TokenObtainPairView,; TokenRefreshView,
+    TokenVerifyView,
+)
+
+from wbcore.routers import WBCoreRouter
+
+from .viewsets import (
+    GroupRepresentationViewSet,
+    GroupViewSet,
+    MyTokenObtainPairModelView,
+    MyTokenRefreshModelView,
+    PermissionRepresentationViewSet,
+    PermissionViewSet,
+    UserActivityChart,
+    UserActivityModelViewSet,
+    UserActivityTable,
+    UserActivityUserChart,
+    UserActivityUserModelViewSet,
+    UserModelViewSet,
+    UserPermissionsModelViewSet,
+    UserProfileModelViewSet,
+    UserRepresentationViewSet,
+)
+from .viewsets.users import activate_user, register_user, reset_password_email
+
+router = WBCoreRouter()
+router.register(r"userrepresentation", UserRepresentationViewSet, basename="userrepresentation")
+router.register(r"grouprepresentation", GroupRepresentationViewSet, basename="grouprepresentation")
+router.register(r"permissionrepresentation", PermissionRepresentationViewSet, basename="permissionrepresentation")
+
+router.register(r"group", GroupViewSet)
+router.register(r"permission", PermissionViewSet)
+router.register(r"user", UserModelViewSet, basename="user")
+router.register(r"userprofile", UserProfileModelViewSet, basename="userprofile")
+
+router.register(r"useractivitychart", UserActivityChart, basename="useractivitychart")
+router.register(r"useractivity", UserActivityModelViewSet, basename="useractivity")
+router.register(r"useractivitytable", UserActivityTable, basename="useractivitytable")
+
+user_router = WBCoreRouter()
+user_router.register(r"useractivity", UserActivityUserModelViewSet, basename="user-useractivity")
+user_router.register(r"useractivitychart", UserActivityUserChart, basename="user-useractivitychart")
+user_router.register(
+    r"permissions",
+    UserPermissionsModelViewSet,
+    basename="user-permissions",
+)
+
+urlpatterns = [
+    # path("token/", TokenObtainPairView.as_view(), name="token_obtain_pair"),
+    # path("token/refresh/", TokenRefreshView.as_view(), name="token_refresh"),
+    # path("token/verify/", TokenVerifyView.as_view(), name="token_verify"),
+    path("token/", MyTokenObtainPairModelView.as_view(), name="token_obtain_pair"),
+    path("token/refresh/", MyTokenRefreshModelView.as_view(), name="token_refresh"),
+    path("token/verify/", TokenVerifyView.as_view(), name="token_verify"),
+    # url(r'^api_token/', get_api_token, name='api-token'),
+    # url(r'^wb_menu/', WBMenuAPIView.as_view(), name='wb-menu'),
+    path("", include(router.urls)),
+    path("user/<int:user_id>/", include(user_router.urls)),
+    path(
+        "reset_password/",
+        auth_views.PasswordResetView.as_view(
+            template_name="reset_password.html",
+            email_template_name="password_reset_email.html",
+            html_email_template_name="password_reset_email_html.html",
+            success_url=reverse_lazy("wbcore:authentication:password_reset_done"),
+        ),
+        name="reset_password",
+    ),
+    # OR direct Post request view
+    path("reset_password_email/", reset_password_email, name="reset_password_email"),
+    path(
+        "reset_password_sent/",
+        auth_views.PasswordResetDoneView.as_view(template_name="password_reset_sent.html"),
+        name="password_reset_done",
+    ),
+    path(
+        "reset/<uidb64>/<token>",
+        auth_views.PasswordResetConfirmView.as_view(
+            template_name="password_reset_form.html",
+            success_url=reverse_lazy("wbcore:authentication:password_reset_complete"),
+        ),
+        name="password_reset_confirm",
+    ),
+    path(
+        "reset_password_complete/",
+        auth_views.PasswordResetCompleteView.as_view(template_name="password_reset_done.html"),
+        name="password_reset_complete",
+    ),
+    path("register/", register_user, name="register"),
+    path("activate/<uuid>/<token>", activate_user, name="activate"),
+]

wbcore/contrib/authentication/utils.py

@@ -0,0 +1,10 @@
+from django.contrib.auth.tokens import PasswordResetTokenGenerator
+from django.utils import six
+
+
+class TokenGenerator(PasswordResetTokenGenerator):
+    def _make_hash_value(self, user, timestamp):
+        return six.text_type(user.pk) + six.text_type(timestamp) + six.text_type(user.is_active)
+
+
+account_activation_token = TokenGenerator()

wbcore/contrib/authentication/viewsets/__init__.py

@@ -0,0 +1,19 @@
+from .user_activities import (
+    UserActivityChart,
+    UserActivityModelViewSet,
+    UserActivityTable,
+    UserActivityUserChart,
+    UserActivityUserModelViewSet,
+)
+from .users import (
+    GroupRepresentationViewSet,
+    GroupViewSet,
+    MyTokenObtainPairModelView,
+    MyTokenRefreshModelView,
+    PermissionRepresentationViewSet,
+    PermissionViewSet,
+    UserModelViewSet,
+    UserPermissionsModelViewSet,
+    UserProfileModelViewSet,
+    UserRepresentationViewSet,
+)