feat: Add service request history for asset

care/facility/api/serializers/asset.py

@@ -1,9 +1,10 @@
-import enum
 from datetime import datetime
 
 from django.core.cache import cache
 from django.db import transaction
 from django.shortcuts import get_object_or_404
+from django.utils.timezone import now
+from rest_framework import serializers
 from rest_framework.exceptions import ValidationError
 from rest_framework.serializers import (
     CharField,
@@ -20,6 +21,8 @@
     Asset,
     AssetAvailabilityRecord,
     AssetLocation,
+    AssetService,
+    AssetServiceEdit,
     AssetTransaction,
     UserDefaultAssetLocation,
 )
@@ -61,12 +64,62 @@ class Meta:
         read_only_fields = TIMESTAMP_FIELDS
 
 
+class AssetBareMinimumSerializer(ModelSerializer):
+    id = UUIDField(source="external_id", read_only=True)
+
+    class Meta:
+        model = Asset
+        fields = ("name", "id")
+
+
+class AssetServiceEditSerializer(ModelSerializer):
+    id = UUIDField(source="asset_service.external_id", read_only=True)
+    edited_by = UserBaseMinimumSerializer(read_only=True)
+
+    class Meta:
+        model = AssetServiceEdit
+        exclude = ("asset_service",)
+
+
+class AssetServiceSerializer(ModelSerializer):
+    id = UUIDField(source="external_id", read_only=True)
+    edits = AssetServiceEditSerializer(many=True)
+
+    class Meta:
+        model = AssetService
+        exclude = ("deleted",)
+
+    def update(self, instance, validated_data):
+        user = self.context["request"].user
+        serviced_on = validated_data.get("serviced_on", instance.serviced_on)
+        note = validated_data.get("note", instance.note)
+        if serviced_on == instance.serviced_on and note == instance.note:
+            return instance
+
+        with transaction.atomic():
+            edit = AssetServiceEdit(
+                asset_service=instance,
+                edited_on=now(),
+                edited_by=user,
+                serviced_on=serviced_on,
+                note=note,
+            )
+            edit.save()
+
+            updated_instance = super().update(instance, validated_data)
+
+        return updated_instance
+
+
 class AssetSerializer(ModelSerializer):
     id = UUIDField(source="external_id", read_only=True)
     status = ChoiceField(choices=Asset.StatusChoices, read_only=True)
     asset_type = ChoiceField(choices=Asset.AssetTypeChoices)
     location_object = AssetLocationSerializer(source="current_location", read_only=True)
     location = UUIDField(write_only=True, required=True)
+    last_service = AssetServiceSerializer(read_only=True)
+    last_serviced_on = serializers.DateField(write_only=True, required=False)
+    note = serializers.CharField(write_only=True, required=False)
 
     class Meta:
         model = Asset
@@ -125,10 +178,48 @@ def validate(self, attrs):
 
         return super().validate(attrs)
 
+    def create(self, validated_data):
+        last_serviced_on = validated_data.pop("last_serviced_on", None)
+        note = validated_data.pop("note", None)
+        with transaction.atomic():
+            asset_instance = super().create(validated_data)
+            if last_serviced_on or note:
+                asset_service = AssetService(
+                    asset=asset_instance, serviced_on=last_serviced_on, note=note
+                )
+                asset_service.save()
+                asset_instance.last_service = asset_service
+                asset_instance.save(update_fields=["last_service"])
+        return asset_instance
+
     def update(self, instance, validated_data):
         user = self.context["request"].user
-
         with transaction.atomic():
+            if validated_data.get("last_serviced_on") and (
+                not instance.last_service
+                or instance.last_service.serviced_on
+                != validated_data.get(
+                    "last_serviced_on", instance.last_service.serviced_on
+                )
+                or instance.last_service.note
+                != validated_data.get("note", instance.last_service.note)
+            ):
+                asset_service = AssetService(
+                    asset=instance,
+                    serviced_on=validated_data.get("last_serviced_on"),
+                    note=validated_data.get("note"),
+                )
+                asset_service_initial_edit = AssetServiceEdit(
+                    asset_service=asset_service,
+                    edited_on=now(),
+                    edited_by=user,
+                    serviced_on=asset_service.serviced_on,
+                    note=asset_service.note,
+                )
+                asset_service.save()
+                asset_service_initial_edit.save()
+                instance.last_service = asset_service
+
             if (
                 "current_location" in validated_data
                 and instance.current_location != validated_data["current_location"]
@@ -151,14 +242,6 @@ def update(self, instance, validated_data):
         return updated_instance
 
 
-class AssetBareMinimumSerializer(ModelSerializer):
-    id = UUIDField(source="external_id", read_only=True)
-
-    class Meta:
-        model = Asset
-        fields = ("name", "id")
-
-
 class AssetTransactionSerializer(ModelSerializer):
     id = UUIDField(source="external_id", read_only=True)
     asset = AssetBareMinimumSerializer(read_only=True)
@@ -190,7 +273,7 @@ class Meta:
 
 class AssetActionSerializer(Serializer):
     def actionChoices():
-        actions: list[enum.Enum] = [
+        actions = [
             OnvifAsset.OnvifActions,
             HL7MonitorAsset.HL7MonitorActions,
             VentilatorAsset.VentilatorActions,

care/facility/api/viewsets/asset.py

@@ -26,6 +26,7 @@
     AssetAvailabilitySerializer,
     AssetLocationSerializer,
     AssetSerializer,
+    AssetServiceSerializer,
     AssetTransactionSerializer,
     DummyAssetOperateResponseSerializer,
     DummyAssetOperateSerializer,
@@ -35,6 +36,7 @@
     Asset,
     AssetAvailabilityRecord,
     AssetLocation,
+    AssetService,
     AssetTransaction,
     UserDefaultAssetLocation,
 )
@@ -338,3 +340,54 @@ def get_queryset(self):
                 | Q(to_location__facility__id__in=allowed_facilities)
             )
         return queryset
+
+
+class AssetServiceFilter(filters.FilterSet):
+    qr_code_id = filters.CharFilter(field_name="asset__qr_code_id")
+    external_id = filters.CharFilter(field_name="asset__external_id")
+
+
+class AssetServiceViewSet(
+    ListModelMixin,
+    RetrieveModelMixin,
+    UpdateModelMixin,
+    GenericViewSet,
+):
+    queryset = (
+        AssetService.objects.all()
+        .select_related(
+            "asset",
+        )
+        .prefetch_related("edits")
+        .order_by("-created_date")
+    )
+    serializer_class = AssetServiceSerializer
+
+    permission_classes = (IsAuthenticated,)
+
+    lookup_field = "external_id"
+
+    filter_backends = (filters.DjangoFilterBackend,)
+    filterset_class = AssetServiceFilter
+
+    def get_queryset(self):
+        user = self.request.user
+        queryset = self.queryset.filter(
+            asset__external_id=self.kwargs.get("asset_external_id")
+        )
+        if user.is_superuser:
+            pass
+        elif user.user_type >= User.TYPE_VALUE_MAP["StateLabAdmin"]:
+            queryset = queryset.filter(
+                asset__current_location__facility__state=user.state
+            )
+        elif user.user_type >= User.TYPE_VALUE_MAP["DistrictLabAdmin"]:
+            queryset = queryset.filter(
+                asset__current_location__facility__district=user.district
+            )
+        else:
+            allowed_facilities = get_accessible_facilities(user)
+            queryset = queryset.filter(
+                asset__current_location__facility__id__in=allowed_facilities
+            )
+        return queryset

care/facility/migrations/0380_assetservice_remove_asset_last_serviced_on_and_more.py

@@ -0,0 +1,136 @@
+# Generated by Django 4.2.2 on 2023-08-24 06:32
+
+import uuid
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+def move_last_serviced_on_and_notes(apps, schema_editor):
+    Asset = apps.get_model("facility", "Asset")
+    AssetService = apps.get_model("facility", "AssetService")
+
+    asset_services = []
+    asset_linked_last_services = []
+    for asset in Asset.objects.all():
+        if asset.last_serviced_on or asset.notes:
+            service_record = AssetService(
+                asset=asset, serviced_on=asset.last_serviced_on, note=asset.notes
+            )
+            asset_services.append(service_record)
+            asset.last_service = service_record
+            asset_linked_last_services.append(asset)
+
+    AssetService.objects.bulk_create(asset_services)
+    Asset.objects.bulk_update(asset_linked_last_services, ["last_service"])
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        (
+            "facility",
+            "0379_rename_prescribed_medication_patientconsultation_treatment_plan",
+        ),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="AssetService",
+            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)),
+                ("serviced_on", models.DateField(default=None, null=True)),
+                ("note", models.TextField(blank=True, default="", null=True)),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        migrations.CreateModel(
+            name="AssetServiceEdit",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("edited_on", models.DateTimeField(auto_now_add=True)),
+                ("serviced_on", models.DateField()),
+                ("note", models.TextField()),
+                (
+                    "asset_service",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="edits",
+                        to="facility.assetservice",
+                    ),
+                ),
+                (
+                    "edited_by",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.PROTECT,
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+            options={
+                "ordering": ["-edited_on"],
+            },
+        ),
+        migrations.AddField(
+            model_name="assetservice",
+            name="asset",
+            field=models.ForeignKey(
+                on_delete=django.db.models.deletion.PROTECT, to="facility.asset"
+            ),
+        ),
+        migrations.AddField(
+            model_name="asset",
+            name="last_service",
+            field=models.ForeignKey(
+                default=None,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="last_service",
+                to="facility.assetservice",
+            ),
+        ),
+        migrations.RunPython(
+            code=move_last_serviced_on_and_notes,
+            reverse_code=django.db.migrations.operations.special.RunPython.noop,
+        ),
+        migrations.RemoveField(
+            model_name="asset",
+            name="last_serviced_on",
+        ),
+        migrations.RemoveField(
+            model_name="asset",
+            name="notes",
+        ),
+    ]