OpenConceptLab/ocl_online#451 | FHIR R4 terminology service for the SVCM transactions

.env.example

@@ -82,7 +82,6 @@ FLOWER_PASSWORD=Root123
 # -----------------------------------------------------------------------------
 # FHIR Validator
 # -----------------------------------------------------------------------------
-FHIR_VALIDATOR_URL=http://fhir_validator:3500
 
 # -----------------------------------------------------------------------------
 # Error tracking (optional)

.pylintrc

@@ -1,6 +1,7 @@
 [MESSAGES CONTROL]
 disable=missing-docstring,too-few-public-methods,no-member,too-many-ancestors,attribute-defined-outside-init,fixme,broad-except,import-outside-toplevel,too-many-instance-attributes,unsupported-membership-test,too-many-public-methods,too-many-lines,unused-private-member,consider-using-with,duplicate-code,unspecified-encoding,invalid-name,cyclic-import,missing-timeout,too-many-positional-arguments
 [MASTER]
+extension-pkg-allow-list=lxml
 ignore=migrations,fixtures,scripts,commands,documents.py,password_validation.py,v1_dump
 [FORMAT]
 max-line-length=120

core/bundles/serializers.py

@@ -21,7 +21,7 @@ class BundleLinkSerializer(CommonSerializer):
 
 
 class BundleMetaSerializer(CommonSerializer):
-    lastUpdated = DateTimeField(read_only=True, default=datetime.now())
+    lastUpdated = DateTimeField(read_only=True, default=datetime.now)
 
 
 class BundleExtensionSerializer(CommonSerializer):
@@ -33,7 +33,9 @@ class BundleExtensionSerializer(CommonSerializer):
 
 
 class BundleEntrySerializer(CommonSerializer):
+    fullUrl = CharField(required=False)
     resource = JSONField()
+    search = JSONField(required=False)
 
 
 class FHIRBundleSerializer(CommonSerializer):
@@ -53,17 +55,29 @@ def get_resource_type(cls, _obj):
         return 'Bundle'
 
     @classmethod
-    def convert_to_entry(cls, resources):
+    def convert_to_entry(cls, resources, base_url):
+        """
+        Searchset entries: each resource a match with its fullUrl (base_url is the base and resource type), and a
+        resource that couldn't be represented (an OperationOutcome) an outcome.
+        """
         entry = []
         for resource in resources:
-            entry.append({'resource': resource})
+            if resource.get('resourceType') == 'OperationOutcome':
+                entry.append({'resource': resource, 'search': {'mode': 'outcome'}})
+            else:
+                entry.append(
+                    {'fullUrl': f"{base_url}/{resource['id']}", 'resource': resource, 'search': {'mode': 'match'}})
         return entry
 
     def get_link(self, _):
+        """self, previous and next, for the page the paginator holds; only self without one (_count=0)"""
         paginator = self.context.get('paginator')
+        if paginator is None:
+            return BundleLinkSerializer(
+                [{'relation': 'self', 'url': self.context['request'].build_absolute_uri()}], many=True).data
         links = [{'relation': 'self', 'url': paginator.get_current_page_url()}]
         if paginator.has_previous():
-            links.append({'relation': 'prev', 'url': paginator.get_previous_page_url()})
+            links.append({'relation': 'previous', 'url': paginator.get_previous_page_url()})
         if paginator.has_next():
             links.append({'relation': 'next', 'url': paginator.get_next_page_url()})
         return BundleLinkSerializer(links, many=True).data

core/code_systems/converter.py

@@ -1,4 +1,4 @@
-from fhir.resources.codesystem import CodeSystem
+from fhir.resources.R4B.codesystem import CodeSystem  # R4B models are the R4 wire models
 
 from core.settings import DEFAULT_LOCALE
 from core.sources.models import Source
@@ -32,7 +32,7 @@ def to_fhir(source):
             'language': source.default_locale,
             'count': source.active_concepts,
         }
-        return CodeSystem(**code_system).dict()
+        return CodeSystem(**code_system).model_dump()
 
     @staticmethod
     def from_fhir(code_system):

core/code_systems/serializers.py

@@ -13,23 +13,14 @@
 from core.common.serializers import ReadSerializerMixin, StatusField, IdentifierSerializer
 from core.concepts.models import Concept, ConceptName
 from core.concepts.serializers import ConceptDetailSerializer
-from core.parameters.serializers import ParametersSerializer
+from core.fhir import search as fhir_search
+from core.fhir.search import CanonicalUrlField, FhirRepositorySerializerMixin, TitleField
 from core.sources.models import Source
 from core.sources.serializers import SourceCreateOrUpdateSerializer
 
 logger = logging.getLogger('oclapi')
 
 
-class ValidateCodeParametersSerializer(ParametersSerializer):
-    allowed_input_parameters = {
-        'url': 'valueUri',
-        'code': 'valueCode',
-        'display': 'valueString',
-        'version': 'valueString',
-        'systemVersion': 'valueString',
-        'system': 'valueUri'
-    }
-
 class CodeSystemConceptDesignationUseSerializer(serializers.Field):
     def to_internal_value(self, data):
         if 'code' in data:
@@ -89,10 +80,10 @@ def to_internal_value(self, data):
         return {'descriptions': [{'description': data, 'locale': settings.DEFAULT_LOCALE, 'locale_preferred': True}]}
 
     def to_representation(self, value):
-        descriptions = value.descriptions_for_default_locale
-        if descriptions and len(descriptions) > 0:
-            return value.descriptions_for_default_locale[0]
-        return None
+        """The first description in the default locale, from the descriptions a read prefetches."""
+        descriptions = [description.name for description in value.descriptions.all()
+                        if description.locale == settings.DEFAULT_LOCALE and not description.retired]
+        return descriptions[0] if descriptions else None
 
 
 class CodeSystemConceptSerializer(ReadSerializerMixin, serializers.Serializer):
@@ -149,13 +140,9 @@ def to_internal_value(self, data):
         return {'concepts': concepts.validated_data}
 
     def to_representation(self, value):
-        # limit to 1000 concepts by default
-        # TODO: support graphQL to go around the limit
-        if self.context.get('has_many', False):
-            limit = 25
-        else:
-            limit = 1000
-        return CodeSystemConceptSerializer(value.concepts.order_by('id')[:limit], many=True).data
+        """Every concept, retired ones included, up to the limit; none above it (content not-present)."""
+        concepts = fhir_search.code_system_concepts(value)[1]
+        return CodeSystemConceptSerializer(concepts, many=True).data if concepts else []
 
 
 class TextField(ReadSerializerMixin, serializers.Serializer):
@@ -178,11 +165,12 @@ def to_representation(self, instance):
         return super().to_representation(obj)
 
 
-class CodeSystemDetailSerializer(serializers.ModelSerializer):
+class CodeSystemDetailSerializer(FhirRepositorySerializerMixin, serializers.ModelSerializer):
+    content_field = 'concept'
     resourceType = SerializerMethodField(method_name='get_resource_type')
     id = CharField(source='mnemonic')
-    url = CharField(source='canonical_url', required=False)
-    title = CharField(source='full_name', required=False)
+    url = CanonicalUrlField(source='canonical_url', required=False)
+    title = TitleField(source='full_name', required=False)
     status = StatusField(source='*')
     language = CharField(source='default_locale', required=False)
     count = SerializerMethodField(method_name='get_total_count')
@@ -210,21 +198,20 @@ class Meta:
                   'copyright', 'revisionDate', 'experimental', 'caseSensitive', 'compositional', 'versionNeeded',
                   'collectionReference', 'hierarchyMeaning', 'concept', 'text', 'filters')
 
-    def __new__(cls, *args, **kwargs):
-        if kwargs.get('many', False):
-            context = kwargs.get('context', {})
-            context.update({'has_many': True})
-            kwargs.update({'context': context})
-
-        return super().__new__(cls, *args, **kwargs)
-
     @staticmethod
     def get_resource_type(_):
         return RESOURCE_TYPE
 
+    def get_total_count(self, obj):
+        """A read's concept count; a search's summary has none (it only checks the limit)."""
+        return None if self.context.get('has_many') else fhir_search.code_system_concepts(obj)[0]
+
     @staticmethod
-    def get_total_count(obj):
-        return obj.concepts.count()
+    def get_content(obj):
+        """complete (or the content mode the CodeSystem was saved with) up to the concept limit, else not-present"""
+        if fhir_search.concepts_over_limit(obj):
+            return 'not-present'
+        return obj.content_type if obj.content_type in ('example', 'fragment', 'supplement') else 'complete'
 
     @staticmethod
     def get_property(obj):
@@ -264,11 +251,11 @@ def get_meta(obj):
 
     def to_representation(self, instance):
         try:
-            if not instance.content_type:
-                instance.content_type = 'complete'
             rep = super().to_representation(instance)
+            rep['content'] = self.get_content(instance)
             delete_empty_fields(rep)
             IdentifierSerializer.include_ocl_identifier(instance.uri, RESOURCE_TYPE, rep)
+            self.with_fhir_view(instance, rep)
         except (Exception, ):
             msg = f'Failed to represent "{instance.uri}" as {RESOURCE_TYPE}'
             logger.exception(msg)