[Fixes #11494] Implement relations between resources - fix formatting

Author: etj

geonode/base/api/serializers.py

@@ -54,7 +54,8 @@
     SpatialRepresentationType,
     ThesaurusKeyword,
     ThesaurusKeywordLabel,
-    ExtraMetadata, LinkedResource,
+    ExtraMetadata,
+    LinkedResource,
 )
 from geonode.documents.models import Document
 from geonode.geoapps.models import GeoApp
@@ -788,9 +789,7 @@ class Meta:
 
 
 class SimpleResourceSerializer(DynamicModelSerializer):
-    warnings.warn('SimpleResourceSerializer is deprecated',
-                  DeprecationWarning,
-                  stacklevel=2)
+    warnings.warn("SimpleResourceSerializer is deprecated", DeprecationWarning, stacklevel=2)
 
     class Meta:
         name = "linked_resources"
@@ -808,7 +807,7 @@ def to_representation(self, instance: LinkedResource):
 
 
 class LinkedResourceSerializer(DynamicModelSerializer):
-    def __init__(self,  *kargs, serialize_source: bool = False, **kwargs):
+    def __init__(self, *kargs, serialize_source: bool = False, **kwargs):
         super().__init__(*kargs, **kwargs)
         self.serialize_target = not serialize_source
 
@@ -820,11 +819,13 @@ class Meta:
     def to_representation(self, instance: LinkedResource):
         data = super().to_representation(instance)
         item: ResourceBase = instance.target if self.serialize_target else instance.source
-        data.update({
-            "pk": item.pk,
-            "title": item.title,
-            "resource_type": item.resource_type,
-            "detail_url": item.detail_url,
-            "thumbnail_url": item.thumbnail_url,
-        })
+        data.update(
+            {
+                "pk": item.pk,
+                "title": item.title,
+                "resource_type": item.resource_type,
+                "detail_url": item.detail_url,
+                "thumbnail_url": item.thumbnail_url,
+            }
+        )
         return data

geonode/base/api/tests.py

@@ -2625,14 +2625,19 @@ def test_linked_resource_for_document(self):
             self.assertEqual(response.status_code, 200)
             payload = response.json()
             self.assert_linkedres_size(payload, "resources", 2)
-            self.assert_linkedres_contains(payload, "resources", (
-                {"pk":self.map.id, "title": ">>> " + self.map.title},
-                {"pk":self.dataset.id, "title": ">>> " + self.dataset.title})
+            self.assert_linkedres_contains(
+                payload,
+                "resources",
+                (
+                    {"pk": self.map.id, "title": ">>> " + self.map.title},
+                    {"pk": self.dataset.id, "title": ">>> " + self.dataset.title},
+                ),
             )
             self.assert_linkedres_size(payload, "linked_to", 2)
-            self.assert_linkedres_contains(payload, "linked_to", (
-                {"pk":self.map.id, "title": self.map.title},
-                {"pk":self.dataset.id, "title": self.dataset.title})
+            self.assert_linkedres_contains(
+                payload,
+                "linked_to",
+                ({"pk": self.map.id, "title": self.map.title}, {"pk": self.dataset.id, "title": self.dataset.title}),
             )
             self.assert_linkedres_size(payload, "linked_by", 0)
         finally:
@@ -2682,18 +2687,20 @@ def test_linked_resource_for_maps_mixed(self):
 
             payload = response.json()
             self.assert_linkedres_size(payload, "resources", 2)
-            self.assert_linkedres_contains(payload, "resources", (
-                {"pk":self.doc.id, "title": "<<< " + self.doc.title},
-                {"pk":self.dataset.id, "title": ">>> " + self.dataset.title},)
+            self.assert_linkedres_contains(
+                payload,
+                "resources",
+                (
+                    {"pk": self.doc.id, "title": "<<< " + self.doc.title},
+                    {"pk": self.dataset.id, "title": ">>> " + self.dataset.title},
+                ),
             )
             self.assert_linkedres_size(payload, "linked_to", 1)
-            self.assert_linkedres_contains(payload, "linked_to", (
-                {"pk":self.dataset.id, "title": self.dataset.title},)
+            self.assert_linkedres_contains(
+                payload, "linked_to", ({"pk": self.dataset.id, "title": self.dataset.title},)
             )
             self.assert_linkedres_size(payload, "linked_by", 1)
-            self.assert_linkedres_contains(payload, "linked_by", (
-                {"pk":self.doc.id, "title": self.doc.title},)
-            )
+            self.assert_linkedres_contains(payload, "linked_by", ({"pk": self.doc.id, "title": self.doc.title},))
 
         finally:
             if _d:
@@ -2721,12 +2728,12 @@ def test_linked_resources_for_maps(self):
 
             payload = response.json()
             self.assert_linkedres_size(payload, "resources", 1)
-            self.assert_linkedres_contains(payload, "resources", (
-                {"pk":self.dataset.id, "title": ">>> " + self.dataset.title},)
+            self.assert_linkedres_contains(
+                payload, "resources", ({"pk": self.dataset.id, "title": ">>> " + self.dataset.title},)
             )
             self.assert_linkedres_size(payload, "linked_to", 1)
-            self.assert_linkedres_contains(payload, "linked_to", (
-                {"pk":self.dataset.id, "title": self.dataset.title},)
+            self.assert_linkedres_contains(
+                payload, "linked_to", ({"pk": self.dataset.id, "title": self.dataset.title},)
             )
             self.assert_linkedres_size(payload, "linked_by", 0)
 
@@ -2754,14 +2761,12 @@ def test_linked_resource_for_dataset(self):
 
             payload = response.json()
             self.assert_linkedres_size(payload, "resources", 1)
-            self.assert_linkedres_contains(payload, "resources", (
-                {"pk":self.map.id, "title": "<<< " + self.map.title},)
+            self.assert_linkedres_contains(
+                payload, "resources", ({"pk": self.map.id, "title": "<<< " + self.map.title},)
             )
             self.assert_linkedres_size(payload, "linked_to", 0)
             self.assert_linkedres_size(payload, "linked_by", 1)
-            self.assert_linkedres_contains(payload, "linked_by", (
-                {"pk":self.map.id, "title": self.map.title},)
-            )
+            self.assert_linkedres_contains(payload, "linked_by", ({"pk": self.map.id, "title": self.map.title},))
 
         finally:
             if _m:
@@ -2787,15 +2792,23 @@ def test_linked_resource_for_datasets_mixed(self):
             self.assertEqual(response.status_code, 200)
             payload = response.json()
             self.assert_linkedres_size(payload, "resources", 2)
-            self.assert_linkedres_contains(payload, "resources", (
-                {"pk":self.doc.id, "title": "<<< " + self.doc.title},
-                {"pk":self.map.id, "title": "<<< " + self.map.title},)
+            self.assert_linkedres_contains(
+                payload,
+                "resources",
+                (
+                    {"pk": self.doc.id, "title": "<<< " + self.doc.title},
+                    {"pk": self.map.id, "title": "<<< " + self.map.title},
+                ),
             )
             self.assert_linkedres_size(payload, "linked_to", 0)
             self.assert_linkedres_size(payload, "linked_by", 2)
-            self.assert_linkedres_contains(payload, "linked_by", (
-                {"pk":self.map.id, "title": self.map.title},
-                {"pk":self.doc.id, "title": self.doc.title},)
+            self.assert_linkedres_contains(
+                payload,
+                "linked_by",
+                (
+                    {"pk": self.map.id, "title": self.map.title},
+                    {"pk": self.doc.id, "title": self.doc.title},
+                ),
             )
 
         finally:

geonode/base/api/views.py

@@ -109,7 +109,8 @@
     TopicCategorySerializer,
     RegionSerializer,
     ThesaurusKeywordSerializer,
-    ExtraMetadataSerializer, LinkedResourceSerializer,
+    ExtraMetadataSerializer,
+    LinkedResourceSerializer,
 )
 from .pagination import GeoNodeApiPagination
 from geonode.base.utils import validate_extra_metadata
@@ -1506,36 +1507,36 @@ def base_linked_resources(instance, user, params):
         # linked_resources = LinkedResource.get_linked_resources(source=instance).filter(target__in=resources)
         # linked_by = LinkedResource.get_linked_resources(target=instance).filter(source__in=resources)
 
-        linked_resources = [lres for lres in instance.get_linked_resources()
-                            if lres.target.id in visible_ids]
-        linked_by = [lres for lres in instance.get_linked_resources(as_target=True)
-                     if lres.source.id in visible_ids]
+        linked_resources = [lres for lres in instance.get_linked_resources() if lres.target.id in visible_ids]
+        linked_by = [lres for lres in instance.get_linked_resources(as_target=True) if lres.source.id in visible_ids]
 
         warnings = {
-            'DEPRECATION': "'resources' field is deprecated, please use 'linked_to'",
+            "DEPRECATION": "'resources' field is deprecated, please use 'linked_to'",
         }
 
         if "page_size" in params or "page" in params:
-            warnings['PAGINATION'] = "Pagination is not supported on this call"
+            warnings["PAGINATION"] = "Pagination is not supported on this call"
 
         # "resources" will be deprecated, so next block is temporary
         # "resources" at the moment it's the only element rendered, so we want to add there both the linked_resources and the linked_by
         # we want to tell them apart, so we're adding an attr to store this info, that will be used in the SimpleResourceSerializer
         resources = []
         for lres in linked_resources:
             res = lres.target
-            setattr(res, 'is_target', True)
+            setattr(res, "is_target", True)
             resources.append(res)
         for lres in linked_by:
             res = lres.source
-            setattr(res, 'is_target', False)
+            setattr(res, "is_target", False)
             resources.append(res)
 
         ret = {
             "WARNINGS": warnings,
             "resources": SimpleResourceSerializer(resources, embed=True, many=True).data,  # deprecated
             "linked_to": LinkedResourceSerializer(linked_resources, embed=True, many=True).data,
-            "linked_by": LinkedResourceSerializer(instance=linked_by, serialize_source=True, embed=True, many=True).data,
+            "linked_by": LinkedResourceSerializer(
+                instance=linked_by, serialize_source=True, embed=True, many=True
+            ).data,
         }
 
         return Response(ret)

geonode/base/forms.py

@@ -347,18 +347,19 @@ def _get_thesauro_title_label(item, lang):
 
 
 class LinkedResourceForm(forms.ModelForm):
-
     linked_resources = forms.MultipleChoiceField(label=_("Link to"), required=False)
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.fields["linked_resources"].choices = LinkedResourceForm.generate_link_choices()
-        self.fields["linked_resources"].initial = LinkedResourceForm.generate_link_values(resources=LinkedResource.get_targets(self.instance))
+        self.fields["linked_resources"].initial = LinkedResourceForm.generate_link_values(
+            resources=LinkedResource.get_targets(self.instance)
+        )
 
     @staticmethod
     def generate_link_choices(resources=None):
         if resources is None:
-            resources = ResourceBase.objects.all().order_by('title')
+            resources = ResourceBase.objects.all().order_by("title")
 
         choices = []
         for obj in resources:
@@ -375,11 +376,7 @@ def save_linked_resources(self, links_field="linked_resources"):
         # create and fetch desired links
         target_ids = []
         for res_id in self.cleaned_data[links_field]:
-            linked, _ = LinkedResource.objects.get_or_create(
-                source=self.instance,
-                target_id=res_id,
-                internal=False
-            )
+            linked, _ = LinkedResource.objects.get_or_create(source=self.instance, target_id=res_id, internal=False)
             target_ids.append(res_id)
 
             # matches = re.match(r"type:(\d+)-id:(\d+)", link)
@@ -396,11 +393,7 @@ def save_linked_resources(self, links_field="linked_resources"):
         # DocumentResourceLink.objects.filter(document_id=self.instance.id).exclude(
         #     pk__in=[i.pk for i in instances]
         # ).delete()
-        (LinkedResource.objects
-            .filter(source_id=self.instance.id)
-            .exclude(target_id__in=target_ids)
-            .delete()
-         )
+        (LinkedResource.objects.filter(source_id=self.instance.id).exclude(target_id__in=target_ids).delete())
 
 
 class ResourceBaseDateTimePicker(DateTimePicker):
@@ -696,4 +689,3 @@ class Meta:
 
 class ThesaurusImportForm(forms.Form):
     rdf_file = forms.FileField()
-

geonode/base/models.py

@@ -1732,8 +1732,11 @@ def get_linked_resources(self, as_target: bool = False):
         This is implemented as a method so that derived classes can override it (for instance, Maps may add
         related datasets)
         """
-        return LinkedResource.get_linked_resources(target=self) if as_target \
+        return (
+            LinkedResource.get_linked_resources(target=self)
+            if as_target
             else LinkedResource.get_linked_resources(source=self)
+        )
 
 
 class LinkManager(models.Manager):
@@ -1759,29 +1762,29 @@ def ows(self):
 
 
 class LinkedResource(models.Model):
-    source = models.ForeignKey(ResourceBase, related_name="linked_to",
-                               blank=False, null=False, on_delete=models.CASCADE)
-    target = models.ForeignKey(ResourceBase, related_name="linked_by",
-                               blank=True, null=False, on_delete=models.CASCADE)
+    source = models.ForeignKey(
+        ResourceBase, related_name="linked_to", blank=False, null=False, on_delete=models.CASCADE
+    )
+    target = models.ForeignKey(ResourceBase, related_name="linked_by", blank=True, null=False, on_delete=models.CASCADE)
     internal = models.BooleanField(null=False, default=False)
 
     @classmethod
     def get_linked_resources(cls, source: ResourceBase = None, target: ResourceBase = None, is_internal: bool = None):
         if source is None and target is None:
-            raise ValueError('Both source and target filters missing')
+            raise ValueError("Both source and target filters missing")
 
         qs = LinkedResource.objects
         if source:
-            qs = qs.filter(source=source).select_related('target')
+            qs = qs.filter(source=source).select_related("target")
         if target:
-            qs = qs.filter(target=target).select_related('source')
+            qs = qs.filter(target=target).select_related("source")
         if is_internal is not None:
             qs = qs.filter(internal=is_internal)
         return qs
 
     @classmethod
     def get_targets(cls, source: ResourceBase, is_internal: bool = None):
-        sub = LinkedResource.objects.filter(source=source).values('target_id')
+        sub = LinkedResource.objects.filter(source=source).values("target_id")
         if is_internal is not None:
             sub = sub.filter(internal=is_internal)
         return ResourceBase.objects.filter(id__in=sub)

geonode/layers/models.py

@@ -323,6 +323,7 @@ def get_linked_resources(self, as_target: bool = False):
 
         if as_target:
             from geonode.maps.models import Map
+
             # create LinkedResources on the fly to report MapLayer relationship
             res = (LinkedResource(source=map, target=self, internal=True) for map in self.maps)
             ret = itertools.chain(ret, res)

geonode/resource/manager.py

@@ -513,13 +513,13 @@ def copy(
                             defaults.pop("name")
                     _resource.save()
                     for lr in LinkedResource.get_linked_resources(source=instance.pk, is_internal=False):
-                        LinkedResource.object.get_or_create(source_id=_resource.pk,
-                                                            target_id=lr.target.pk,
-                                                            internal=False)
+                        LinkedResource.object.get_or_create(
+                            source_id=_resource.pk, target_id=lr.target.pk, internal=False
+                        )
                     for lr in LinkedResource.get_linked_resources(target=instance.pk, is_internal=False):
-                        LinkedResource.object.get_or_create(source_id=lr.source.pk,
-                                                            target_id=_resource.pk,
-                                                            internal=False)
+                        LinkedResource.object.get_or_create(
+                            source_id=lr.source.pk, target_id=_resource.pk, internal=False
+                        )
 
                     if isinstance(instance.get_real_instance(), Dataset):
                         for attribute in Attribute.objects.filter(dataset=instance.get_real_instance()):