Improved asset bed relations for camera preset

care/facility/api/serializers/camera_preset.py

@@ -0,0 +1,49 @@
+from rest_framework import serializers
+from rest_framework.exceptions import ValidationError
+
+from care.facility.api.serializers.bed import AssetBedSerializer
+from care.facility.models import CameraPreset
+from care.users.api.serializers.user import UserBaseMinimumSerializer
+
+
+class CameraPresetSerializer(serializers.ModelSerializer):
+    id = serializers.UUIDField(source="external_id", read_only=True)
+    created_by = UserBaseMinimumSerializer(read_only=True)
+    updated_by = UserBaseMinimumSerializer(read_only=True)
+    asset_bed = AssetBedSerializer(read_only=True)
+
+    class Meta:
+        model = CameraPreset
+        exclude = (
+            "external_id",
+            "deleted",
+        )
+        read_only_fields = (
+            "created_date",
+            "modified_date",
+            "is_migrated",
+            "created_by",
+            "updated_by",
+        )
+
+    def get_asset_bed_obj(self):
+        return (
+            self.instance.asset_bed if self.instance else self.context.get("asset_bed")
+        )
+
+    def validate_name(self, value):
+        if CameraPreset.objects.filter(
+            asset_bed__bed_id=self.get_asset_bed_obj().bed_id, name=value
+        ).exists():
+            msg = "Name should be unique. Another preset related to this bed already uses the same name."
+            raise ValidationError(msg)
+        return value
+
+    def create(self, validated_data):
+        validated_data["created_by"] = self.context["request"].user
+        validated_data["asset_bed"] = self.get_asset_bed_obj()
+        return super().create(validated_data)
+
+    def update(self, instance, validated_data):
+        validated_data["updated_by"] = self.context["request"].user
+        return super().update(instance, validated_data)

care/facility/api/viewsets/asset.py

@@ -62,6 +62,7 @@
 from care.utils.assetintegration.asset_classes import AssetClasses
 from care.utils.cache.cache_allowed_facilities import get_accessible_facilities
 from care.utils.filters.choicefilter import CareChoiceFilter, inverse_choices
+from care.utils.queryset.asset_bed import get_asset_queryset
 from care.utils.queryset.asset_location import get_asset_location_queryset
 from care.utils.queryset.facility import get_facility_queryset
 from config.authentication import MiddlewareAuthentication
@@ -290,21 +291,7 @@ class AssetViewSet(
     filterset_class = AssetFilter
 
     def get_queryset(self):
-        user = self.request.user
-        queryset = self.queryset
-        if user.is_superuser:
-            pass
-        elif user.user_type >= User.TYPE_VALUE_MAP["StateLabAdmin"]:
-            queryset = queryset.filter(current_location__facility__state=user.state)
-        elif user.user_type >= User.TYPE_VALUE_MAP["DistrictLabAdmin"]:
-            queryset = queryset.filter(
-                current_location__facility__district=user.district
-            )
-        else:
-            allowed_facilities = get_accessible_facilities(user)
-            queryset = queryset.filter(
-                current_location__facility__id__in=allowed_facilities
-            )
+        queryset = get_asset_queryset(user=self.request.user, queryset=self.queryset)
         return queryset.annotate(
             latest_status=Subquery(
                 AvailabilityRecord.objects.filter(

care/facility/api/viewsets/bed.py

@@ -30,6 +30,7 @@
 from care.users.models import User
 from care.utils.cache.cache_allowed_facilities import get_accessible_facilities
 from care.utils.filters.choicefilter import CareChoiceFilter, inverse_choices
+from care.utils.queryset.asset_bed import get_asset_bed_queryset, get_bed_queryset
 
 inverse_bed_type = inverse_choices(BedTypeChoices)
 
@@ -76,27 +77,14 @@
     filterset_class = BedFilter
 
     def get_queryset(self):
-        user = self.request.user
-        queryset = self.queryset
-
-        queryset = queryset.annotate(
+        queryset = self.queryset.annotate(
             is_occupied=Exists(
                 ConsultationBed.objects.filter(
                     bed__id=OuterRef("id"), end_date__isnull=True
                 )
             )
         )
-
-        if user.is_superuser:
-            pass
-        elif user.user_type >= User.TYPE_VALUE_MAP["StateLabAdmin"]:
-            queryset = queryset.filter(facility__state=user.state)
-        elif user.user_type >= User.TYPE_VALUE_MAP["DistrictLabAdmin"]:
-            queryset = queryset.filter(facility__district=user.district)
-        else:
-            allowed_facilities = get_accessible_facilities(user)
-            queryset = queryset.filter(facility__id__in=allowed_facilities)
-        return queryset
+        return get_bed_queryset(user=self.request.user, queryset=queryset)
 
     @transaction.atomic
     def create(self, request, *args, **kwargs):
@@ -168,18 +156,7 @@
     lookup_field = "external_id"
 
     def get_queryset(self):
-        user = self.request.user
-        queryset = self.queryset
-        if user.is_superuser:
-            pass
-        elif user.user_type >= User.TYPE_VALUE_MAP["StateLabAdmin"]:
-            queryset = queryset.filter(bed__facility__state=user.state)
-        elif user.user_type >= User.TYPE_VALUE_MAP["DistrictLabAdmin"]:
-            queryset = queryset.filter(bed__facility__district=user.district)
-        else:
-            allowed_facilities = get_accessible_facilities(user)
-            queryset = queryset.filter(bed__facility__id__in=allowed_facilities)
-        return queryset
+        return get_asset_bed_queryset(user=self.request.user, queryset=self.queryset)
 
 
 class PatientAssetBedFilter(filters.FilterSet):
@@ -212,20 +189,9 @@
     ]
 
     def get_queryset(self):
-        user = self.request.user
-        queryset = self.queryset
-        if user.is_superuser:
-            pass
-        elif user.user_type >= User.TYPE_VALUE_MAP["StateLabAdmin"]:
-            queryset = queryset.filter(bed__facility__state=user.state)
-        elif user.user_type >= User.TYPE_VALUE_MAP["DistrictLabAdmin"]:
-            queryset = queryset.filter(bed__facility__district=user.district)
-        else:
-            allowed_facilities = get_accessible_facilities(user)
-            queryset = queryset.filter(bed__facility__id__in=allowed_facilities)
-        return queryset.filter(
-            bed__facility__external_id=self.kwargs["facility_external_id"]
-        )
+        return get_asset_bed_queryset(
+            user=self.request.user, queryset=self.queryset
+        ).filter(bed__facility__external_id=self.kwargs["facility_external_id"])
 
 
 class ConsultationBedFilter(filters.FilterSet):

care/facility/api/viewsets/camera_preset.py

@@ -0,0 +1,63 @@
+from django.shortcuts import get_object_or_404
+from rest_framework.exceptions import NotFound
+from rest_framework.mixins import ListModelMixin
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.viewsets import GenericViewSet, ModelViewSet
+
+from care.facility.api.serializers.camera_preset import CameraPresetSerializer
+from care.facility.models import CameraPreset
+from care.utils.queryset.asset_bed import (
+    get_asset_bed_queryset,
+    get_asset_queryset,
+    get_bed_queryset,
+)
+
+
+class AssetBedCameraPresetViewSet(ModelViewSet):
+    serializer_class = CameraPresetSerializer
+    queryset = CameraPreset.objects.all().select_related(
+        "asset_bed", "created_by", "updated_by"
+    )
+    lookup_field = "external_id"
+    permission_classes = (IsAuthenticated,)
+
+    def get_asset_bed_obj(self):
+        queryset = get_asset_bed_queryset(self.request.user).filter(
+            external_id=self.kwargs["assetbed_external_id"]
+        )
+        return get_object_or_404(queryset)
+
+    def get_queryset(self):
+        return super().get_queryset().filter(asset_bed=self.get_asset_bed_obj())
+
+    def get_serializer_context(self):
+        context = super().get_serializer_context()
+        context["asset_bed"] = self.get_asset_bed_obj()
+        return context
+
+
+class CameraPresetViewSet(GenericViewSet, ListModelMixin):
+    serializer_class = CameraPresetSerializer
+    queryset = CameraPreset.objects.all().select_related(
+        "asset_bed", "created_by", "updated_by"
+    )
+    lookup_field = "external_id"
+    permission_classes = (IsAuthenticated,)
+
+    def get_bed_obj(self, external_id: str):
+        queryset = get_bed_queryset(self.request.user).filter(external_id=external_id)
+        return get_object_or_404(queryset)
+
+    def get_asset_obj(self, external_id: str):
+        queryset = get_asset_queryset(self.request.user).filter(external_id=external_id)
+        return get_object_or_404(queryset)
+
+    def get_queryset(self):
+        queryset = super().get_queryset()
+        if asset_external_id := self.kwargs.get("asset_external_id"):
+            return queryset.filter(
+                asset_bed__asset=self.get_asset_obj(asset_external_id)
+            )
+        if bed_external_id := self.kwargs.get("bed_external_id"):
+            return queryset.filter(asset_bed__bed=self.get_bed_obj(bed_external_id))
+        raise NotFound

care/facility/migrations/0466_camera_presets.py

@@ -0,0 +1,171 @@
+# Generated by Django 4.2.8 on 2024-05-30 06:56
+
+import uuid
+
+import django.db.models.deletion
+from django.conf import settings
+from django.core.paginator import Paginator
+from django.db import migrations, models
+from django.db.models import F, Window
+from django.db.models.functions import RowNumber
+
+import care.utils.models.validators
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("facility", "0465_merge_20240923_1045"),
+    ]
+
+    def delete_asset_beds_without_asset_class(apps, schema_editor):
+        AssetBed = apps.get_model("facility", "AssetBed")
+        AssetBed.objects.filter(asset__asset_class__isnull=True).delete()
+
+    def backfill_camera_presets(apps, schema_editor):
+        AssetBed = apps.get_model("facility", "AssetBed")
+        CameraPreset = apps.get_model("facility", "CameraPreset")
+
+        paginator = Paginator(
+            AssetBed.objects.annotate(
+                row_number=Window(
+                    expression=RowNumber(),
+                    partition_by=[F("asset"), F("bed")],
+                    order_by=F("id").asc(),
+                )
+            )
+            .filter(deleted=False, asset__asset_class="ONVIF")
+            .order_by("asset", "bed", "id"),
+            1000,
+        )
+
+        for page_number in paginator.page_range:
+            assetbeds_to_delete = []
+            presets_to_create = []
+
+            for asset_bed in paginator.page(page_number).object_list:
+                name = asset_bed.meta.get("preset_name")
+
+                if position := asset_bed.meta.get("position"):
+                    presets_to_create.append(
+                        CameraPreset(
+                            name=name,
+                            asset_bed=AssetBed.objects.filter(
+                                asset=asset_bed.asset, bed=asset_bed.bed
+                            ).order_by("id")[0],
+                            position={
+                                "x": position["x"],
+                                "y": position["y"],
+                                "zoom": position["zoom"],
+                            },
+                            is_migrated=True,
+                        )
+                    )
+                    if asset_bed.row_number != 1:
+                        assetbeds_to_delete.append(asset_bed.id)
+                else:
+                    assetbeds_to_delete.append(asset_bed.id)
+
+            CameraPreset.objects.bulk_create(presets_to_create)
+            AssetBed.objects.filter(id__in=assetbeds_to_delete).update(
+                deleted=True, meta={}
+            )
+        AssetBed.objects.filter(deleted=False, asset__asset_class="ONVIF").update(
+            meta={}
+        )
+
+    operations = [
+        migrations.CreateModel(
+            name="CameraPreset",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "external_id",
+                    models.UUIDField(db_index=True, default=uuid.uuid4, unique=True),
+                ),
+                (
+                    "created_date",
+                    models.DateTimeField(auto_now_add=True, db_index=True, null=True),
+                ),
+                (
+                    "modified_date",
+                    models.DateTimeField(auto_now=True, db_index=True, null=True),
+                ),
+                ("deleted", models.BooleanField(db_index=True, default=False)),
+                ("name", models.CharField(max_length=255, null=True)),
+                (
+                    "position",
+                    models.JSONField(
+                        validators=[
+                            care.utils.models.validators.JSONFieldSchemaValidator(
+                                {
+                                    "$schema": "http://json-schema.org/draft-07/schema#",
+                                    "additionalProperties": False,
+                                    "properties": {
+                                        "x": {"type": "number"},
+                                        "y": {"type": "number"},
+                                        "zoom": {"type": "number"},
+                                    },
+                                    "required": ["x", "y", "zoom"],
+                                    "type": "object",
+                                }
+                            )
+                        ],
+                    ),
+                ),
+                ("is_migrated", models.BooleanField(default=False)),
+                (
+                    "asset_bed",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="camera_presets",
+                        to="facility.assetbed",
+                    ),
+                ),
+                (
+                    "created_by",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="+",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+                (
+                    "updated_by",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="+",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+        ),
+        migrations.RunPython(
+            delete_asset_beds_without_asset_class,
+            migrations.RunPython.noop,
+        ),
+        migrations.RunPython(
+            backfill_camera_presets,
+            migrations.RunPython.noop,
+        ),
+        migrations.AddConstraint(
+            model_name="assetbed",
+            constraint=models.UniqueConstraint(
+                condition=models.Q(("deleted", False)),
+                fields=("asset", "bed"),
+                name="unique_together_asset_bed",
+            ),
+        ),
+    ]