firefighter-incident 0.0.1__py3-none-any.whl

firefighter/_version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.0.1'
+__version_tuple__ = version_tuple = (0, 0, 1)

firefighter/api/__init__.py

@@ -0,0 +1,4 @@
+"""The `api` app exposes the API endpoints for the application.
+
+It uses the `rest_framework` package to provide the API endpoints.
+"""

firefighter/api/admin.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from django.contrib import messages
+from rest_framework.authtoken.admin import TokenAdmin
+from rest_framework.authtoken.models import TokenProxy
+
+from firefighter.api.models import APITokenProxy
+from firefighter.firefighter.admin import admin_custom as admin
+from firefighter.incidents.models.user import User
+
+logger = logging.getLogger(__name__)
+
+
+if TYPE_CHECKING:
+    from django.db.models import ForeignKey
+    from django.db.models.query import QuerySet
+    from django.forms import ModelChoiceField, ModelForm
+    from django.http.request import HttpRequest as BaseHttpRequest
+
+    class HttpRequest(BaseHttpRequest):
+        user: User
+
+
+class APITokenAdmin(TokenAdmin):
+    """Custom Admin for DRF Token.
+    Add supports for custom permissions.
+    """
+
+    def formfield_for_foreignkey(self, db_field: ForeignKey[Any, Any], request: HttpRequest, **kwargs: Any) -> ModelChoiceField:  # type: ignore[override]
+        """Show all or only current user depending on permissions."""
+        if db_field.name == "user":
+            if request.user.has_perm("api.can_add_any") or request.user.has_perm(
+                "api.can_edit_any"
+            ):
+                kwargs["queryset"] = User.objects.all()
+            elif request.user.has_perm("api.can_add_own"):
+                kwargs["queryset"] = User.objects.filter(id=request.user.id)
+        return super().formfield_for_foreignkey(db_field, request, **kwargs)
+
+    def get_form(self, request: HttpRequest, obj: APITokenProxy | None = None, change: bool = False, **kwargs: Any) -> type[ModelForm[APITokenProxy]]:  # type: ignore[override] # noqa: FBT001, FBT002
+        """Prefill the form with the current user."""
+        form: type[ModelForm[APITokenProxy]] = super().get_form(
+            request, obj, change, **kwargs
+        )
+        form.base_fields["user"].initial = request.user
+        return form
+
+    def get_queryset(self, request: HttpRequest) -> QuerySet[APITokenProxy]:  # type: ignore[override]
+        """Show all or only own tokens depending on permissions."""
+        qs = super().get_queryset(request)
+        if request.user.has_perm("api.can_view_any"):
+            return qs
+        return qs.filter(user=request.user)
+
+    def get_sortable_by(self, request: HttpRequest):  # type: ignore[no-untyped-def,override]
+        """Hack to send a message depending on the status of the user."""
+        if request.user.has_perm("api.can_view_any"):
+            self.message_user(request, "You are seeing all tokens.", messages.WARNING)
+        elif request.user.has_perm("api.can_view_own"):
+            self.message_user(
+                request, "You are only seeing your tokens.", messages.WARNING
+            )
+        return super().get_sortable_by(request)
+
+    def has_view_permission(self, request: HttpRequest, obj: APITokenProxy | None = None) -> bool:  # type: ignore[override]
+        if obj is None:
+            return request.user.has_perm("api.can_view_any") or request.user.has_perm(
+                "api.can_view_own"
+            )
+        if request.user.has_perm("api.can_view_any"):
+            return True
+        if request.user.has_perm("api.can_view_own"):
+            return bool(obj.user == request.user)
+        return False
+
+    def has_add_permission(self, request: HttpRequest) -> bool:  # type: ignore[override]
+        return request.user.has_perm("api.can_add_any") or request.user.has_perm(
+            "api.can_add_own"
+        )
+
+    def has_delete_permission(self, request: HttpRequest, obj: APITokenProxy | None = None) -> bool:  # type: ignore[override]
+        if obj is None:
+            return request.user.has_perm("api.can_delete_any") or request.user.has_perm(
+                "api.can_delete_own"
+            )
+        if request.user.has_perm("api.can_delete_any"):
+            return True
+        if request.user.has_perm("api.can_delete_own"):
+            return bool(obj.user == request.user)
+        return False
+
+    def has_change_permission(self, request: HttpRequest, obj: APITokenProxy | None = None) -> bool:  # type: ignore[override]
+        if obj is None:
+            return request.user.has_perm("api.can_edit_any")
+        if request.user.has_perm("api.can_edit_any"):
+            return True
+        return False
+
+
+# Remove the default TokenAdmin created by DRF and replace it with our custom one.
+admin.site.unregister(TokenProxy)
+admin.site.register(APITokenProxy, APITokenAdmin)

firefighter/api/apps.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from django.apps import AppConfig
+
+
+class ApiConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    label = "api"
+    name = "firefighter.api"

firefighter/api/authentication.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rest_framework.authentication import TokenAuthentication
+
+if TYPE_CHECKING:
+    from django.db.models import Model
+
+
+class BearerTokenAuthentication(TokenAuthentication):
+    """To use `Authorization: Bearer <token>` instead of `Authorization: Token <token>`."""
+
+    keyword = "Bearer"
+
+    def get_model(self) -> type[Model]:
+        # ruff: noqa: PLC0415
+        from firefighter.api.models import APIToken
+
+        return APIToken

firefighter/api/migrations/0001_initial.py

@@ -0,0 +1,49 @@
+# Generated by Django 3.2.8 on 2021-11-07 16:58
+
+from __future__ import annotations
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = [
+        ("authtoken", "0003_tokenproxy"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="APIToken",
+            fields=[],
+            options={
+                "proxy": True,
+                "default_permissions": [],
+                "indexes": [],
+                "constraints": [],
+            },
+            bases=("authtoken.token",),
+        ),
+        migrations.CreateModel(
+            name="APITokenProxy",
+            fields=[],
+            options={
+                "verbose_name": "API Token",
+                "permissions": (
+                    ("can_edit_any", "Can reassign token to any user"),
+                    ("can_add_any", "Can add token to any user"),
+                    ("can_view_any", "Can view token of all users"),
+                    ("can_delete_any", "Can delete token of any user"),
+                    ("can_add_own", "Can add own tokens"),
+                    ("can_view_own", "Can view own tokens"),
+                    ("can_delete_own", "Can delete own tokens"),
+                ),
+                "abstract": False,
+                "proxy": True,
+                "default_permissions": [],
+                "indexes": [],
+                "constraints": [],
+            },
+            bases=("api.apitoken",),
+        ),
+    ]

firefighter/api/migrations/0002_alter_apitokenproxy_options.py

@@ -0,0 +1,28 @@
+# Generated by Django 4.2.3 on 2023-07-04 09:06
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("api", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name="apitokenproxy",
+            options={
+                "default_permissions": [],
+                "permissions": [
+                    ("can_edit_any", "Can reassign token to any user"),
+                    ("can_add_any", "Can add token to any user"),
+                    ("can_view_any", "Can view token of all users"),
+                    ("can_delete_any", "Can delete token of any user"),
+                    ("can_add_own", "Can add own tokens"),
+                    ("can_view_own", "Can view own tokens"),
+                    ("can_delete_own", "Can delete own tokens"),
+                ],
+                "verbose_name": "API Token",
+            },
+        ),
+    ]

firefighter/api/models.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import uuid
+from typing import TYPE_CHECKING, ClassVar, Self, cast
+
+from django.conf import settings
+from django.utils.translation import gettext_lazy as _
+from django_stubs_ext.db.models import TypedModelMeta
+from rest_framework.authtoken.models import Token
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+class APIToken(Token):
+    class Meta(TypedModelMeta):
+        default_permissions: ClassVar[Sequence[str]] = []
+        proxy = True
+
+
+class APITokenProxy(APIToken):
+    """Proxy mapping pk to user pk for use in admin.
+
+    Overrides default permissions.
+    """
+
+    @property
+    def pk(self: Self) -> uuid.UUID:
+        return cast(uuid.UUID, self.user_id)  # pyright: ignore[reportGeneralTypeIssues]
+
+    class Meta(TypedModelMeta):
+        permissions = [
+            ("can_edit_any", "Can reassign token to any user"),
+            ("can_add_any", "Can add token to any user"),
+            ("can_view_any", "Can view token of all users"),
+            ("can_delete_any", "Can delete token of any user"),
+            ("can_add_own", "Can add own tokens"),
+            ("can_view_own", "Can view own tokens"),
+            ("can_delete_own", "Can delete own tokens"),
+        ]
+        default_permissions: ClassVar[Sequence[str]] = []
+        proxy = "rest_framework.authtoken" in settings.INSTALLED_APPS
+        abstract = "rest_framework.authtoken" not in settings.INSTALLED_APPS
+        verbose_name = _("API Token")
+        verbose_name_plural = _("API Tokens")

firefighter/api/permissions.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from rest_framework.permissions import DjangoModelPermissions
+
+
+class StrictDjangoModelPermissions(DjangoModelPermissions):
+    """Custom class to restrict GET requests."""
+
+    # Map methods into required permission codes.
+    perms_map = {
+        "GET": ["%(app_label)s.view_%(model_name)s"],
+        "OPTIONS": [],
+        "HEAD": [],
+        "POST": ["%(app_label)s.add_%(model_name)s"],
+        "PUT": ["%(app_label)s.change_%(model_name)s"],
+        "PATCH": ["%(app_label)s.change_%(model_name)s"],
+        "DELETE": ["%(app_label)s.delete_%(model_name)s"],
+    }

firefighter/api/renderer.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import logging
+import re
+from functools import cache
+from typing import TYPE_CHECKING, Any
+
+from rest_framework_csv.renderers import CSVRenderer as BaseCSVRenderer
+
+if TYPE_CHECKING:
+    from collections.abc import Generator, Iterable
+
+logger = logging.getLogger(__name__)
+
+
+class CSVRenderer(BaseCSVRenderer):
+    """Renderer which serializes to CSV
+    Override the default CSV Renderer to allow hiding header fields.
+    Hide head by setting labels to "__hidden__".
+    """
+
+    def tablize(
+        self, data: Any, header: Any | None = None, labels: Any | None = None
+    ) -> Generator[list[Any], None, None]:
+        """Convert a list of data into a table.
+
+        If there is a header provided to tablize it will efficiently yield each
+        row as needed. If no header is provided, tablize will need to process
+        each row in the data in order to construct a complete header. Thus, if
+        you have a lot of data and want to stream it, you should probably
+        provide a header to the renderer (using the `header` attribute, or via
+        the `renderer_context`).
+        """
+        # Try to pull the header off of the data, if it's not passed in as an
+        # argument.
+        if not header and hasattr(data, "header"):
+            header = data.header
+
+        if data:
+            # First, flatten the data (i.e., convert it to a list of
+            # dictionaries that are each exactly one level deep).  The key for
+            # each item designates the name of the column that the item will
+            # fall into.
+            data = self.flatten_data(data)
+
+            # Get the set of all unique headers, and sort them (unless already provided).
+            data, header = self._get_headers(data, header)
+
+            # Return your "table", with the headers as the first row.
+            if labels != "__hidden__":
+                if labels:
+                    yield [labels.get(x, x) for x in header]
+                else:
+                    yield header
+
+            # Create a row for each dictionary, filling in columns for which the
+            # item has no data with None values.
+            for item in data:
+                row = [item.get(key, None) for key in header]
+                yield row
+
+        elif header:
+            # If there's no data but a header was supplied, yield the header.
+            if labels:
+                yield [labels.get(x, x) for x in header]
+            else:
+                yield header
+
+        else:
+            # Generator will yield nothing if there's no data and no header
+            pass
+
+    def _get_headers(
+        self, data: Iterable[Any], header: None | list[str]
+    ) -> tuple[Iterable[Any], list[str]]:
+        # If we already have a header, and it does not contain any wildcards,
+        # we can use it as-is.
+        has_wildcards = any(".*." in x for x in header) if header else False
+        if header and not has_wildcards:
+            return data, header
+
+        # We have to materialize the data in order to get the headers.
+        data = tuple(data)
+        header_fields: set[str] = set()
+        for item in data:
+            header_fields.update(list(item.keys()))
+
+        if not has_wildcards:
+            return data, sorted(header_fields)
+        if header is None:
+            header = sorted(header_fields)
+
+        to_expand: list[str] = [x for x in header if ".*." in x]
+        expanded_headers: dict[str, list[str]] = {
+            key: sorted([x for x in header_fields if self._get_regex(key).match(x)])
+            for key in to_expand
+        }
+
+        return data, [x for h in header for x in expanded_headers.get(h, [h])]
+
+    @staticmethod
+    @cache
+    def _get_regex(header: str) -> re.Pattern[str]:
+        regex = header.replace(".*.", ".+")
+        return re.compile(f"^{regex}$")
+
+
+class TSVRenderer(CSVRenderer):
+    """Renderer which serializes to TSV."""
+
+    media_type = "text/tab-separated-values"
+    format = "tsv"
+    writer_opts = {
+        "dialect": "excel-tab",
+    }