baseapp-backend 0.0.51__py3-none-any.whl

baseapp/README.md

@@ -0,0 +1,40 @@
+# BaseApp
+
+BaseApp is a Django project template that provides a set of tools and best practices for building web applications.
+
+## Requirements:
+
+Run `pip install baseapp-backend`
+And make sure to add the frozen version to your `requirements/base.txt` file
+
+If you want to develop, [install using this other guide](#how-to-develop).
+
+## How to use
+
+Then enable the desired apps in your Django project's `INSTALLED_APPS` setting:
+
+```python
+INSTALLED_APPS = [
+    ...
+    'baseapp.activity_log',
+    ...
+]
+```
+
+## Features
+
+## How to develop
+
+Clone the project inside your project's backend dir:
+
+```
+git clone git@github.com:silverlogic/baseapp-backend.git
+```
+
+And manually install the package:
+
+```
+pip install -e baseapp-backend/baseapp
+```
+
+The `-e` flag will make it like any change you make in the cloned repo files will effect into the project.

baseapp/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("baseapp_backend")
+except PackageNotFoundError:
+    __version__ = None

baseapp/activity_log/README.md

@@ -0,0 +1,104 @@
+# BaseApp Activity Log
+
+This app exposes an API to view user's activities that are being tracked by the system.
+
+## Installation
+
+### Requirements:
+
+You need to have [django-pghistory](https://github.com/Opus10/django-pghistory) installed in your project and models that you want to track should be tracked by pghistory:
+
+```python
+import pghistory
+
+@pghistory.track()
+class TrackedModel(models.Model):
+    int_field = models.IntegerField()
+    text_field = models.TextField()
+```
+
+Add `baseapp.activity_log` to your `INSTALLED_APPS` setting:
+
+```python
+INSTALLED_APPS = [
+    ...
+    'baseapp.activity_log',
+]
+```
+
+Add `HistoryMiddleware` to the `MIDDLEWARE` list in the `settings.py` file:
+
+```python
+MIDDLEWARE = [
+    ...
+    'baseapp.activity_log.middleware.HistoryMiddleware',
+]
+```
+
+Add `ActivityLogPermissionsBackend` to the `AUTHENTICATION_BACKENDS` list in the `settings.py` file:
+
+```python
+AUTHENTICATION_BACKENDS = [
+    ...
+    "baseapp.activity_log.permissions.ActivityLogPermissionsBackend",
+]
+```
+
+Add `ActivityLogQueries` to your GraphQL schema:
+
+```python
+from baseapp.activity_log.schema import ActivityLogQueries
+
+class Query(ActivityLogQueries, graphene.ObjectType):
+    pass
+
+schema = graphene.Schema(query=Query)
+```
+
+## Usage
+
+By default users only have access to public activities. To log an activity as public use the `set_public_activity` function:
+
+```python
+from baseapp.activity_log.context import set_public_activity
+
+def create_comment(request, body):
+    # ...
+    set_public_activity(verb="baseapp_comments.add_comment")
+```
+
+### GraphQL
+
+This packages provides the following interfaces that can be used to expose the activity logs for user, profile and specific models:
+
+- `NodeActivityLogInterface`
+- `UserActivityLog`
+- `ProfileActivityLog`
+
+This app also exposes a query to fetch a global list of activities:
+
+```graphql
+{
+  activityLogs(visibility: PUBLIC, first: 10) {
+    edges {
+      node {
+        id
+        verb
+        profile {
+          name
+        }
+        events {
+          diff
+          label
+          obj {            
+            ... on Comment {
+              body
+            }
+          }
+        }
+        createdAt
+      }
+    }
+  }
+}
+```

baseapp/activity_log/apps.py

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+
+
+class PackageConfig(AppConfig):
+    default = True
+    name = "baseapp.activity_log"
+    label = "baseapp_activity_log"
+    verbose_name = "BaseApp Activity Log"
+    default_auto_field = "django.db.models.BigAutoField"

baseapp/activity_log/context.py

@@ -0,0 +1,15 @@
+from typing import Any
+
+import pghistory
+
+from .models import VisibilityTypes
+
+
+def set_public_activity(verb: str, **kwargs: Any) -> None:
+    """Set public visibility context for activity logging.
+
+    Args:
+        verb: The action verb describing the activity (e.g., 'create', 'update')
+        **kwargs: Additional context parameters to be logged
+    """
+    pghistory.context(visibility=VisibilityTypes.PUBLIC, verb=verb, **kwargs)

baseapp/activity_log/graphql/filters.py

@@ -0,0 +1,40 @@
+import django_filters
+from django.core.exceptions import ValidationError
+from django.db.models import Q
+
+from ..models import ActivityLog
+
+
+class ActivityLogFilter(django_filters.FilterSet):
+    created_from = django_filters.DateFilter(field_name="created_at", lookup_expr="date__gte")
+    created_to = django_filters.DateFilter(field_name="created_at", lookup_expr="date__lte")
+    user_pk = django_filters.NumberFilter(field_name="user_id")
+    profile_pk = django_filters.NumberFilter(field_name="profile_id")
+    user_name = django_filters.CharFilter(method="filter_user_name")
+
+    def filter_user_name(self, queryset, name, value):
+        return queryset.filter(
+            Q(user__profile__name__icontains=value) | Q(user__email__icontains=value)
+        )
+
+    def filter_queryset(self, queryset):
+        created_from = self.data.get("created_from")
+        created_to = self.data.get("created_to")
+
+        if created_from and created_to and created_from > created_to:
+            raise ValidationError("`created_from` must be earlier than or equal to `created_to`.")
+        return super().filter_queryset(queryset)
+
+    class Meta:
+        model = ActivityLog
+        fields = ["created_from", "created_to", "user_pk", "profile_pk", "user_name"]
+
+
+class MiddlewareEventFilter(django_filters.FilterSet):
+    created_from = django_filters.DateFilter(field_name="pgh_created_at__gte")
+    created_to = django_filters.DateFilter(field_name="pgh_created_at__lte")
+    user_pk = django_filters.NumberFilter(field_name="user_id")
+
+    class Meta:
+        model = ActivityLog
+        fields = ["created_from", "created_to", "user_pk"]

baseapp/activity_log/graphql/interfaces.py

@@ -0,0 +1,50 @@
+import graphene
+from graphene_django.filter import DjangoFilterConnectionField
+
+from ..models import ActivityLog
+from .object_types import ActivityLogObjectType, VisibilityTypesEnum
+
+
+class NodeActivityLogInterface(graphene.Interface):
+    node_activity_logs = DjangoFilterConnectionField(
+        ActivityLogObjectType,
+        visibility=VisibilityTypesEnum(),
+        first=graphene.Int(default_value=10),
+        max_limit=100,
+    )
+
+    def resolve_node_activity_logs(self, info, **kwargs):
+        if not info.context.user.has_perm("activity_log.list_node_activitylog", self):
+            return ActivityLog.objects.none()
+        context_ids = self.pgh_event_model.objects.filter(pgh_obj_id=self.pk).values_list(
+            "pgh_context_id", flat=True
+        )
+        return ActivityLog.objects.filter(pk__in=context_ids)
+
+
+class UserActivityLog:
+    activity_logs = DjangoFilterConnectionField(
+        ActivityLogObjectType,
+        visibility=VisibilityTypesEnum(),
+        first=graphene.Int(default_value=10),
+        max_limit=100,
+    )
+
+    def resolve_activity_logs(self, info, **kwargs):
+        if not info.context.user.has_perm("activity_log.list_user_activitylog", self):
+            return ActivityLog.objects.none()
+        return ActivityLog.objects.filter(user_id=self.pk)
+
+
+class ProfileActivityLog:
+    activity_logs = DjangoFilterConnectionField(
+        ActivityLogObjectType,
+        visibility=VisibilityTypesEnum(),
+        first=graphene.Int(default_value=10),
+        max_limit=100,
+    )
+
+    def resolve_activity_logs(self, info, **kwargs):
+        if not info.context.user.has_perm("activity_log.list_profile_activitylog", self):
+            return ActivityLog.objects.none()
+        return ActivityLog.objects.filter(profile_id=self.pk)

baseapp/activity_log/graphql/object_types.py

@@ -0,0 +1,133 @@
+import graphene
+import swapper
+from django.apps import apps
+from django.contrib.auth import get_user_model
+from graphene.types.generic import GenericScalar
+from graphene_django.filter import DjangoFilterConnectionField
+from pghistory.models import MiddlewareEvents
+
+from baseapp_core.graphql import DjangoObjectType
+from baseapp_core.graphql import Node as RelayNode
+from baseapp_core.graphql import get_object_type_for_model
+
+from ..models import ActivityLog, VisibilityTypes
+from .filters import ActivityLogFilter, MiddlewareEventFilter
+
+User = get_user_model()
+Profile = swapper.load_model("baseapp_profiles", "Profile")
+VisibilityTypesEnum = graphene.Enum.from_enum(VisibilityTypes)
+
+
+class NodeLogEventObjectType(DjangoObjectType):
+    obj = graphene.Field(RelayNode, description="The object of the event.")
+    label = graphene.String(description="The event label.")
+    data = GenericScalar(description="The raw data of the event.")
+    diff = GenericScalar(description="The diff between the previous event of the same label.")
+    created_at = graphene.DateTime(description="When the event was created.")
+
+    class Meta:
+        interfaces = (RelayNode,)
+        model = MiddlewareEvents
+        name = "NodeLogEvent"
+        fields = (
+            "id",
+            "obj",
+            "data",
+            "created_at",
+            "diff",
+            "user",
+            "label",
+        )
+        filterset_class = MiddlewareEventFilter
+
+    def resolve_data(self, info, **kwargs):
+        if info.context.user.has_perm("activity_log.view_nodelogevent-data", self):
+            return self.pgh_data
+
+    def resolve_obj(self, info, **kwargs):
+        Model = apps.get_model(self.pgh_obj_model)
+        try:
+            return Model.objects.get(pk=self.pgh_obj_id)
+        except Model.DoesNotExist:
+            return None
+
+    def resolve_created_at(self, info, **kwargs):
+        return self.pgh_created_at
+
+    def resolve_diff(self, info, **kwargs):
+        if info.context.user.has_perm("activity_log.view_nodelogevent-diff", self):
+            return self.pgh_diff
+
+    def resolve_label(self, info, **kwargs):
+        return self.pgh_label
+
+
+class BaseActivityLogObjectType:
+    metadata = GenericScalar()
+    events = DjangoFilterConnectionField(lambda: NodeLogEventObjectType)
+    user = graphene.Field(get_object_type_for_model(User))
+    profile = graphene.Field(get_object_type_for_model(Profile))
+    visibility = graphene.Field(VisibilityTypesEnum)
+    verb = graphene.String()
+    ip_address = graphene.String()
+    url = graphene.String()
+
+    @classmethod
+    def get_node(cls, info, id):
+        try:
+            obj = cls._meta.model.objects.get(id=id)
+            if not info.context.user.has_perm("activity_log.view_activitylog", obj):
+                return None
+            return obj
+
+        except cls._meta.model.DoesNotExist:
+            return None
+
+    @classmethod
+    def get_queryset(cls, queryset, info):
+        if not info.context.user.has_perm("activity_log.list_activitylog_any_visibility"):
+            queryset = queryset.filter(visibility=VisibilityTypes.PUBLIC)
+        return queryset
+
+    class Meta:
+        interfaces = (RelayNode,)
+        model = ActivityLog
+        fields = (
+            "id",
+            "pk",
+            "user",
+            "url",
+            "verb",
+            "events",
+            "visibility",
+            "ip_address",
+            "created_at",
+            "updated_at",
+        )
+        filterset_class = ActivityLogFilter
+
+    def resolve_events(self, info, **kwargs):
+        return MiddlewareEvents.objects.filter(pgh_context_id=self.pk)
+
+    def resolve_user(self, info, **kwargs):
+        user_id = getattr(self, "user_id", None)
+        if user_id is not None:
+            try:
+                return User.objects.get(pk=user_id)
+            except User.DoesNotExist:
+                return None
+        return getattr(self, "user", None)
+
+    def resolve_profile(self, info, **kwargs):
+        profile_id = getattr(self, "profile_id", None)
+        if profile_id is not None:
+            try:
+                return Profile.objects.get(pk=profile_id)
+            except Profile.DoesNotExist:
+                return None
+        return getattr(self, "profile", None)
+
+
+class ActivityLogObjectType(BaseActivityLogObjectType, DjangoObjectType):
+    class Meta(BaseActivityLogObjectType.Meta):
+        pass

baseapp/activity_log/graphql/queries.py

@@ -0,0 +1,17 @@
+import graphene
+from graphene_django.filter import DjangoFilterConnectionField
+
+from ..models import ActivityLog
+from .object_types import ActivityLogObjectType, VisibilityTypesEnum
+
+
+class ActivityLogQueries:
+    activity_logs = DjangoFilterConnectionField(
+        ActivityLogObjectType,
+        visibility=VisibilityTypesEnum(),
+        first=graphene.Int(default_value=10),
+        max_limit=100,
+    )
+
+    def resolve_activity_logs(self, info, visibility=None, **kwargs):
+        return ActivityLog.objects.all()

baseapp/activity_log/graphql/subscriptions.py

@@ -0,0 +1,49 @@
+import channels_graphql_ws
+import graphene
+from channels.db import database_sync_to_async
+
+from baseapp_core.graphql import get_obj_from_relay_id
+
+from .object_types import ActivityLogObjectType
+
+
+class OnNewActivityLogMessage(channels_graphql_ws.Subscription):
+    message = graphene.Field(lambda: ActivityLogObjectType._meta.connection.Edge)
+
+    class Arguments:
+        room_id = graphene.ID(required=True)
+
+    @staticmethod
+    def subscribe(root, info, room_id):
+        room = database_sync_to_async(get_obj_from_relay_id)(info, room_id)
+
+        user = info.context.channels_scope["user"]
+        if not user.is_authenticated or not database_sync_to_async(user.has_perm)(
+            "activity_log.view_activitylog", room
+        ):
+            return []
+        return [room_id]
+
+    @staticmethod
+    def publish(payload, info, room_id):
+        message = payload["message"]
+        user = info.context.channels_scope["user"]
+
+        if not user.is_authenticated:
+            return None
+
+        return OnNewActivityLogMessage(
+            message=ActivityLogObjectType._meta.connection.Edge(node=message)
+        )
+
+    @classmethod
+    def new_message(cls, message, room_id):
+        cls.broadcast(
+            group=room_id,
+            payload={"message": message},
+        )
+        OnNewActivityLogMessage.new_message(message=message)
+
+
+class ActivityLogSubscriptions:
+    on_new_activity_log = OnNewActivityLogMessage.Field()

baseapp/activity_log/middleware.py

@@ -0,0 +1,92 @@
+import pghistory
+from django.core.handlers.asgi import ASGIRequest as DjangoASGIRequest
+from django.core.handlers.wsgi import WSGIRequest as DjangoWSGIRequest
+from ipware import get_client_ip
+from pghistory import config
+
+# The default meta precedence order
+IPWARE_META_PRECEDENCE_ORDER = (
+    "X_FORWARDED_FOR",
+    "HTTP_X_FORWARDED_FOR",
+    "HTTP_CLIENT_IP",
+    "HTTP_X_REAL_IP",
+    "HTTP_X_FORWARDED",
+    "HTTP_X_CLUSTER_CLIENT_IP",
+    "HTTP_FORWARDED_FOR",
+    "HTTP_FORWARDED",
+    "HTTP_CF_CONNECTING_IP",
+    "X-CLIENT-IP",
+    "X-REAL-IP",
+    "X-CLUSTER-CLIENT-IP",
+    "X_FORWARDED",
+    "FORWARDED_FOR",
+    "CF-CONNECTING-IP",
+    "TRUE-CLIENT-IP",
+    "FASTLY-CLIENT-IP",
+    "FORWARDED",
+    "CLIENT-IP",
+    "REMOTE_ADDR",
+)
+
+
+class DjangoRequest:
+    """
+    Although Django's auth middleware sets the user in middleware,
+    apps like django-rest-framework set the user in the view layer.
+    This creates issues for pghistory tracking since the context needs
+    to be set before DB operations happen.
+
+    This special WSGIRequest updates pghistory context when
+    the request.user attribute is updated.
+    """
+
+    def __setattr__(self, attr, value):
+        if attr == "user":
+            pghistory.context(user=value.pk if value and hasattr(value, "pk") else None)
+
+        return super().__setattr__(attr, value)
+
+
+class WSGIRequest(DjangoRequest, DjangoWSGIRequest):
+    pass
+
+
+class ASGIRequest(DjangoRequest, DjangoASGIRequest):
+    pass
+
+
+def HistoryMiddleware(get_response):
+    def middleware(request):
+        if request.method in config.middleware_methods():
+            user = (
+                request.user.pk
+                if hasattr(request, "user") and hasattr(request.user, "pk")
+                else None
+            )
+            profile = (
+                request.user.current_profile.pk
+                if hasattr(request.user, "current_profile")
+                and hasattr(request.user.current_profile, "pk")
+                else None
+            )
+            client_ip, is_routable = get_client_ip(
+                request, request_header_order=IPWARE_META_PRECEDENCE_ORDER
+            )
+
+            with pghistory.context(
+                user=user,
+                profile=profile,
+                url=request.path,
+                ip_address=client_ip,
+                is_ip_routable=is_routable,
+            ):
+                if isinstance(request, DjangoWSGIRequest):  # pragma: no branch
+                    request.__class__ = WSGIRequest
+                elif isinstance(request, DjangoASGIRequest):  # pragma: no branch
+                    request.__class__ = ASGIRequest
+
+                return get_response(request)
+        else:
+            return get_response(request)
+
+    return middleware

baseapp/activity_log/migrations/0001_initial.py

@@ -0,0 +1,25 @@
+# Generated by Django 5.0.1 on 2024-11-03 00:29
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ("pghistory", "0006_delete_aggregateevent"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="ActivityLog",
+            fields=[],
+            options={
+                "proxy": True,
+                "indexes": [],
+                "constraints": [],
+            },
+            bases=("pghistory.context", models.Model),
+        ),
+    ]

baseapp/activity_log/migrations/0002_auto_20241216_1804.py

@@ -0,0 +1,29 @@
+# Generated by Django 5.1.4 on 2024-12-16 18:04
+
+from django.db import migrations
+
+CREATE_SQL = """
+create or replace view v_activity_log as select
+    pc.id as id,
+    pc.created_at as created_at,
+    pc.updated_at as updated_at,
+    nullif(metadata->>'user', '')::int8 as user_id,
+    nullif(metadata->>'profile', '')::int8 as profile_id,
+    metadata->>'url' as url,
+    metadata->>'verb' as verb,
+    nullif(metadata->>'visibility', '')::int4 as visibility,
+    metadata->>'ip_address' as ip_address,
+    metadata
+from pghistory_context pc
+"""
+
+DROP_SQL = "drop view if exists v_activity_log"
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("baseapp_activity_log", "0001_initial"),
+    ]
+
+    operations = [migrations.RunSQL(sql=CREATE_SQL, reverse_sql=DROP_SQL)]

baseapp/activity_log/migrations/0003_delete_activitylog_activitylog.py

@@ -0,0 +1,38 @@
+# Generated by Django 5.1.4 on 2024-12-16 18:08
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("baseapp_activity_log", "0002_auto_20241216_1804"),
+    ]
+
+    operations = [
+        migrations.DeleteModel(
+            name="ActivityLog",
+        ),
+        migrations.CreateModel(
+            name="ActivityLog",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False, verbose_name="ID"
+                    ),
+                ),
+                ("created_at", models.DateTimeField()),
+                ("updated_at", models.DateTimeField()),
+                ("ip_address", models.TextField()),
+                ("verb", models.TextField()),
+                ("visibility", models.TextField()),
+                ("url", models.TextField()),
+                ("metadata", models.JSONField()),
+            ],
+            options={
+                "db_table": "v_activity_log",
+                "managed": False,
+            },
+        ),
+    ]