parent_community: use OS instead of DB queries for search result

invenio_communities/communities/records/api.py

@@ -26,6 +26,7 @@
 from invenio_vocabularies.records.api import Vocabulary
 from invenio_vocabularies.records.systemfields.relations import CustomFieldsRelation
 
+from invenio_communities.communities.records.systemfields.children import ChildrenField
 from invenio_communities.communities.records.systemfields.is_verified import (
     IsVerifiedField,
 )
@@ -53,6 +54,7 @@ class Community(Record):
     slug = ModelField()
     pid = PIDSlugField("id", "slug")
     parent = ParentCommunityField()
+    children = ChildrenField()
 
     schema = ConstantField("$schema", "local://communities/communities-v1.0.0.json")
 

invenio_communities/communities/records/jsonschemas/communities/communities-v1.0.0.json

@@ -145,6 +145,16 @@
         }
       }
     },
+    "children":{
+      "type": "object",
+      "description": "Children communities.",
+      "properties": {
+        "allow": {
+          "type": "boolean",
+          "description": "Whether or not the community allows children."
+        }
+      }
+    },
     "parent": {
       "type": "object",
       "properties": {

invenio_communities/communities/records/mappings/os-v1/communities/communities-v1.0.0.json

@@ -262,12 +262,33 @@
           }
         }
       },
+      "children": {
+        "type": "object",
+        "properties": {
+          "allow": {
+            "type": "boolean"
+          }
+        }
+      },
       "parent": {
         "type": "object",
         "properties": {
           "@v": {
             "type": "keyword"
           },
+          "uuid": {
+            "type": "keyword",
+            "index": false
+          },
+          "created": {
+            "type": "date"
+          },
+          "updated": {
+            "type": "date"
+          },
+          "version_id": {
+            "type": "long"
+          },
           "id": {
             "type": "keyword"
           },

invenio_communities/communities/records/mappings/os-v2/communities/communities-v1.0.0.json

@@ -257,12 +257,33 @@
           }
         }
       },
+      "children": {
+        "type": "object",
+        "properties": {
+          "allow": {
+            "type": "boolean"
+          }
+        }
+      },
       "parent": {
         "type": "object",
         "properties": {
           "@v": {
             "type": "keyword"
           },
+          "uuid": {
+            "type": "keyword",
+            "index": false
+          },
+          "created": {
+            "type": "date"
+          },
+          "updated": {
+            "type": "date"
+          },
+          "version_id": {
+            "type": "long"
+          },
           "id": {
             "type": "keyword"
           },

invenio_communities/communities/records/mappings/v7/communities/communities-v1.0.0.json

@@ -262,12 +262,33 @@
           }
         }
       },
+      "children": {
+        "type": "object",
+        "properties": {
+          "allow": {
+            "type": "boolean"
+          }
+        }
+      },
       "parent": {
         "type": "object",
         "properties": {
           "@v": {
             "type": "keyword"
           },
+          "uuid": {
+            "type": "keyword",
+            "index": false
+          },
+          "created": {
+            "type": "date"
+          },
+          "updated": {
+            "type": "date"
+          },
+          "version_id": {
+            "type": "long"
+          },
           "id": {
             "type": "keyword"
           },

invenio_communities/communities/records/systemfields/children.py

@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+#
+# This file is part of Invenio.
+# Copyright (C) 2023 CERN.
+#
+# Invenio is free software; you can redistribute it and/or modify it
+# under the terms of the MIT License; see LICENSE file for more details.
+
+"""Children system field."""
+
+from invenio_records.systemfields import SystemField
+
+
+class Children:
+    """Children object."""
+
+    def __init__(self, allow=None):
+        """Create a Children object."""
+        self._allow = allow or False
+
+    @property
+    def allow(self):
+        """Get the allow."""
+        return self._allow
+
+    @allow.setter
+    def allow(self, value):
+        """Set the allow."""
+        if not isinstance(value, bool):
+            raise ValueError("Invalid value for allow, it must be a boolean.")
+        self._allow = value
+
+    @classmethod
+    def from_dict(cls, data):
+        """Create a Children object from a dictionary."""
+        return cls(allow=data.get("allow"))
+
+    def dump(self):
+        """Dump the Children object to a dictionary."""
+        return {"allow": self.allow}
+
+
+class ChildrenField(SystemField):
+    """System field for children of a community."""
+
+    children_obj_class = Children
+
+    def __init__(self, key="children", children_obj_class=None):
+        """Create a new ChildrenField instance."""
+        self._children_obj_class = children_obj_class or self.children_obj_class
+        super().__init__(key=key)
+
+    def obj(self, instance):
+        """Get the Children object."""
+        obj = self._get_cache(instance)
+        if obj is not None:
+            return obj
+
+        data = self.get_dictkey(instance)
+        if data:
+            obj = self._children_obj_class.from_dict(data)
+        else:
+            obj = self._children_obj_class()
+
+        self._set_cache(instance, obj)
+        return obj
+
+    def set_obj(self, record, obj):
+        """Set the Children object."""
+        # We accept both dicts and Children class objects.
+        if isinstance(obj, dict):
+            obj = self._children_obj_class.from_dict(obj)
+
+        if not isinstance(obj, self._children_obj_class):
+            raise ValueError("Invalid children object.")
+
+        # We do not dump the object until the pre_commit hook
+        self._set_cache(record, obj)
+
+    def __get__(self, record, owner=None):
+        """Get the record's Children object."""
+        if record is None:
+            # access by class
+            return self
+
+        # access by object
+        return self.obj(record)
+
+    def __set__(self, record, obj):
+        """Set the records Children object."""
+        self.set_obj(record, obj)
+
+    def pre_commit(self, record):
+        """Dump the configured values before the record is committed."""
+        obj = self.obj(record)
+        if obj is not None:
+            # only set the 'children' property if one was present in the
+            # record dict
+            record[self.key] = obj.dump()

invenio_communities/communities/records/systemfields/parent_community.py

@@ -51,6 +51,7 @@ def set_obj(self, record, obj):
         # Check if obj is None and remove 'parent' key from record
         if obj is None:
             record.pop("parent", None)
+            self._set_cache(record, None)
             return
 
         if isinstance(obj, type(record)):
@@ -82,8 +83,8 @@ def __set__(self, record, obj):
         """Set the records access object."""
         self.set_obj(record, obj)
 
-    def pre_dump(self, record, data, dumper=None):
-        """Before dumping, dereference the parent community."""
+    def post_dump(self, record, data, dumper=None):
+        """After dumping, dereference the parent community."""
         parent_community = getattr(record, self.attr_name)
         if parent_community:
             dump = parent_community.dumps()
@@ -104,3 +105,8 @@ def pre_dump(self, record, data, dumper=None):
                     "metadata.funding",
                 ],
             )
+
+    def post_load(self, record, data, loader=None):
+        """Laod the parent community using the OS data (preventing a DB query)."""
+        if data.get("parent"):
+            record.parent = record.loads(data["parent"])

invenio_communities/communities/schema.py

@@ -182,6 +182,12 @@ class CommunityThemeSchema(Schema):
     enabled = fields.Boolean()
 
 
+class ChildrenSchema(Schema):
+    """Children schema."""
+
+    allow = fields.Boolean()
+
+
 class BaseCommunitySchema(BaseRecordSchema, FieldPermissionsMixin):
     """Base schema for the community metadata."""
 
@@ -223,6 +229,8 @@ class Meta:
 
     deletion_status = fields.Nested(DeletionStatusSchema, dump_only=True)
 
+    children = NestedAttribute(ChildrenSchema)
+
     @post_dump
     def post_dump(self, data, many, **kwargs):
         """Hide tombstone info if the record isn't deleted and metadata if it is."""
@@ -274,6 +282,13 @@ def post_dump(self, data, many, **kwargs):
             data.pop("parent", None)
         return data
 
+    @post_load
+    def filter_parent_id(self, in_data, **kwargs):
+        """Simply keep the parent id."""
+        if in_data.get("parent"):
+            in_data["parent"] = dict(id=in_data.get("parent", {}).get("id"))
+        return in_data
+
 
 class CommunityFeaturedSchema(Schema):
     """Community Featured schema."""

invenio_communities/communities/services/components.py

@@ -300,6 +300,23 @@ def update(self, identity, data=None, record=None, errors=None, **kwargs):
                 record["theme"] = data["theme"]
 
 
+class ChildrenComponent(ServiceComponent):
+    """Service component for children integration."""
+
+    def create(self, identity, data=None, record=None, **kwargs):
+        """Create handler."""
+        if "children" in data:
+            self.service.require_permission(identity, "manage_children", record=record)
+            record.children = record.children.from_dict(data["children"])
+
+    def update(self, identity, data=None, record=None, **kwargs):
+        """Update handler."""
+        # We check if the children field is passed and it's different to the values stored
+        if "children" in data and data["children"] != record.get("children", {}):
+            self.service.require_permission(identity, "manage_children", record=record)
+            record.children = record.children.from_dict(data["children"])
+
+
 DefaultCommunityComponents = [
     MetadataComponent,
     CommunityThemeComponent,
@@ -311,4 +328,5 @@ def update(self, identity, data=None, record=None, errors=None, **kwargs):
     FeaturedCommunityComponent,
     OAISetComponent,
     CommunityDeletionComponent,
+    ChildrenComponent,
 ]

invenio_communities/permissions.py

@@ -166,6 +166,9 @@ class CommunityPermissionPolicy(BasePermissionPolicy):
     can_set_theme = [SystemProcess()]
     can_delete_theme = can_set_theme
 
+    # Permissions to set if communities can have children
+    can_manage_children = [SystemProcess()]
+
 
 def can_perform_action(community, context):
     """Check if the given action is available on the request."""

tests/communities/test_components.py

@@ -130,3 +130,17 @@ def test_oai_set_update(community_service, comm, comm_restricted):
     assert comm.data.get("slug") in oaiset.spec
     assert new_data.get("metadata", {}).get("title") in oaiset.description
     assert new_data.get("metadata", {}).get("title") in oaiset.name
+
+
+def test_children_component(community_service, parent_community, db):
+    """Test children component."""
+    # By default it's set to False
+    assert parent_community.children.allow is False
+
+    parent_community.children.allow = True
+    parent_community.commit()
+    db.session.commit()
+
+    comm = community_service.record_cls.get_record(str(parent_community.id))
+
+    assert comm.children.allow is True

tests/communities/test_services.py

@@ -592,3 +592,38 @@ def test_theme_updates(
     community_service.update(system_identity, community.id, community_data)
     community_item = community_service.read(system_identity, community.id)
     assert community_item.data.get("theme") is None
+
+
+def test_children_updates(
+    app,
+    db,
+    search_clear,
+    location,
+    community_service,
+    community,
+    members,
+):
+    current_cache.clear()
+    owner = members["owner"]
+
+    # Update children
+    community_data = deepcopy(community.data)
+    community_data.update(dict(children=dict(allow=True)))
+
+    # check if owner can update the children
+    with pytest.raises(PermissionDeniedError):
+        community_service.update(owner.identity, community.id, community_data)
+
+    # only system can update the children
+    community_service.update(system_identity, community.id, community_data)
+    community_item = community_service.read(system_identity, community.id)
+    assert community_item.data["children"]["allow"] == True
+
+    # Update community data without passing children should keep the stored values
+    community_data = deepcopy(community_item.data)
+    community_data.pop("children")
+
+    # Owner should be able to perfrom this operation since is not changing the children
+    community_service.update(owner.identity, community.id, community_data)
+    # Refresh index
+    community_service.record_cls.index.refresh()