wbcore 1.59.9__py2.py3-none-any.whl

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,56 @@
+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,86 @@
+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

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

@@ -0,0 +1,73 @@
+from typing import Optional
+
+from django.utils.translation import gettext as _
+
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+    create_simple_section,
+)
+from wbcore.metadata.configs.display.instance_display.utils import repeat_field
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class UserPermissionModelDisplay(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="name", label=_("Name")),
+                dp.Field(key="codename", label=_("Code Name")),
+                dp.Field(key="content_type_repr", label=_("Content Type")),
+            ]
+        )
+
+
+class UserProfileModelDisplay(DisplayViewConfig):
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [
+                [repeat_field(3, "profile_image"), "prefix", "first_name", "last_name"],
+                [repeat_field(3, "profile_image"), repeat_field(2, "email"), "birthday"],
+                [repeat_field(3, "profile_image"), repeat_field(2, "profile"), "username"],
+                [repeat_field(6, "token_section")],
+            ],
+            [
+                create_simple_section(
+                    "token_section",
+                    _("Token (Sensitive information: handle with care)"),
+                    [["generic_auth_token_key"], ["calendar_subscription_link"]],
+                )
+            ],
+        )
+
+
+class UserModelDisplay(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="email", label=_("Email")),
+                dp.Field(key="is_active", label=_("Is Active")),
+                dp.Field(key="date_joined", label=_("Joined")),
+                dp.Field(key="last_connection", label=_("Latest Connection")),
+            ]
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [
+                ["username", "email"],
+                [repeat_field(2, "profile")],
+                [repeat_field(2, "is_active")],
+                [repeat_field(2, "groups_section")],
+                [repeat_field(2, "permissions_section")],
+                [repeat_field(2, "user_activity_section")],
+            ],
+            [
+                create_simple_section("groups_section", _("Groups"), [["groups"]], collapsed=True),
+                create_simple_section("permissions_section", _("Permissions"), [["user_permissions"]], collapsed=True),
+                create_simple_section(
+                    "user_activity_section", _("User Activity"), [["user_activity"]], "user_activity", collapsed=True
+                ),
+            ],
+        )

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

@@ -0,0 +1,6 @@
+from .user_activities import (
+    UserActivityModelEndpointConfig,
+    UserActivityTableEndpointConfig,
+    UserActivityUserModelEndpointConfig,
+)
+from .users import UserPermissionsModelEndpointConfig, UserProfileModelEndpointConfig

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

@@ -0,0 +1,14 @@
+from wbcore.metadata.configs.endpoints import EndpointViewConfig
+
+
+class UserActivityModelEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        return None
+
+
+class UserActivityUserModelEndpointConfig(UserActivityModelEndpointConfig):
+    pass
+
+
+class UserActivityTableEndpointConfig(UserActivityModelEndpointConfig):
+    pass

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

@@ -0,0 +1,18 @@
+from rest_framework.reverse import reverse
+
+from wbcore.metadata.configs.endpoints import EndpointViewConfig
+
+
+class UserPermissionsModelEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        return reverse(
+            "wbcore:authentication:user-permissions-list", args=[self.view.kwargs["user_id"]], request=self.request
+        )
+
+
+class UserProfileModelEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        return None
+
+    def get_instance_endpoint(self, **kwargs):
+        return reverse("wbcore:authentication:userprofile-list", args=[], request=self.request)

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

@@ -0,0 +1,6 @@
+from .user_activities import (
+    USER_ACTIVITY_CHART_MENUITEM,
+    USER_ACTIVITY_MENUITEM,
+    USER_ACTIVITY_TABLE_MENUITEM,
+)
+from .users import USER_MENUITEM

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

@@ -0,0 +1,40 @@
+from django.utils.translation import gettext as _
+
+from wbcore.menus import ItemPermission, MenuItem
+
+USER_ACTIVITY_MENUITEM = MenuItem(
+    label=_("User Activity"),
+    endpoint="wbcore:authentication:useractivity-list",
+    permission=ItemPermission(
+        permissions=[
+            "authentication.view_user",
+            "authentication.add_user",
+            "authentication.delete_user",
+            "authentication.change_user",
+        ]
+    ),
+)
+USER_ACTIVITY_TABLE_MENUITEM = MenuItem(
+    label=_("User Activity Table"),
+    endpoint="wbcore:authentication:useractivitytable-list",
+    permission=ItemPermission(
+        permissions=[
+            "authentication.view_user",
+            "authentication.add_user",
+            "authentication.delete_user",
+            "authentication.change_user",
+        ]
+    ),
+)
+USER_ACTIVITY_CHART_MENUITEM = MenuItem(
+    label=_("User Activity Chart"),
+    endpoint="wbcore:authentication:useractivitychart-list",
+    permission=ItemPermission(
+        permissions=[
+            "authentication.view_user",
+            "authentication.add_user",
+            "authentication.delete_user",
+            "authentication.change_user",
+        ]
+    ),
+)

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

@@ -0,0 +1,17 @@
+from django.utils.translation import gettext as _
+
+from wbcore.menus import ItemPermission, MenuItem
+from wbcore.permissions.shortcuts import is_internal_user
+
+USER_MENUITEM = MenuItem(
+    label=_("Users"),
+    endpoint="wbcore:authentication:user-list",
+    permission=ItemPermission(
+        method=lambda request: is_internal_user(request.user), permissions=["authentication.view_user"]
+    ),
+    add=MenuItem(
+        label=_("Create New User"),
+        endpoint="wbcore:authentication:user-list",
+        permission=ItemPermission(permissions=["authentication.add_user"]),
+    ),
+)

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

@@ -0,0 +1,12 @@
+from .user_activities import (
+    UserActivityChartTitleConfig,
+    UserActivityModelTitleConfig,
+    UserActivityTableTitleConfig,
+    UserActivityUserChartTitleConfig,
+    UserActivityUserModelTitleConfig,
+)
+from .users import (
+    UserModelTitleConfig,
+    UserPermissionsModelTitleConfig,
+    UserProfileModelTitleConfig,
+)

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

@@ -0,0 +1,32 @@
+from django.utils.translation import gettext as _
+
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+from ...models import User
+
+
+class UserActivityModelTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        return _("User Activity")
+
+
+class UserActivityUserModelTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        user = User.objects.get(id=self.view.kwargs["user_id"])
+        return _("User Activity of {user}").format(user=user.profile.computed_str)
+
+
+class UserActivityTableTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        return _("User Activity Table")
+
+
+class UserActivityChartTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        return _("User Activity Chart")
+
+
+class UserActivityUserChartTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        user = User.objects.get(id=self.view.kwargs["user_id"])
+        return _("User Activity of {user}").format(user=user.profile.computed_str)

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

@@ -0,0 +1,27 @@
+from django.utils.translation import gettext as _
+
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+from ...models import User
+
+
+class UserPermissionsModelTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        user = User.objects.get(id=self.view.kwargs["user_id"])
+        return _("Permissions for {email}").format(email=user.email)
+
+
+class UserProfileModelTitleConfig(TitleViewConfig):
+    def get_instance_title(self):
+        return _("Your Profile")
+
+
+class UserModelTitleConfig(TitleViewConfig):
+    def get_instance_title(self):
+        return _("User: {{email}}")
+
+    def get_list_title(self):
+        return _("Users")
+
+    def get_create_title(self):
+        return _("New User")

wbcore/contrib/authentication/viewsets/user_activities.py

@@ -0,0 +1,224 @@
+import logging
+from datetime import date, timedelta
+
+import pandas as pd
+import plotly.graph_objects as go
+from django.db.models import (
+    DurationField,
+    ExpressionWrapper,
+    F,
+    OuterRef,
+    Subquery,
+    Sum,
+    Value,
+)
+from django.db.models.fields import FloatField
+from django.db.models.functions import Coalesce, Concat, ExtractMinute
+from django.utils.translation import gettext as _
+from rest_framework import filters
+
+from wbcore import viewsets
+from wbcore.filters import DjangoFilterBackend
+
+from .. import serializers
+from ..filters import UserActivityChartFilter
+from ..models import User, UserActivity
+from ..serializers import UserActivityTableSerializer
+from .display.user_activities import (
+    UserActivityModelDisplay,
+    UserActivityModelUserDisplay,
+    UserActivityTableDisplayConfig,
+)
+from .endpoints.user_activities import (
+    UserActivityModelEndpointConfig,
+    UserActivityTableEndpointConfig,
+    UserActivityUserModelEndpointConfig,
+)
+from .titles.user_activities import (
+    UserActivityChartTitleConfig,
+    UserActivityModelTitleConfig,
+    UserActivityTableTitleConfig,
+    UserActivityUserChartTitleConfig,
+    UserActivityUserModelTitleConfig,
+)
+
+logger = logging.getLogger()
+
+
+class UserActivityModelViewSet(viewsets.ModelViewSet):
+    filterset_fields = {
+        "IP": ["exact", "icontains"],
+        "user": ["exact"],
+        "date": ["gte", "exact", "lte"],
+        "latest_refresh": ["gte", "exact", "lte"],
+        "user_agent_info": ["exact", "icontains"],
+    }
+
+    filter_backends = (filters.SearchFilter, filters.OrderingFilter, DjangoFilterBackend)
+    search_fields = ("user__email", "user_agent_info")
+    ordering_fields = ("date", "latest_refresh", "time_online_minute")
+    ordering = ["-date"]
+
+    queryset = UserActivity.objects.all()
+    serializer_class = serializers.UserActivitySerializer
+
+    display_config_class = UserActivityModelDisplay
+    endpoint_config_class = UserActivityModelEndpointConfig
+    title_config_class = UserActivityModelTitleConfig
+
+    def get_queryset(self):
+        expression = ExpressionWrapper(F("latest_refresh") - F("date"), output_field=DurationField())
+        return UserActivity.objects.annotate(time_online_minute=ExtractMinute(expression))
+
+
+class UserActivityUserModelViewSet(UserActivityModelViewSet):
+    display_config_class = UserActivityModelUserDisplay
+    endpoint_config_class = UserActivityUserModelEndpointConfig
+    title_config_class = UserActivityUserModelTitleConfig
+
+    filter_backends = (filters.SearchFilter, DjangoFilterBackend, filters.OrderingFilter)
+    filterset_fields = {
+        "IP": ["exact"],
+        "date": ["gte", "exact", "lte"],
+        "latest_refresh": ["gte", "exact", "lte"],
+        "user_agent_info": ["exact", "icontains"],
+    }
+
+    def get_queryset(self):
+        user = User.objects.get(id=self.kwargs["user_id"])
+        return super().get_queryset().filter(user=user)
+
+
+class UserActivityTable(viewsets.ModelViewSet):
+    queryset = UserActivity.objects.all()
+    filter_backends = (filters.SearchFilter, filters.OrderingFilter)
+    serializer_class = UserActivityTableSerializer
+    ordering_fields = ["user_repr", "today_activity", "yesterday_activity", "beforeyesterday_activity"]
+    ordering = ["-today_activity"]
+    search_fields = ["user_repr"]
+
+    endpoint_config_class = UserActivityTableEndpointConfig
+    title_config_class = UserActivityTableTitleConfig
+    display_config_class = UserActivityTableDisplayConfig
+
+    def get_queryset(self):
+        expression = ExpressionWrapper(F("latest_refresh") - F("date"), output_field=DurationField())
+
+        def get_time_day(day):
+            return Coalesce(
+                Subquery(
+                    UserActivity.objects.filter(user__id=OuterRef("pk"), date__date=day)
+                    .annotate(_time_online_minute=ExtractMinute(expression))
+                    .values("user")
+                    .annotate(total_time=Sum("_time_online_minute"))
+                    .values("total_time")[:1],
+                    output_field=FloatField(),
+                ),
+                0.0,
+            )
+
+        today = date.today()
+        qs = User.objects.annotate(
+            beforeyesterday_activity=get_time_day(today - timedelta(days=2)),
+            today_activity=get_time_day(today),
+            yesterday_activity=get_time_day(today - timedelta(days=1)),
+            user_repr=F("profile__computed_str"),
+        )
+        return qs
+
+
+class UserActivityChart(viewsets.ChartViewSet):
+    queryset = UserActivity.objects.all()
+    title_config_class = UserActivityChartTitleConfig
+    filter_backends = (DjangoFilterBackend,)
+    filterset_class = UserActivityChartFilter
+
+    def get_queryset(self):
+        return UserActivity.objects.all().annotate(
+            username=Concat(F("user__profile__first_name"), Value(" "), F("user__profile__last_name"))
+        )
+
+    def get_plotly(self, queryset):
+        fig = go.Figure()
+        if queryset.count() > 0:
+            df = pd.DataFrame(queryset.order_by("-date").values("latest_refresh", "date", "username"))
+
+            df.date = pd.to_datetime(df.date).dt.round("Min")
+            df.latest_refresh = pd.to_datetime(df.latest_refresh).dt.round("Min")
+            min_date = df.date.min()
+            max_date = df.latest_refresh.max()
+            freq = "H"
+            if (max_date - min_date).total_seconds() < 86400:
+                freq = "D"
+            min_date = min_date.floor(freq)
+            max_date = max_date.ceil(freq)
+
+            for username, dff in df.groupby("username"):
+                cum_times = pd.Series(
+                    dt
+                    for group in [
+                        pd.date_range(start, end, freq="Min")
+                        for start, end in zip(dff.date, dff.latest_refresh, strict=False)
+                    ]
+                    for dt in group
+                ).value_counts()
+                fig.add_trace(
+                    go.Histogram(
+                        histfunc="sum",
+                        xbins=dict(start=min_date, end=max_date, size=3600000),  # bins used for histogram
+                        y=cum_times.values,
+                        x=cum_times.index,
+                        bingroup=1,
+                        name=username,
+                    ),
+                )
+            fig.update_layout(
+                barmode="stack",
+                paper_bgcolor="rgba(0,0,0,0)",
+                plot_bgcolor="rgba(0,0,0,0)",
+                title=_("<b>User Activity</b>"),
+                xaxis=dict(title=_("Time"), type="date", range=[min_date, max_date]),
+                yaxis=dict(title=_("Cummulative time"), type="linear"),
+                updatemenus=[
+                    dict(
+                        buttons=[
+                            # dict(
+                            #     args = ['xbins.size', 60000],
+                            #     label = 'Minute',
+                            #     method = 'restyle',
+                            # ),
+                            dict(
+                                args=["xbins.size", 3600000],
+                                label=_("Hour"),
+                                method="restyle",
+                            ),
+                            dict(
+                                args=["xbins.size", 86400000],
+                                label=_("Day"),
+                                method="restyle",
+                            ),
+                            dict(
+                                args=["xbins.size", 604800000],
+                                label=_("Week"),
+                                method="restyle",
+                            ),
+                            dict(
+                                args=["xbins.size", "M1"],
+                                label=_("Month"),
+                                method="restyle",
+                            ),
+                        ]
+                    )
+                ],
+                autosize=True,
+            )
+
+        return fig
+
+
+class UserActivityUserChart(UserActivityChart):
+    title_config_class = UserActivityUserChartTitleConfig
+
+    def get_queryset(self):
+        user = User.objects.get(id=self.kwargs["user_id"])
+        return super().get_queryset().filter(user=user)