fcm-django 3.2.0__py3-none-any.whl

fcm_django/__init__.py

@@ -0,0 +1,16 @@
+__author__ = "xTrinch"
+__email__ = "mojca.rojko@gmail.com"
+__version__ = "3.2.0"
+
+
+class NotificationError(Exception):
+    pass
+
+
+try:
+    from django import VERSION as DJANGO_VERSION
+
+    if DJANGO_VERSION < (3, 2):
+        default_app_config = "fcm_django.apps.FcmDjangoConfig"
+except ImportError:
+    pass

fcm_django/admin.py

@@ -0,0 +1,278 @@
+from typing import Union
+
+import swapper
+from django.apps import apps
+from django.contrib import admin, messages
+from django.utils.translation import gettext_lazy as _
+from django.utils.translation import ngettext_lazy
+from firebase_admin.exceptions import FirebaseError
+from firebase_admin.messaging import (
+    ErrorInfo,
+    Message,
+    Notification,
+    SendResponse,
+    TopicManagementResponse,
+)
+
+from fcm_django.models import fcm_error_list
+from fcm_django.settings import FCM_DJANGO_SETTINGS as SETTINGS
+from fcm_django.types import FirebaseResponseDict
+
+User = apps.get_model(*SETTINGS["USER_MODEL"].split("."))
+
+FCMDevice = swapper.load_model("fcm_django", "fcmdevice")
+
+
+class DeviceAdmin(admin.ModelAdmin):
+    list_display = (
+        "__str__",
+        "device_id",
+        "name",
+        "type",
+        "user",
+        "active",
+        "date_created",
+    )
+    list_filter = (
+        "active",
+        "type",
+    )
+    actions = (
+        "send_message",
+        "send_bulk_message",
+        "subscribe_to_topic",
+        "bulk_subscribe_to_topic",
+        "unsubscribe_to_topic",
+        "bulk_unsubscribe_to_topic",
+        "send_topic_message",
+        "enable",
+        "disable",
+    )
+    raw_id_fields = ("user",)
+    list_select_related = ("user",)
+
+    def get_search_fields(self, request):
+        if hasattr(User, "USERNAME_FIELD"):
+            return "name", "device_id", f"user__{User.USERNAME_FIELD}"
+        else:
+            return "name", "device_id"
+
+    def _send_deactivated_message(
+        self,
+        request,
+        response: Union[
+            FirebaseResponseDict,
+            list[FirebaseResponseDict],
+            list[tuple[SendResponse, str]],
+        ],
+        total_failure: int,
+        is_topic: bool,
+    ):
+        if total_failure == 0:
+            return
+        if is_topic:
+            message = ngettext_lazy(
+                "A device failed to un/subscribe to topic. %(count)d device was "
+                "marked as inactive.",
+                "Some devices failed to un/subscribe to topic. %(count)d devices "
+                "were marked as inactive.",
+                total_failure,
+            )
+        else:
+            message = ngettext_lazy(
+                "A message failed to send. %(count)d device was marked as " "inactive.",
+                "Some messages failed to send. %(count)d devices were marked as "
+                "inactive.",
+                total_failure,
+            )
+        self.message_user(
+            request,
+            message % {"count": total_failure},
+            level=messages.WARNING,
+        )
+
+        def _get_to_str_obj(obj):
+            if isinstance(obj, SendResponse):
+                return obj.exception
+            elif isinstance(obj, TopicManagementResponse):
+                return obj.errors
+            return obj
+
+        def _print_responses(_response):
+            __error_list = fcm_error_list + [ErrorInfo]
+            # TODO Aggregate error response text. Each firebase error
+            #  has multiple response texts too
+            [
+                self.message_user(
+                    request,
+                    (
+                        _("%(response)s (Registration ID/Tokens: %(reg_id)s)")
+                        % {"response": _get_to_str_obj(x), "reg_id": reg_id}
+                    ),
+                    level=messages.WARNING,
+                )
+                for x, reg_id in _response
+                if type(_get_to_str_obj(x)) in __error_list
+            ]
+
+        if isinstance(response, list):
+            # Our custom list of single responses
+            _print_responses(response)
+        elif isinstance(response, FirebaseResponseDict):
+            # technically, type should be: FirebaseResponseDict not just dict
+            _print_responses(
+                zip(
+                    response.response.responses,
+                    response.deactivated_registration_ids,
+                ),
+            )
+        else:
+            raise NotImplementedError
+
+    def send_messages(self, request, queryset, bulk=False):
+        """
+        Provides error handling for DeviceAdmin send_message and
+        send_bulk_message methods.
+        """
+        total_failure = 0
+        single_responses: list[tuple[SendResponse, str]] = []
+
+        try:
+            for device in queryset:
+                device: "FCMDevice"
+                if bulk:
+                    response = queryset.send_message(
+                        Message(
+                            notification=Notification(
+                                title="Test notification", body="Test bulk notification"
+                            )
+                        )
+                    )
+                    total_failure = len(response.deactivated_registration_ids)
+                    return self._send_deactivated_message(
+                        request, response, total_failure, False
+                    )
+                else:
+                    response = device.send_message(
+                        Message(
+                            notification=Notification(
+                                title="Test notification",
+                                body="Test single notification",
+                            )
+                        )
+                    )
+                    single_responses.append((response, device.registration_id))
+                    if type(response) != SendResponse:
+                        total_failure += 1
+        except FirebaseError as exc:
+            self.message_user(request, str(exc), level=messages.ERROR)
+            return
+
+        self._send_deactivated_message(request, single_responses, total_failure, False)
+
+    def send_message(self, request, queryset):
+        self.send_messages(request, queryset)
+
+    send_message.short_description = _("Send test notification")
+
+    def send_bulk_message(self, request, queryset):
+        self.send_messages(request, queryset, True)
+
+    send_bulk_message.short_description = _("Send test notification in bulk")
+
+    def handle_topic_subscription(
+        self, request, queryset, should_subscribe: bool, bulk: bool = False
+    ):
+        """
+        Provides error handling for DeviceAdmin bulk_un/subscribe_to_topic and
+        un/subscribe_to_topic methods.
+        """
+        total_failure = 0
+        single_responses = []
+
+        for device in queryset:
+            device: "FCMDevice"
+            if bulk:
+                response: "FirebaseResponseDict" = queryset.handle_topic_subscription(
+                    should_subscribe,
+                    "test-topic",
+                )
+                total_failure = response.response.failure_count
+                single_responses = [
+                    (x, response.registration_ids_sent[x.index])
+                    for x in response.response.errors
+                ]
+                break
+            else:
+                response = device.handle_topic_subscription(
+                    should_subscribe,
+                    "test-topic",
+                )
+                single_responses.append(
+                    (
+                        (
+                            response.response.errors[0]
+                            if len(response.response.errors) > 0
+                            else "Success"
+                        ),
+                        device.registration_id,
+                    )
+                )
+                total_failure += len(response.deactivated_registration_ids)
+
+        self._send_deactivated_message(request, single_responses, total_failure, True)
+
+    def subscribe_to_topic(self, request, queryset):
+        self.handle_topic_subscription(request, queryset, True)
+
+    subscribe_to_topic.short_description = _("Subscribe to test topic")
+
+    def bulk_subscribe_to_topic(self, request, queryset):
+        self.handle_topic_subscription(request, queryset, True, True)
+
+    bulk_subscribe_to_topic.short_description = _("Subscribe to test topic in bulk")
+
+    def unsubscribe_to_topic(self, request, queryset):
+        self.handle_topic_subscription(request, queryset, False)
+
+    unsubscribe_to_topic.short_description = _("Unsubscribe to test topic")
+
+    def bulk_unsubscribe_to_topic(self, request, queryset):
+        self.handle_topic_subscription(request, queryset, False, True)
+
+    bulk_unsubscribe_to_topic.short_description = _("Unsubscribe to test topic in bulk")
+
+    def handle_send_topic_message(self, request, queryset):
+        try:
+            FCMDevice.send_topic_message(
+                Message(
+                    notification=Notification(
+                        title="Test notification", body="Test single notification"
+                    )
+                ),
+                "test-topic",
+            )
+        except FirebaseError as exc:
+            self.message_user(request, str(exc), level=messages.ERROR)
+
+    def send_topic_message(self, request, queryset):
+        self.handle_send_topic_message(request, queryset)
+
+    send_topic_message.short_description = _("Send message test topic")
+
+    def enable(self, request, queryset):
+        queryset.update(active=True)
+
+    enable.short_description = _("Enable selected devices")
+
+    def disable(self, request, queryset):
+        queryset.deactivate(
+            reason="manual_disable",
+            source="admin_action",
+            metadata={},
+        )
+
+    disable.short_description = _("Disable selected devices")
+
+
+admin.site.register(FCMDevice, DeviceAdmin)

fcm_django/api/__init__.py

@@ -0,0 +1,10 @@
+from django.conf import settings
+
+if "tastypie" in settings.INSTALLED_APPS:
+    # Tastypie resources are importable from the api package level (backwards compatibility)
+    from .tastypie import APNSDeviceAuthenticatedResource, FCMDeviceResource
+
+    __all__ = [
+        "APNSDeviceAuthenticatedResource",
+        "FCMDeviceResource",
+    ]

fcm_django/api/rest_framework.py

@@ -0,0 +1,190 @@
+import swapper
+from django.db.models import Q
+from rest_framework import permissions, status
+from rest_framework.mixins import CreateModelMixin
+from rest_framework.response import Response
+from rest_framework.serializers import ModelSerializer, Serializer, ValidationError
+from rest_framework.viewsets import GenericViewSet, ModelViewSet
+
+from fcm_django.settings import FCM_DJANGO_SETTINGS as SETTINGS
+
+FCMDevice = swapper.load_model("fcm_django", "fcmdevice")
+
+
+# Serializers
+class DeviceSerializerMixin(ModelSerializer):
+    class Meta:
+        fields = (
+            "id",
+            "name",
+            "registration_id",
+            "device_id",
+            "active",
+            "date_created",
+            "type",
+        )
+        read_only_fields = ("date_created",)
+
+        extra_kwargs = {"active": {"default": True}}
+
+
+class UniqueRegistrationSerializerMixin(Serializer):
+    def validate(self, attrs):
+        devices = None
+        primary_key = None
+        request_method = None
+
+        if self.initial_data.get("registration_id", None):
+            if self.instance:
+                request_method = "update"
+                primary_key = self.instance.id
+            else:
+                request_method = "create"
+        else:
+            if self.context["request"].method in ["PUT", "PATCH"]:
+                request_method = "update"
+                primary_key = self.instance.id
+            elif self.context["request"].method == "POST":
+                request_method = "create"
+
+        Device = self.Meta.model
+        # if request authenticated, unique together with registration_id and
+        # user
+        user = self.context["request"].user
+        registration_id = attrs.get("registration_id")
+
+        if request_method == "update":
+            if registration_id:
+                if user is not None and user.is_authenticated:
+                    devices = Device.objects.filter(
+                        registration_id=registration_id
+                    ).exclude(id=primary_key)
+                    if attrs.get("active", False):
+                        devices.filter(~Q(user=user)).deactivate(
+                            reason="duplicate_registration_id",
+                            source="serializer_update",
+                            metadata={
+                                "request_method": request_method,
+                                "target_user_id": user.id,
+                            },
+                        )
+                    devices = devices.filter(user=user)
+                else:
+                    devices = Device.objects.filter(
+                        registration_id=registration_id
+                    ).exclude(id=primary_key)
+        elif request_method == "create":
+            if user is not None and user.is_authenticated:
+                devices = Device.objects.filter(registration_id=registration_id)
+                devices.filter(~Q(user=user)).deactivate(
+                    reason="duplicate_registration_id",
+                    source="serializer_create",
+                    metadata={
+                        "request_method": request_method,
+                        "target_user_id": user.id,
+                    },
+                )
+                devices = devices.filter(user=user, active=True)
+            else:
+                devices = Device.objects.filter(registration_id=registration_id)
+
+        if devices:
+            raise ValidationError({"registration_id": "This field must be unique."})
+        return attrs
+
+
+class FCMDeviceSerializer(ModelSerializer, UniqueRegistrationSerializerMixin):
+    class Meta(DeviceSerializerMixin.Meta):
+        model = FCMDevice
+
+        extra_kwargs = {"id": {"read_only": True, "required": False}}
+        extra_kwargs.update(DeviceSerializerMixin.Meta.extra_kwargs)
+
+
+# Permissions
+class IsOwner(permissions.BasePermission):
+    def has_object_permission(self, request, view, obj):
+        # must be the owner to view the object
+        return obj.user == request.user
+
+
+# Mixins
+class DeviceViewSetMixin:
+    lookup_field = "registration_id"
+
+    def create(self, request, *args, **kwargs):
+        serializer = None
+        is_update = False
+        if (
+            SETTINGS.get("UPDATE_ON_DUPLICATE_REG_ID")
+            and "registration_id" in request.data
+        ):
+            instance = self.queryset.model.objects.filter(
+                registration_id=request.data["registration_id"]
+            ).first()
+            if instance:
+                serializer = self.get_serializer(instance, data=request.data)
+                is_update = True
+        if not serializer:
+            serializer = self.get_serializer(data=request.data)
+
+        serializer.is_valid(raise_exception=True)
+        if is_update:
+            self.perform_update(serializer)
+            return Response(serializer.data)
+        else:
+            self.perform_create(serializer)
+            headers = self.get_success_headers(serializer.data)
+            return Response(
+                serializer.data, status=status.HTTP_201_CREATED, headers=headers
+            )
+
+    def perform_create(self, serializer):
+        if self.request.user.is_authenticated:
+            if SETTINGS["ONE_DEVICE_PER_USER"] and self.request.data.get(
+                "active", True
+            ):
+                FCMDevice.objects.filter(user=self.request.user).deactivate(
+                    reason="one_device_per_user",
+                    source="perform_create",
+                    metadata={"user_id": self.request.user.id},
+                )
+            return serializer.save(user=self.request.user)
+        return serializer.save()
+
+    def perform_update(self, serializer):
+        if self.request.user.is_authenticated:
+            if SETTINGS["ONE_DEVICE_PER_USER"] and self.request.data.get(
+                "active", False
+            ):
+                FCMDevice.objects.filter(user=self.request.user).deactivate(
+                    reason="one_device_per_user",
+                    source="perform_update",
+                    metadata={"user_id": self.request.user.id},
+                )
+
+            return serializer.save(user=self.request.user)
+        return serializer.save()
+
+
+class AuthorizedMixin:
+    permission_classes = (permissions.IsAuthenticated, IsOwner)
+
+    def get_queryset(self):
+        # filter all devices to only those belonging to the current user
+        return self.queryset.filter(user=self.request.user)
+
+
+# ViewSets
+class FCMDeviceViewSet(DeviceViewSetMixin, ModelViewSet):
+    queryset = FCMDevice.objects.order_by("-id")
+    serializer_class = FCMDeviceSerializer
+
+
+class FCMDeviceCreateOnlyViewSet(DeviceViewSetMixin, CreateModelMixin, GenericViewSet):
+    queryset = FCMDevice.objects.all()
+    serializer_class = FCMDeviceSerializer
+
+
+class FCMDeviceAuthorizedViewSet(AuthorizedMixin, FCMDeviceViewSet):
+    pass

fcm_django/api/tastypie.py

@@ -0,0 +1,26 @@
+import swapper
+from tastypie.authentication import BasicAuthentication
+from tastypie.authorization import Authorization
+from tastypie.resources import ModelResource
+
+FCMDevice = swapper.load_model("fcm_django", "fcmdevice")
+
+
+class FCMDeviceResource(ModelResource):
+    class Meta:
+        authorization = Authorization()
+        queryset = FCMDevice.objects.all()
+        resource_name = "device/apns"
+
+
+class APNSDeviceAuthenticatedResource(FCMDeviceResource):
+    # user = ForeignKey(UserResource, "user")
+
+    class Meta(FCMDeviceResource.Meta):
+        authentication = BasicAuthentication()
+
+    # authorization = SameUserAuthorization()
+
+    def obj_create(self, bundle, **kwargs):
+        # See https://github.com/toastdriven/django-tastypie/issues/854
+        return super().obj_create(bundle, user=bundle.request.user, **kwargs)

fcm_django/apps.py

@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from fcm_django.settings import FCM_DJANGO_SETTINGS as SETTINGS
+
+
+class FcmDjangoConfig(AppConfig):
+    name = "fcm_django"
+    verbose_name = SETTINGS["APP_VERBOSE_NAME"]

fcm_django/fields.py

@@ -0,0 +1,127 @@
+import re
+import struct
+
+from django import forms
+from django.core.validators import MaxValueValidator, MinValueValidator, RegexValidator
+from django.db import connection, models
+from django.utils.translation import gettext_lazy as _
+
+UNSIGNED_64BIT_INT_MIN_VALUE = 0
+UNSIGNED_64BIT_INT_MAX_VALUE = 2**64 - 1
+
+__all__ = ["HexadecimalField", "HexIntegerField"]
+
+hex_re = re.compile(r"^(([0-9A-f])|(0x[0-9A-f]))+$")
+signed_integer_engines = [
+    "django.db.backends.postgresql",
+    "django.db.backends.postgresql_psycopg2",
+    "django.contrib.gis.db.backends.postgis",
+    "django.db.backends.sqlite3",
+]
+
+
+def _using_signed_storage():
+    return connection.settings_dict["ENGINE"] in signed_integer_engines
+
+
+def _signed_to_unsigned_integer(value):
+    return struct.unpack("Q", struct.pack("q", value))[0]
+
+
+def _unsigned_to_signed_integer(value):
+    return struct.unpack("q", struct.pack("Q", value))[0]
+
+
+def _hex_string_to_unsigned_integer(value):
+    return int(value, 16)
+
+
+def _unsigned_integer_to_hex_string(value):
+    return hex(value).rstrip("L")
+
+
+class HexadecimalField(forms.CharField):
+    """
+    A form field that accepts only hexadecimal numbers
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.default_validators = [
+            RegexValidator(hex_re, _("Enter a valid hexadecimal number"), "invalid")
+        ]
+        super().__init__(*args, **kwargs)
+
+    def prepare_value(self, value):
+        # converts bigint from db to hex before it is displayed in admin
+        if (
+            value
+            and not isinstance(value, str)
+            and connection.vendor in ("mysql", "sqlite")
+        ):
+            value = _unsigned_integer_to_hex_string(value)
+        return super(forms.CharField, self).prepare_value(value)
+
+
+class HexIntegerField(models.BigIntegerField):
+    """
+    This field stores a hexadecimal *string* of up to 64 bits as an unsigned integer
+    on *all* backends including postgres.
+
+    Reasoning: Postgres only supports signed bigints. Since we don't care about
+    signedness, we store it as signed, and cast it to unsigned when we deal with
+    the actual value (with struct)
+
+    On sqlite and mysql, native unsigned bigint types are used. In all cases, the
+    value we deal with in python is always in hex.
+    """
+
+    validators = [
+        MinValueValidator(UNSIGNED_64BIT_INT_MIN_VALUE),
+        MaxValueValidator(UNSIGNED_64BIT_INT_MAX_VALUE),
+    ]
+
+    def db_type(self, connection):
+        engine = connection.settings_dict["ENGINE"]
+        if "mysql" in engine:
+            return "bigint unsigned"
+        elif "sqlite" in engine:
+            return "UNSIGNED BIG INT"
+        else:
+            return super().db_type(connection=connection)
+
+    def get_prep_value(self, value):
+        """Return the integer value to be stored from the hex string"""
+        if value is None or value == "":
+            return None
+        if isinstance(value, str):
+            value = _hex_string_to_unsigned_integer(value)
+        if _using_signed_storage():
+            value = _unsigned_to_signed_integer(value)
+        return value
+
+    def from_db_value(self, value, expression, connection, context):
+        """Return an unsigned int representation from all db backends"""
+        if value is None:
+            return value
+        if _using_signed_storage():
+            value = _signed_to_unsigned_integer(value)
+        return value
+
+    def to_python(self, value):
+        """Return a str representation of the hexadecimal"""
+        if isinstance(value, str):
+            return value
+        if value is None:
+            return value
+        return _unsigned_integer_to_hex_string(value)
+
+    def formfield(self, **kwargs):
+        defaults = {"form_class": HexadecimalField}
+        defaults.update(kwargs)
+        # yes, that super call is right
+        return super(models.IntegerField, self).formfield(**defaults)
+
+    def run_validators(self, value):
+        # make sure validation is performed on integer value not string value
+        value = _hex_string_to_unsigned_integer(value)
+        return super(models.BigIntegerField, self).run_validators(value)