Merge branch 'issue#1274' of https://github.com/siddnikh/care into is…

…sue#1274

.vscode/launch.json

@@ -26,5 +26,14 @@
       "django": true,
       "justMyCode": false
     },
+    {
+      "name": "Python: Django test",
+      "type": "python",
+      "request": "launch",
+      "program": "${workspaceFolder}/manage.py",
+      "args": ["test", "--keepdb"],
+      "django": true,
+      "justMyCode": false
+    },
   ]
 }

aws/backend.json

@@ -227,7 +227,7 @@
       "name": "care-backend"
     }
   ],
-  "memory": "512",
+  "memory": "1024",
   "taskRoleArn": "arn:aws:iam::299650323339:role/ecsTaskExecutionRole",
   "family": "care",
   "requiresCompatibilities": [

care/facility/api/serializers/patient_consultation.py

@@ -328,18 +328,17 @@ def validate(self, attrs):
                     validated["referred_to"] = None
                 elif validated.get("referred_to"):
                     validated["referred_to_external"] = None
-            if (
-                validated["suggestion"] is SuggestionChoices.A
-                and validated.get("admitted")
-                and not validated.get("admission_date")
-            ):
-                raise ValidationError(
-                    {
-                        "admission_date": [
-                            "This field is required as the patient has been admitted."
-                        ]
-                    }
-                )
+            if validated["suggestion"] is SuggestionChoices.A:
+                if not validated.get("admission_date"):
+                    raise ValidationError(
+                        {
+                            "admission_date": "This field is required as the patient has been admitted."
+                        }
+                    )
+                if validated["admission_date"] > now():
+                    raise ValidationError(
+                        {"admission_date": "This field value cannot be in the future."}
+                    )
 
         if "action" in validated:
             if validated["action"] == PatientRegistration.ActionEnum.REVIEW:
@@ -432,13 +431,33 @@ def validate(self, attrs):
         if attrs.get("discharge_reason") == "EXP":
             if not attrs.get("death_datetime"):
                 raise ValidationError({"death_datetime": "This field is required"})
+            if attrs.get("death_datetime") > now():
+                raise ValidationError(
+                    {"death_datetime": "This field value cannot be in the future."}
+                )
+            if attrs.get("death_datetime") < self.instance.admission_date:
+                raise ValidationError(
+                    {
+                        "death_datetime": "This field value cannot be before the admission date."
+                    }
+                )
             if not attrs.get("death_confirmed_doctor"):
                 raise ValidationError(
                     {"death_confirmed_doctor": "This field is required"}
                 )
             attrs["discharge_date"] = attrs["death_datetime"]
         elif not attrs.get("discharge_date"):
             raise ValidationError({"discharge_date": "This field is required"})
+        elif attrs.get("discharge_date") > now():
+            raise ValidationError(
+                {"discharge_date": "This field value cannot be in the future."}
+            )
+        elif attrs.get("discharge_date") < self.instance.admission_date:
+            raise ValidationError(
+                {
+                    "discharge_date": "This field value cannot be before the admission date."
+                }
+            )
         return attrs
 
     def save(self, **kwargs):

care/facility/api/serializers/prescription.py

@@ -1,15 +1,29 @@
+from django.shortcuts import get_object_or_404
 from rest_framework import serializers
 
-from care.facility.models import MedicineAdministration, Prescription
+from care.facility.models import MedibaseMedicine, MedicineAdministration, Prescription
 from care.users.api.serializers.user import UserBaseMinimumSerializer
 
 
-class PrescriptionSerializer(serializers.ModelSerializer):
+class MedibaseMedicineSerializer(serializers.ModelSerializer):
     id = serializers.UUIDField(source="external_id", read_only=True)
 
-    prescribed_by = UserBaseMinimumSerializer(read_only=True)
+    class Meta:
+        model = MedibaseMedicine
+        exclude = ("deleted",)
+        read_only_fields = (
+            "external_id",
+            "created_date",
+            "modified_date",
+        )
+
 
+class PrescriptionSerializer(serializers.ModelSerializer):
+    id = serializers.UUIDField(source="external_id", read_only=True)
+    prescribed_by = UserBaseMinimumSerializer(read_only=True)
     last_administered_on = serializers.SerializerMethodField()
+    medicine_object = MedibaseMedicineSerializer(read_only=True, source="medicine")
+    medicine = serializers.UUIDField(write_only=True)
 
     def get_last_administered_on(self, obj):
         last_administration = (
@@ -28,6 +42,7 @@ class Meta:
             "deleted",
         )
         read_only_fields = (
+            "medicine_old",
             "external_id",
             "prescribed_by",
             "created_date",
@@ -37,12 +52,16 @@ class Meta:
         )
 
     def validate(self, attrs):
+        if "medicine" in attrs:
+            attrs["medicine"] = get_object_or_404(
+                MedibaseMedicine, external_id=attrs["medicine"]
+            )
+
         if attrs.get("is_prn"):
             if not attrs.get("indicator"):
                 raise serializers.ValidationError(
                     {"indicator": "Indicator should be set for PRN prescriptions."}
                 )
-
         else:
             if not attrs.get("frequency"):
                 raise serializers.ValidationError(

care/facility/api/viewsets/patient.py

@@ -153,6 +153,10 @@ def filter_by_category(self, queryset, name, value):
         field_name="last_consultation__current_bed__bed__bed_type",
         choice_dict=REVERSE_BED_TYPES,
     )
+    last_consultation_discharge_reason = filters.ChoiceFilter(
+        field_name="last_consultation__discharge_reason",
+        choices=DISCHARGE_REASON_CHOICES,
+    )
     last_consultation_assigned_to = filters.NumberFilter(
         field_name="last_consultation__assigned_to"
     )

care/facility/api/viewsets/prescription.py

@@ -1,11 +1,13 @@
+from re import IGNORECASE
+
 from django.shortcuts import get_object_or_404
 from django_filters import rest_framework as filters
 from drf_spectacular.utils import extend_schema
 from rest_framework import mixins, status
 from rest_framework.decorators import action
 from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
-from rest_framework.viewsets import GenericViewSet
+from rest_framework.viewsets import GenericViewSet, ViewSet
 
 from care.facility.api.serializers.prescription import (
     MedicineAdministrationSerializer,
@@ -132,3 +134,54 @@ def administer(self, request, *args, **kwargs):
     #     administered_obj = MedicineAdministration.objects.get(external_id=request.query_params.get("id", None))
     #     administered_obj.delete()
     #     return Response({"success": True}, status=status.HTTP_200_OK)
+
+
+class MedibaseViewSet(ViewSet):
+    permission_classes = (IsAuthenticated,)
+
+    def serailize_data(self, objects):
+        result = []
+        for object in objects:
+            if type(object) == tuple:
+                object = object[0]
+            result.append(
+                {
+                    "id": object.external_id,
+                    "name": object.name,
+                    "type": object.type,
+                    "generic": object.generic,
+                    "company": object.company,
+                    "contents": object.contents,
+                    "cims_class": object.cims_class,
+                    "atc_classification": object.atc_classification,
+                }
+            )
+        return result
+
+    def sort(self, query, results):
+        exact_matches = []
+        partial_matches = []
+
+        for result in results:
+            if type(result) == tuple:
+                result = result[0]
+            words = result.searchable.lower().split()
+            if query in words:
+                exact_matches.append(result)
+            else:
+                partial_matches.append(result)
+
+        return exact_matches + partial_matches
+
+    def list(self, request):
+        from care.facility.static_data.medibase import MedibaseMedicineTable
+
+        queryset = MedibaseMedicineTable
+
+        if request.GET.get("query", False):
+            query = request.GET.get("query").strip().lower()
+            queryset = queryset.where(
+                searchable=queryset.re_match(r".*" + query + r".*", IGNORECASE)
+            )
+            queryset = self.sort(query, queryset)
+        return Response(self.serailize_data(queryset[:15]))

care/facility/management/commands/load_dummy_data.py

@@ -24,6 +24,7 @@ def handle(self, *args, **options):
         try:
             management.call_command("loaddata", self.BASE_URL + "users.json")
             management.call_command("load_data", "kerala")
+            management.call_command("load_medicines_data")
             management.call_command("seed_data")
             management.call_command("loaddata", self.BASE_URL + "facility.json")
             management.call_command("loaddata", self.BASE_URL + "cypress_users.json")

care/facility/management/commands/load_medicines_data.py

@@ -0,0 +1,39 @@
+import json
+
+from django.core.management import BaseCommand
+
+from care.facility.models import MedibaseMedicine
+
+
+class Command(BaseCommand):
+    """
+    Command to load medibase medicines
+    Usage: python manage.py load_medicines_data
+    """
+
+    help = "Loads Medibase Medicines into the database from medibase.json"
+
+    def fetch_data(self):
+        with open("data/medibase.json", "r") as json_file:
+            return json.load(json_file)
+
+    def handle(self, *args, **options):
+        print("Loading Medibase Medicines into the database from medibase.json")
+
+        medibase_objects = self.fetch_data()
+        MedibaseMedicine.objects.bulk_create(
+            [
+                MedibaseMedicine(
+                    name=medicine["name"],
+                    type=medicine["type"],
+                    company=medicine.get("company"),
+                    contents=medicine.get("contents"),
+                    cims_class=medicine.get("cims_class"),
+                    atc_classification=medicine.get("atc_classification"),
+                    generic=medicine.get("generic"),
+                )
+                for medicine in medibase_objects
+            ],
+            batch_size=1000,
+            ignore_conflicts=True,
+        )

care/facility/migrations/0366_medibasemedicine_and_more.py

@@ -0,0 +1,73 @@
+# Generated by Django 4.2.2 on 2023-06-28 02:50
+
+import uuid
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("facility", "0365_merge_20230626_1834"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="MedibaseMedicine",
+            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(db_index=True, max_length=255, unique=True)),
+                (
+                    "type",
+                    models.CharField(
+                        choices=[("BRAND", "brand"), ("GENERIC", "generic")],
+                        db_index=True,
+                        max_length=16,
+                    ),
+                ),
+                (
+                    "generic",
+                    models.CharField(
+                        blank=True, db_index=True, max_length=255, null=True
+                    ),
+                ),
+                (
+                    "company",
+                    models.CharField(
+                        blank=True, db_index=True, max_length=255, null=True
+                    ),
+                ),
+                ("contents", models.TextField(blank=True, null=True)),
+                ("cims_class", models.CharField(blank=True, max_length=255, null=True)),
+                ("atc_classification", models.TextField(blank=True, null=True)),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        migrations.RenameField(
+            model_name="prescription",
+            old_name="medicine",
+            new_name="medicine_old",
+        ),
+    ]

care/facility/migrations/0367_auto_20230704_1646.py

@@ -0,0 +1,22 @@
+# Generated by Django 4.2.2 on 2023-07-04 11:16
+
+from django.db import migrations
+from django.db.models import F
+
+
+class Migration(migrations.Migration):
+    def move_non_admission_ip_to_op(apps, schema_editor):
+        PatientConsultation = apps.get_model("facility", "PatientConsultation")
+        PatientConsultation.objects.exclude(suggestion="A").filter(
+            ip_no__isnull=False, admission_date__isnull=True
+        ).update(op_no=F("ip_no"), ip_no=None)
+
+    dependencies = [
+        ("facility", "0366_auto_20230627_1806"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            move_non_admission_ip_to_op, reverse_code=migrations.RunPython.noop
+        )
+    ]