Implementing SymphonyGroup extension

Author: symphony-mariacristina

examples/extension/groups_extension.py

@@ -0,0 +1,64 @@
+import asyncio
+import logging.config
+from pathlib import Path
+
+from symphony.bdk.core.config.loader import BdkConfigLoader
+from symphony.bdk.core.symphony_bdk import SymphonyBdk
+from symphony.bdk.ext.group import SymphonyGroupBdkExtension, SymphonyGroupService
+from symphony.bdk.gen.group_model.base_profile import BaseProfile
+from symphony.bdk.gen.group_model.create_group import CreateGroup
+from symphony.bdk.gen.group_model.member import Member
+from symphony.bdk.gen.group_model.owner import Owner
+from symphony.bdk.gen.group_model.status import Status
+from symphony.bdk.gen.group_model.update_group import UpdateGroup
+
+logging.config.fileConfig(Path(__file__).parent.parent / "logging.conf", disable_existing_loggers=False)
+
+
+async def run():
+    async with SymphonyBdk(BdkConfigLoader.load_from_symphony_dir("configDevx3.yaml")) as bdk:
+        bdk.extensions().register(SymphonyGroupBdkExtension)
+        group_service: SymphonyGroupService = bdk.extensions().service(SymphonyGroupBdkExtension)
+        await group_service._oauth_session.refresh()
+
+        # list groups
+        groups = await group_service.list_groups(status=Status("ACTIVE"))
+        logging.debug(f"List groups: {groups}")
+
+        # create a new group
+        profile = BaseProfile(display_name="Mary's SDL")
+        member = Member(member_tenant=190, member_id=13056700580915)
+        create_group = CreateGroup(type="SDL", owner_type=Owner(value="TENANT"), owner_id=190, name="Another SDL",
+                                   members=[member], profile=profile)
+        group = await group_service.insert_group(create_group=create_group)
+        logging.debug(f"Group created: {group}")
+
+        # update group name
+        update_group = UpdateGroup(name="Updated name", type=group.type, owner_type=Owner(value="TENANT"),
+                                   owner_id=group.owner_id, id=group.id, e_tag=group.e_tag,
+                                   status=Status(value="ACTIVE"), profile=profile, members=[member])
+        group = await group_service.update_group(if_match=group.e_tag, group_id=group.id, update_group=update_group)
+        logging.debug(f"Group after name update: {group}")
+
+        # add member to a group
+        group = await group_service.add_member_to_group(group.id, 13056700580913)
+        logging.debug(f"Group after a new member is added: {group}")
+
+        # update group avatar
+        image_base_64 = "base_64_format_image"
+        group = await group_service.update_avatar(group_id=group.id, image=image_base_64)
+        logging.debug(f"Group after avatar update: {group}")
+
+        # get a group by id
+        group = await group_service.get_group(group_id=group.id)
+        logging.debug(f"Retrieve group by id: {group}")
+
+        # Delete group
+        update_group = UpdateGroup(name=group.name, type=group.type, owner_type=Owner(value="TENANT"),
+                                   owner_id=group.owner_id, id=group.id, e_tag=group.e_tag,
+                                   status=Status(value="DELETED"), profile=profile, members=[member])
+        group = await group_service.update_group(if_match=group.e_tag, group_id=group.id, update_group=update_group)
+        logging.debug(f"Group removed: {group}")
+
+
+asyncio.run(run())

poetry.lock

@@ -38,6 +38,7 @@ def __init__(self, config):
                                                                       self._config.bot.certificate.path)
         self._app_session_auth_client = self._get_api_client_with_client_cert(self._config.session_auth, SESSION_AUTH,
                                                                               self._config.app.certificate.path)
+        self._custom_clients = []
 
     def get_login_client(self) -> ApiClient:
         """Returns a fully initialized ApiClient for Login API.
@@ -53,6 +54,16 @@ def get_pod_client(self) -> ApiClient:
         """
         return self._pod_client
 
+    def get_client(self, context_path):
+        """Returns a fully initialized custom ApiClient
+
+        :param context_path: custom path to be used in the client
+        :return: an ApiClient instance
+        """
+        client = self._get_api_client(self._config.pod, context_path)
+        self._custom_clients.append(client)
+        return client
+
     def get_relay_client(self) -> ApiClient:
         """Returns a fully initialized ApiClient for Key Manager API.
 
@@ -99,6 +110,8 @@ async def close_clients(self):
         await self._session_auth_client.close()
         await self._key_auth_client.close()
         await self._app_session_auth_client.close()
+        for client in self._custom_clients:
+            await client.close()
 
     def _get_api_client(self, server_config, context) -> ApiClient:
         configuration = self._get_client_config(context, server_config)

symphony/bdk/core/client/api_client_factory.py

@@ -0,0 +1,59 @@
+"""Module containing utility function to extract the tenant ID from a user ID.
+The user ID is a combination of a unique tenant ID, and a unique sub-tenant ID, combined into a number.
+The tenant ID is stored in the 27 highest bits (minus the sign bit which is unused so that all IDs remain a
+positive value) which allows for 134 million pods.
+This leaves 36 lowest bits for the user ID, which allows 68.7 billion users per tenant.
+"""
+TENANT_ID_BIT_LENGTH = 27
+SUBTENANT_ID_BIT_LENGTH = 36
+TENANT_ID_INDEX = 1
+
+
+def extract_tenant_id(user_id: int):
+    """Extracts the tenant ID from a user ID.
+
+    :param user_id: the user ID.
+    :return: the tenant ID.
+    """
+    number_util = NumberUtil(sizes=[SUBTENANT_ID_BIT_LENGTH, TENANT_ID_BIT_LENGTH])
+    return number_util.extract(user_id, TENANT_ID_INDEX)
+
+
+class NumberUtil:
+    """Used to compute the segments bases in the input sizes
+    """
+
+    def __init__(self, sizes: []):
+        self._segments = []
+        self._total_size = 0
+        self._shift = 0
+
+        for size in sizes:
+            segment = Segment(size, self._shift)
+            self._shift += size
+            self._segments.append(segment)
+            self._total_size += size
+
+        if self._total_size > 64:
+            raise ValueError("total size is larger than the bit-count of 64")
+
+    def extract(self, value: int, index: int):
+        """Extract the tenant_id given the user_id and the index
+        """
+        segment = self._segments[index]
+        return value >> segment._shift & segment._mask
+
+
+class Segment:
+    """Helper class to initialize a Segment
+    """
+
+    def __init__(self, size: int, shift: int):
+        mask = 0
+        for _ in range(size):
+            mask |= 1
+            mask <<= 1
+
+        mask >>= 1
+        self._mask = mask
+        self._shift = shift

symphony/bdk/core/service/user/user_util.py

@@ -119,7 +119,7 @@ def _initialize_bot_services(self):
         self._activity_registry = ActivityRegistry(self._session_service)
         self._datafeed_loop.subscribe(self._activity_registry)
         # initialises extension service and register decorated extensions
-        self._extension_service = ExtensionService(self._bot_session, self._config, self._api_client_factory)
+        self._extension_service = ExtensionService(self._api_client_factory, self._bot_session, self._config)
 
     @bot_service
     def bot_session(self) -> AuthSession: