Privacy consultation bed for camera plugin

care/facility/api/serializers/asset.py

@@ -33,9 +33,6 @@
 )
 from care.users.api.serializers.user import UserBaseMinimumSerializer
 from care.utils.assetintegration.asset_classes import AssetClasses
-from care.utils.assetintegration.hl7monitor import HL7MonitorAsset
-from care.utils.assetintegration.onvif import OnvifAsset
-from care.utils.assetintegration.ventilator import VentilatorAsset
 from care.utils.models.validators import MiddlewareDomainAddressValidator
 from care.utils.queryset.facility import get_facility_queryset
 from care.utils.serializers.fields import ChoiceField
@@ -144,6 +141,7 @@ class AssetSerializer(ModelSerializer):
     id = UUIDField(source="external_id", read_only=True)
     status = ChoiceField(choices=StatusChoices, read_only=True)
     asset_type = ChoiceField(choices=AssetTypeChoices)
+    asset_class = serializers.CharField(required=False)
     location_object = AssetLocationSerializer(source="current_location", read_only=True)
     location = UUIDField(write_only=True, required=True)
     last_service = AssetServiceSerializer(read_only=True)
@@ -166,6 +164,13 @@ def validate_qr_code_id(self, value):
         return value
 
     def validate(self, attrs):
+        if (
+            "asset_class" in attrs
+            and attrs["asset_class"] not in Asset.get_asset_class_choices()
+        ):
+            error = f"{attrs['asset_class']} is not a valid asset class"
+            raise ValidationError(error)
+
         user = self.context["request"].user
         if "location" in attrs:
             location = get_object_or_404(
@@ -233,8 +238,9 @@ def validate(self, attrs):
                     )
                     .filter(
                         asset_class__in=[
-                            AssetClasses.ONVIF.name,
-                            AssetClasses.HL7MONITOR.name,
+                            member.name
+                            for member in AssetClasses.all()
+                            if member.value.can_be_linked_to_asset_bed()  # need better naming
                         ],
                         current_location__facility=current_location.facility_id,
                         resolved_middleware_hostname=middleware_hostname,
@@ -410,25 +416,19 @@ class Meta:
 
 
 class AssetActionSerializer(Serializer):
-    def action_choices():
-        actions = [
-            OnvifAsset.OnvifActions,
-            HL7MonitorAsset.HL7MonitorActions,
-            VentilatorAsset.VentilatorActions,
-        ]
-        choices = []
-        for action in actions:
-            choices += [(e.value, e.name) for e in action]
-        return choices
-
     type = ChoiceField(
-        choices=action_choices(),
+        choices=[
+            choice
+            for asset_class in AssetClasses.all()
+            for choice in asset_class.value.get_action_choices()
+        ],
         required=True,
     )
     data = JSONField(required=False)
+    options = JSONField(required=False)
 
     class Meta:
-        fields = ("type", "data")
+        fields = ("type", "data", "options")
 
 
 class DummyAssetOperateSerializer(Serializer):

care/facility/api/serializers/bed.py

@@ -121,11 +121,16 @@ def validate(self, attrs):
                 raise ValidationError(
                     {"non_field_errors": "Asset is already linked to bed"}
                 )
-            if asset.asset_class not in [
-                AssetClasses.HL7MONITOR.name,
-                AssetClasses.ONVIF.name,
-            ]:
-                raise ValidationError({"asset": "Asset is not a monitor or camera"})
+
+            valid_asset_classes = [
+                member.name
+                for member in AssetClasses.all()
+                if member.name == "HL7MONITOR"
+            ]
+            if asset.asset_class not in valid_asset_classes:
+                raise ValidationError(
+                    {"asset": "This Asset Class cannot be linked to a bed"}
+                )
             attrs["asset"] = asset
             attrs["bed"] = bed
             if asset.current_location.facility.id != bed.facility.id:
@@ -315,6 +320,11 @@ def create(self, validated_data) -> ConsultationBed:
             if assets_ids := validated_data.pop("assets", None):
                 # we check assets in use here as they might have been in use in
                 # the previous bed
+                exclude_asset_classes = [
+                    member.name
+                    for member in AssetClasses.all()
+                    if not member.value.can_be_linked_to_consultation_bed()
+                ]
                 assets = (
                     Asset.objects.annotate(
                         is_in_use=Exists(
@@ -330,12 +340,7 @@ def create(self, validated_data) -> ConsultationBed:
                         external_id__in=assets_ids,
                         current_location__facility=consultation.facility_id,
                     )
-                    .exclude(
-                        asset_class__in=[
-                            AssetClasses.HL7MONITOR.name,
-                            AssetClasses.ONVIF.name,
-                        ]
-                    )
+                    .exclude(asset_class__in=exclude_asset_classes)
                     .values_list("external_id", flat=True)
                 )
                 not_found_assets = set(assets_ids) - set(assets)

care/facility/api/viewsets/asset.py

@@ -20,7 +20,7 @@
 from rest_framework import exceptions, status
 from rest_framework import filters as drf_filters
 from rest_framework.decorators import action
-from rest_framework.exceptions import APIException, ValidationError
+from rest_framework.exceptions import APIException, PermissionDenied, ValidationError
 from rest_framework.mixins import (
     CreateModelMixin,
     DestroyModelMixin,
@@ -74,7 +74,6 @@
 
 logger = logging.getLogger(__name__)
 
-
 inverse_asset_type = inverse_choices(AssetTypeChoices)
 inverse_asset_status = inverse_choices(StatusChoices)
 
@@ -202,20 +201,15 @@ def filter_in_use_by_consultation(self, queryset, _, value):
 
     def filter_is_permanent(self, queryset, _, value):
         if value not in EMPTY_VALUES:
+            movable_assets = [
+                member.name
+                for member in AssetClasses.all()
+                if not member.value.is_movable()
+            ]
             if value:
-                queryset = queryset.filter(
-                    asset_class__in=[
-                        AssetClasses.ONVIF.name,
-                        AssetClasses.HL7MONITOR.name,
-                    ]
-                )
+                queryset = queryset.filter(asset_class__in=movable_assets)
             else:
-                queryset = queryset.exclude(
-                    asset_class__in=[
-                        AssetClasses.ONVIF.name,
-                        AssetClasses.HL7MONITOR.name,
-                    ]
-                )
+                queryset = queryset.exclude(asset_class__in=movable_assets)
         return queryset.distinct()
 
 
@@ -385,7 +379,7 @@ def set_default_user_location(self, request, *args, **kwargs):
         tags=["asset"],
     )
     @action(detail=True, methods=["POST"])
-    def operate_assets(self, request, *args, **kwargs):
+    def operate_assets(self, request, *args, **kwargs):  # noqa: PLR0911
         """
         This API is used to operate assets. API accepts the asset_id and action as parameters.
         """
@@ -398,19 +392,34 @@ def operate_assets(self, request, *args, **kwargs):
                 or asset.current_location.middleware_address
                 or asset.current_location.facility.middleware_address
             )
+            available_asset_classes = [asset.name for asset in AssetClasses.all()]
+            if asset.asset_class not in available_asset_classes:
+                return Response(
+                    {
+                        "error": f"Cannot operate asset: Plugin for {asset.asset_class} is not installed",
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
             asset_class: BaseAssetIntegration = AssetClasses[asset.asset_class].value(
                 {
                     **asset.meta,
                     "id": str(asset.external_id),
                     "middleware_hostname": middleware_hostname,
                 }
             )
-            result = asset_class.handle_action(**request.data["action"])
+            result = asset_class.handle_action(request.user, **request.data["action"])
             return Response({"result": result}, status=status.HTTP_200_OK)
 
         except ValidationError as e:
             return Response({"detail": e.detail}, status=status.HTTP_400_BAD_REQUEST)
 
+        except PermissionDenied as e:
+            return Response(
+                {**e.detail},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
         except KeyError as e:
             return Response(
                 {"message": {key: "is required" for key in e.args}},
@@ -466,14 +475,14 @@ def list(self, request, *args, **kwargs):
                 {"middleware_hostname": "Invalid middleware hostname"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
-
         queryset = (
             self.get_queryset()
             .filter(
                 current_location__facility=self.request.user.facility,
                 asset_class__in=[
-                    AssetClasses.ONVIF.name,
-                    AssetClasses.HL7MONITOR.name,
+                    member.name
+                    for member in AssetClasses.all()
+                    if member.value.can_be_linked_to_asset_bed()  # better naming required
                 ],
             )
             .annotate(

care/facility/api/viewsets/bed.py

@@ -1,10 +1,12 @@
+from distutils.util import strtobool
 from django.core.exceptions import ValidationError as DjangoValidationError
 from django.db import IntegrityError, transaction
 from django.db.models import Exists, OuterRef, Subquery
 from django_filters import rest_framework as filters
 from drf_spectacular.utils import extend_schema, extend_schema_view
 from rest_framework import filters as drf_filters
 from rest_framework import status
+from rest_framework.decorators import action
 from rest_framework.exceptions import PermissionDenied
 from rest_framework.exceptions import ValidationError as DRFValidationError
 from rest_framework.fields import get_error_detail
@@ -230,3 +232,37 @@ def get_queryset(self):
             allowed_facilities = get_accessible_facilities(user)
             queryset = queryset.filter(bed__facility__id__in=allowed_facilities)
         return queryset
+
+    @action(detail=True, methods=["patch"])
+    def set_privacy(self, request, external_id):
+        consultation_bed: ConsultationBed = self.get_object()
+
+        is_privacy_enabled = request.data.get("is_privacy_enabled")
+
+        if is_privacy_enabled is None:
+            return Response(
+                {"detail": "is_privacy_enabled is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        try:
+            is_privacy_enabled = strtobool(is_privacy_enabled)
+        except (ValueError, TypeError):
+            return Response(
+                {"detail": "is_privacy_enabled should be a boolean"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        if not consultation_bed.consultation.patient.has_object_update_permission(
+            request
+        ) or request.user.user_type in [
+            User.TYPE_VALUE_MAP["DistrictLabAdmin"],
+            User.TYPE_VALUE_MAP["StateLabAdmin"],
+        ]:
+            raise PermissionDenied
+
+        consultation_bed.is_privacy_enabled = is_privacy_enabled
+        consultation_bed.save(update_fields=["is_privacy_enabled"])
+
+        return Response(
+            ConsultationBedSerializer(consultation_bed).data, status=status.HTTP_200_OK
+        )