wbcore 2.2.1__py2.py3-none-any.whl

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",
+            side_effect=Exception if should_fail else None,
+            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,97 @@
+from django.contrib.auth import views as auth_views
+from django.urls import include, path, reverse_lazy
+from dynamic_preferences.api.viewsets import GlobalPreferencesViewSet
+from dynamic_preferences.users.viewsets import UserPreferencesViewSet
+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"global_preferences", GlobalPreferencesViewSet, basename="global_preferences")
+router.register(r"user_preferences", UserPreferencesViewSet, basename="user_preferences")
+
+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,
+)

wbcore/contrib/authentication/viewsets/buttons/__init__.py

@@ -0,0 +1 @@
+from .users import UserModelButtonConfig, UserProfileButtonConfig

wbcore/contrib/authentication/viewsets/buttons/users.py

@@ -0,0 +1,55 @@
+from django.utils.translation import gettext_lazy as _
+from wbcore.contrib.icons import WBIcon
+from wbcore.enums import RequestType
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.buttons.enums import ButtonDefaultColor
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+from wbcore.metadata.configs.display.instance_display import create_simple_display
+
+from ...serializers import ChangePasswordSerializer
+
+
+class UserProfileButtonConfig(ButtonViewConfig):
+    CUSTOM_INSTANCE_BUTTONS = {
+        bt.WidgetButton(label=_("See Profile"), icon=WBIcon.PERSON.icon, key="see_profile"),
+        bt.ActionButton(
+            method=RequestType.PATCH,
+            identifiers=("authentication:userprofile",),
+            action_label=_("Resetting Settings"),
+            key="reset_settings",
+            description_fields=_("<p>This will reset all widgets on all pages.</p>"),
+            icon=WBIcon.UNDO.icon,
+            title=_("Reset Settings"),
+            label=_("Reset Settings"),
+        ),
+        bt.ActionButton(
+            method=RequestType.PATCH,
+            identifiers=("authentication:userprofile",),
+            action_label=_("Changing Password"),
+            key="change_password",
+            description_fields=_("<p>Change Password</p>"),
+            serializer=ChangePasswordSerializer,
+            icon=WBIcon.EDIT.icon,
+            title=_("Change Password"),
+            label=_("Change Password"),
+            instance_display=create_simple_display([["old_password"], ["new_password"], ["confirm_password"]]),
+        ),
+    }
+
+
+class UserModelButtonConfig(ButtonViewConfig):
+    CUSTOM_INSTANCE_BUTTONS = CUSTOM_LIST_INSTANCE_BUTTONS = {
+        bt.ActionButton(
+            method=RequestType.GET,
+            identifiers=("authentication:user",),
+            action_label=_("Resetting Password"),
+            key="reset_password",
+            description_fields=_("<p>Reset Password</p>"),
+            icon=WBIcon.REGENERATE.icon,
+            color=ButtonDefaultColor.WARNING,
+            title=_("Reset Password"),
+            label=_("Reset Password"),
+        ),
+        bt.WidgetButton(key="user_activity_chart", label=_("User Activity"), icon=WBIcon.CHART_BARS_HORIZONTAL.icon),
+        bt.WidgetButton(key="profile", label=_("Profile"), icon=WBIcon.PERSON.icon),
+    }

wbcore/contrib/authentication/viewsets/display/__init__.py

@@ -0,0 +1,6 @@
+from .user_activities import (
+    UserActivityModelDisplay,
+    UserActivityModelUserDisplay,
+    UserActivityTableDisplayConfig,
+)
+from .users import UserModelDisplay, UserPermissionModelDisplay, UserProfileModelDisplay

wbcore/contrib/authentication/viewsets/display/user_activities.py

@@ -0,0 +1,85 @@
+from datetime import date, timedelta
+from typing import Optional
+
+from django.utils.translation import gettext as _
+from wbcore.contrib.color.enums import WBColor
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+from ...models import UserActivity
+
+
+class UserActivityModelDisplay(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="IP", label=_("IP")),
+                dp.Field(key="user", label=_("User")),
+                dp.Field(key="date", label=_("First Login")),
+                dp.Field(key="latest_refresh", label=_("Latest Refresh")),
+                dp.Field(key="time_online_minute", label=_("Time Online (Minutes)")),
+                dp.Field(key="user_agent_info", label=_("Agent Info")),
+            ],
+            formatting=[
+                dp.Formatting(
+                    column="status",
+                    formatting_rules=[
+                        dp.FormattingRule(
+                            style={"backgroundColor": WBColor.GREEN_LIGHT.value},
+                            condition=("==", UserActivity.SUCCESS),
+                        ),
+                        dp.FormattingRule(
+                            style={"backgroundColor": WBColor.RED_LIGHT.value},
+                            condition=("==", UserActivity.FAILED),
+                        ),
+                    ],
+                )
+            ],
+            legends=[
+                dp.Legend(
+                    key="status",
+                    items=[
+                        dp.LegendItem(
+                            icon=WBColor.GREEN_LIGHT.value,
+                            label=UserActivity.SUCCESS,
+                            value=UserActivity.SUCCESS,
+                        ),
+                        dp.LegendItem(
+                            icon=WBColor.RED_LIGHT.value,
+                            label=UserActivity.FAILED,
+                            value=UserActivity.FAILED,
+                        ),
+                    ],
+                )
+            ],
+        )
+
+
+class UserActivityModelUserDisplay(UserActivityModelDisplay):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="IP", label=_("IP")),
+                dp.Field(key="user", label=_("User")),
+                dp.Field(key="date", label=_("First Login")),
+                dp.Field(key="latest_refresh", label=_("Latest Refresh")),
+                dp.Field(key="time_online_minute", label=_("Time Online (Minutes)")),
+                dp.Field(key="user_agent_info", label=_("Agent Info")),
+            ],
+            formatting=super().get_list_display().formatting,
+            legends=super().get_list_display().legends,
+        )
+
+
+class UserActivityTableDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        today = date.today()
+        display = dp.ListDisplay(
+            fields=[
+                dp.Field(key="user_repr", label=_("User")),
+                dp.Field(key="beforeyesterday_activity", label=f"{today - timedelta(days=2)}"),
+                dp.Field(key="yesterday_activity", label=f"{today - timedelta(days=1)}"),
+                dp.Field(key="today_activity", label=f"{today}"),
+            ]
+        )
+        return display