pyxecm 2.0.3__py3-none-any.whl → 2.0.4__py3-none-any.whl

pyxecm/otcs.py

@@ -27,10 +27,12 @@ import threading
 import time
 import urllib.parse
 import zipfile
+from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timezone
 from functools import cache
 from http import HTTPStatus
 from importlib.metadata import version
+from queue import Empty, LifoQueue, Queue
 
 import requests
 import websockets
@@ -148,6 +150,16 @@ class OTCS:
     ITEM_TYPE_WORKFLOW_MAP = 128
     ITEM_TYPE_WORKFLOW_STATUS = 190
 
+    CONTAINER_ITEM_TYPES = [
+        ITEM_TYPE_FOLDER,
+        ITEM_TYPE_BUSINESS_WORKSPACE,
+        ITEM_TYPE_COMPOUND_DOCUMENT,
+        ITEM_TYPE_CLASSIFICATION,
+        VOLUME_TYPE_ENTERPRISE_WORKSPACE,
+        VOLUME_TYPE_CLASSIFICATION_VOLUME,
+        VOLUME_TYPE_CONTENT_SERVER_DOCUMENT_TEMPLATES,
+    ]
+
     PERMISSION_TYPES = [
         "see",
         "see_contents",
@@ -166,6 +178,10 @@ class OTCS:
         "public",
         "custom",
     ]
+
+    # The maximum length of an item name in OTCS:
+    MAX_ITEM_NAME_LENGTH = 248
+
     _config: dict
     _otcs_ticket = None
     _otds_ticket = None
@@ -183,6 +199,42 @@ class OTCS:
     )  # only 1 thread should handle the re-authentication
     _session_lock = threading.Lock()
 
+    @classmethod
+    def cleanse_item_name(cls, item_name: str, max_length: int | None = None) -> str:
+        """Cleanse the given name of an OTCS item.
+
+        Control for forbidden characters and check the item name length.
+
+        Args:
+            item_name (str):
+                The item name to cleanse.
+            max_length (int, optional):
+                A specific maximum length for custom cases.
+                If not provided we will use the default OTCS.MAX_ITEM_NAME_LENGTH.
+
+        Returns:
+            str:
+                The cleansed item name.
+
+        """
+
+        # If no custom max length is given we use the default:
+        if max_length is None:
+            max_length = OTCS.MAX_ITEM_NAME_LENGTH
+
+        # Item names for sure are not allowed to have ":":
+        item_name = item_name.replace(":", "")
+        # Item names for sure should not have leading or trailing spaces:
+        item_name = item_name.strip()
+        # Truncate the item name to 248 characters which is the maximum
+        # allowed length in Content Server
+        if len(item_name) > max_length:
+            item_name = item_name[:max_length]
+
+        return item_name
+
+    # end method definition
+
     @classmethod
     def date_is_newer(cls, date_old: str, date_new: str) -> bool:
         """Compare two dates, typically create or modification dates.
@@ -461,6 +513,7 @@ class OTCS:
         self._semaphore = threading.BoundedSemaphore(value=thread_number)
         self._last_session_renewal = 0
         self._use_numeric_category_identifier = use_numeric_category_identifier
+        self._executor = ThreadPoolExecutor(max_workers=thread_number)
 
     # end method definition
 
@@ -734,6 +787,21 @@ class OTCS:
 
     # end method definition
 
+    def clear_data(self) -> Data:
+        """Reset the data object to an empty data frame.
+
+        Returns:
+            Data:
+                Newly initialized data object.
+
+        """
+
+        self._data = Data(logger=self.logger)
+
+        return self._data
+
+    # end method definition
+
     def request_form_header(self) -> dict:
         """Deliver the request header used for the CRUD REST API calls.
 
@@ -1457,7 +1525,7 @@ class OTCS:
         property_name: str = "properties",
         data_name: str = "data",
     ) -> list | None:
-        """Read an item value from the REST API response.
+        """Read all values with a given key from the REST API response.
 
         This method handles the most common response structures delivered by the
         V2 REST API of Extended ECM. For more details, refer to the documentation at
@@ -1551,6 +1619,44 @@ class OTCS:
 
     # end method definition
 
+    def get_result_values_iterator(
+        self,
+        response: dict,
+        property_name: str = "properties",
+        data_name: str = "data",
+    ) -> iter:
+        """Get an iterator object that can be used to traverse through OTCS responses.
+
+        This method handles the most common response structures delivered by the
+        V2 REST API of Extended ECM. For more details, refer to the documentation at
+        developer.opentext.com.
+
+        Args:
+            response (dict):
+                REST API response object.
+            property_name (str, optional):
+                Name of the sub-dictionary holding the actual values.
+                Defaults to "properties".
+            data_name (str, optional):
+                Name of the sub-dictionary holding the data.
+                Defaults to "data".
+
+        Returns:
+            list | None:
+                Value list of the item with the given key, or None if no value is found.
+
+        """
+
+        # First do some sanity checks:
+        if not response:
+            return
+        if "results" not in response:
+            return
+
+        yield from (item[data_name][property_name] for item in response["results"])
+
+    # end method definition
+
     def is_configured(self) -> bool:
         """Check if the Content Server pod is configured to receive requests.
 
@@ -2036,63 +2142,141 @@ class OTCS:
 
     # end method definition
 
-    @cache
-    def get_user(self, name: str, user_type: int = 0, show_error: bool = False) -> dict | None:
-        """Look up an Content Server user based on the login name.
+    def get_users(
+        self,
+        where_type: int = 0,
+        where_name: str | None = None,
+        where_first_name: str | None = None,
+        where_last_name: str | None = None,
+        where_business_email: str | None = None,
+        query_string: str | None = None,
+        sort: str | None = None,
+        limit: int = 20,
+        page: int = 1,
+        show_error: bool = False,
+    ) -> dict | None:
+        """Get a Content Server users based on different criterias.
+
+        The criterias can be combined.
 
         Args:
-            name (str):
-                Name of the user (login).
-            user_type (int, optional):
+            where_type (int, optional):
                 Type ID of user:
                 0 - Regular User
                 17 - Service User
                 Defaults to 0 -> (Regular User)
-
+            where_name (str | None = None):
+                Name of the user (login).
+            where_first_name (str | None = None):
+                First name of the user.
+            where_last_name (str | None = None):
+                Last name of the user.
+            where_business_email (str | None = None):
+                Business email address of the user.
+            query_string (str | None = None):
+                Filters the results, returning the users with the specified query string
+                in any of the following fields: log-in name, first name, last name, email address,
+                and groups with the specified query string in the group name.
+                NOTE: query cannot be used together with any combination of: where_name,
+                where_first_name, where_last_name, where_business_email.
+                The query value will be used to perform a search within the log-in name,
+                first name, last name and email address properties for users and group name
+                for groups to see if that value is contained within any of those properties.
+                This differs from the user search that is performed in Classic UI where it
+                searches for a specific property that begins with the value provided by the user.
+            sort (str | None = None):
+                Order by named column (Using prefixes such as sort=asc_name or sort=desc_name).
+                Format can be sort = id, sort = name, sort = first_name, sort = last_name,
+                sort = group_id, sort = mailaddress. If the prefix of asc or desc is not used
+                then asc will be assumed.
+                Default is None.
+            limit (int, optional):
+                The maximum number of results per page (internal default is 10). OTCS does
+                not allow values > 20 so this method adjusts values > 20 to 20.
+            page (int, optional):
+                The page number to retrieve.
             show_error (bool, optional):
                 If True, treat as an error if the user is not found. Defaults to False.
 
         Returns:
             dict | None:
-                User information as a dictionary, or None if the user is not found.
+                User information as a dictionary, or None if the user could not be found
+                (e.g., because it doesn't exist).
 
         Example:
             ```json
             {
                 'collection': {
-                    'paging': {...},
-                    'sorting': {...}
+                    'paging': {
+                        'limit': 10,
+                        'page': 1,
+                        'page_total': 1,
+                        'range_max': 1,
+                        'range_min': 1,
+                        'total_count': 1
+                    },
+                    'sorting': {
+                        'sort': [
+                            {
+                                'key': 'sort',
+                                'value': 'asc_id'
+                            }
+                        ]
+                    }
                 },
                 'links': {
-                    'data': {...}
+                    'data': {
+                        'self': {
+                            'body': '',
+                            'content_type': '',
+                            'href': '/api/v2/members?where_first_name=Peter',
+                            'method': 'GET',
+                            'name': ''
+                        }
+                    }
                 },
                 'results': [
                     {
                         'data': {
-                            'birth_date': None,
-                            'business_email': 'pramos@M365x61936377.onmicrosoft.com',
-                            'business_fax': None,
-                            'business_phone': None,
-                            'cell_phone': None,
-                            'deleted': False,
-                            'display_language': None,
-                            'first_name': 'Peter',
-                            'gender': None,
-                            'group_id': 8006,
-                            'home_address_1': None,
-                            'home_address_2': None,
-                            'home_fax': None,
-                            'home_phone': None,
-                            'id': 8123,
-                            'initials': None,
-                            'last_name': 'Ramos',
-                            'middle_name': None,
-                            'name': 'pramos',
-                            'name_formatted': 'Peter Ramos',
-                            'photo_id': 13981,
-                            'photo_url': 'api/v1/members/8123/photo?v=13981.1',
-                            'type': 0,
-                            'type_name': 'User'
+                            'properties': {
+                                'birth_date': None,
+                                'business_email': 'pramos@M365x61936377.onmicrosoft.com',
+                                'business_fax': None,
+                                'business_phone': None,
+                                'cell_phone': None,
+                                'deleted': False,
+                                'display_language': None,
+                                'first_name': 'Peter',
+                                'gender': None,
+                                'group_id': 8006,
+                                'home_address_1': None,
+                                'home_address_2': None,
+                                'home_fax': None,
+                                'home_phone': None,
+                                'id': 8123,
+                                'initials': None,
+                                'last_name': 'Ramos',
+                                'middle_name': None,
+                                'name': 'pramos',
+                                'name_formatted': 'Peter Ramos',
+                                'office_location': None,
+                                'pager': None,
+                                'personal_email': None,
+                                'photo_id': 13981,
+                                'photo_url': 'api/v1/members/8123/photo?v=13981.1',
+                                'privilege_content_manager': False,
+                                'privilege_grant_discovery': False,
+                                'privilege_login': True,
+                                'privilege_modify_groups': False,
+                                'privilege_modify_users': False,
+                                'privilege_public_access': True,
+                                'privilege_system_admin_rights': False,
+                                'privilege_user_admin_rights': False,
+                                'time_zone': -1,
+                                'title': 'Maintenance Planner',
+                                'type': 0,
+                                'type_name': 'User'
+                            }
                         }
                     }
                 ]
@@ -2105,17 +2289,45 @@ class OTCS:
 
         """
 
-        # Add query parameters (these are NOT passed via JSon body!)
-        # type = 0 ==> regular User
-        query = {"where_type": user_type, "where_name": name}
+        # Add query parameters (embedded in the URL)
+        # Using type = 0 for OTCS groups or type = 17 for service user:
+        query = {}
+        filter_string = " type -> 'service user'" if where_type == 17 else ""
+        query["where_type"] = where_type
+        if where_name:
+            query["where_name"] = where_name
+            filter_string += " login name -> '{}'".format(where_name) if where_name else ""
+        if where_first_name:
+            query["where_first_name"] = where_first_name
+            filter_string += " first name -> '{}'".format(where_first_name) if where_first_name else ""
+        if where_last_name:
+            query["where_last_name"] = where_last_name
+            filter_string += " last name -> '{}'".format(where_last_name) if where_last_name else ""
+        if where_business_email:
+            query["where_business_email"] = where_business_email
+            filter_string += " business email -> '{}'".format(where_business_email) if where_business_email else ""
+        if query_string:
+            query["query"] = query_string
+            filter_string += " query -> '{}'".format(query_string) if where_business_email else ""
+        if sort:
+            query["sort"] = sort
+        if limit:
+            if limit > 20:
+                self.logger.warning(
+                    "Page limit for user query cannot be larger than 20. Adjusting from %d to 20.", limit
+                )
+                limit = 20
+            query["limit"] = limit
+        if page:
+            query["page"] = page
         encoded_query = urllib.parse.urlencode(query=query, doseq=True)
         request_url = self.config()["membersUrlv2"] + "?{}".format(encoded_query)
 
         request_header = self.request_form_header()
 
         self.logger.debug(
-            "Get user with login name -> '%s'; calling -> %s",
-            name,
+            "Get users%s; calling -> %s",
+            " with{}".format(filter_string) if filter_string else "",
             request_url,
         )
 
@@ -2124,105 +2336,287 @@ class OTCS:
             method="GET",
             headers=request_header,
             timeout=None,
-            failure_message="Failed to get user with login -> '{}'".format(name),
-            warning_message="Couldn't find user with login -> '{}'".format(name),
+            failure_message="Failed to get users{}".format(" with{}".format(filter_string) if filter_string else ""),
+            warning_message="Couldn't find users{}".format(" with{}".format(filter_string) if filter_string else ""),
             show_error=show_error,
         )
 
     # end method definition
 
-    def add_user(
+    def get_users_iterator(
         self,
-        name: str,
-        password: str,
-        first_name: str,
-        last_name: str,
-        email: str,
-        title: str,
-        base_group: int,
-        privileges: list | None = None,
-        user_type: int = 0,
-    ) -> dict | None:
-        """Add Content Server user.
-
-        Args:
-            name (str):
-                The login name of the user.
-            password (str):
-                The password of the user.
-            first_name (str):
-                The first name of the user.
-            last_name (str):
-                The last name of the user.
-            email (str):
-                The email address of the user.
-            title (str):
-                The title of the user.
-            base_group (int):
-                The base group id of the user (e.g. department)
-            privileges (list, optional):
-                Possible values are Login, Public Access, Content Manager,
-                Modify Users, Modify Groups, User Admin Rights,
-                Grant Discovery, System Admin Rights
-            user_type (int, optional):
-                The ID of the user type. 0 = regular user, 17 = service user.
-
-        Returns:
-            dict | None:
-                User information or None if the user couldn't be created
-                (e.g. because it exisits already).
+        where_type: int = 0,
+        where_name: str | None = None,
+        where_first_name: str | None = None,
+        where_last_name: str | None = None,
+        where_business_email: str | None = None,
+        query_string: str | None = None,
+        sort: str | None = None,
+        limit: int = 20,
+    ) -> iter:
+        """Get an iterator object that can be used to traverse OTCS users.
 
-        """
+        Filters can be applied that are given by the "where" and "query" parameters.
 
-        if privileges is None:
-            privileges = ["Login", "Public Access"]
+        Using a generator avoids loading a large users into memory at once.
+        Instead you can iterate over the potential large list of users.
 
-        user_post_body = {
-            "type": user_type,
-            "name": name,
-            "password": password,
-            "first_name": first_name,
-            "last_name": last_name,
-            "business_email": email,
-            "title": title,
-            "group_id": base_group,
-            "privilege_login": ("Login" in privileges),
-            "privilege_public_access": ("Public Access" in privileges),
-            "privilege_content_manager": ("Content Manager" in privileges),
-            "privilege_modify_users": ("Modify Users" in privileges),
-            "privilege_modify_groups": ("Modify Groups" in privileges),
-            "privilege_user_admin_rights": ("User Admin Rights" in privileges),
-            "privilege_grant_discovery": ("Grant Discovery" in privileges),
-            "privilege_system_admin_rights": ("System Admin Rights" in privileges),
-        }
+        Example usage:
+            ```python
+            users = otcs_object.get_users_iterator(where_type=0, limit=10)
+            for user in users:
+                logger.info(
+                    "Traversing user -> '%s' (%s)",
+                    otcs_object.get_result_value(response=user, key="name"),
+                    otcs_object.get_result_value(response=user, key="id"),
+                )
+            ```
 
-        request_url = self.config()["membersUrlv2"]
-        request_header = self.request_form_header()
+        Args:
+            where_type (int, optional):
+                Type ID of user:
+                0 - Regular User
+                17 - Service User
+                Defaults to 0 -> (Regular User)
+            where_name (str | None = None):
+                Name of the user (login).
+            where_first_name (str | None = None):
+                First name of the user.
+            where_last_name (str | None = None):
+                Last name of the user.
+            where_business_email (str | None = None):
+                Business email address of the user.
+            query_string (str | None = None):
+                Filters the results, returning the users with the specified query string
+                in any of the following fields: log-in name, first name, last name, email address,
+                and groups with the specified query string in the group name.
+                NOTE: query cannot be used together with any combination of: where_name,
+                where_first_name, where_last_name, where_business_email.
+                The query value will be used to perform a search within the log-in name,
+                first name, last name and email address properties for users and group name
+                for groups to see if that value is contained within any of those properties.
+                This differs from the user search that is performed in Classic UI where it
+                searches for a specific property that begins with the value provided by the user.
+            sort (str | None = None):
+                Order by named column (Using prefixes such as sort=asc_name or sort=desc_name).
+                Format can be sort = id, sort = name, sort = first_name, sort = last_name,
+                sort = group_id, sort = mailaddress. If the prefix of asc or desc is not used
+                then asc will be assumed.
+                Default is None.
+            limit (int, optional):
+                The maximum number of results per page (internal default is 10). OTCS does
+                not allow values > 20 so this method adjusts values > 20 to 20.
 
-        self.logger.debug("Add user -> '%s'; calling -> %s", name, request_url)
+        Returns:
+            iter:
+                A generator yielding one user per iteration.
+                If the REST API fails, returns no value.
 
-        # Clear user cache
-        self.get_user.cache_clear()
+        """
 
-        return self.do_request(
-            url=request_url,
-            method="POST",
-            headers=request_header,
-            data=user_post_body,
-            timeout=None,
-            failure_message="Failed to add user -> '{}'".format(name),
+        # First we probe how many members we have:
+        response = self.get_users(
+            where_type=where_type,
+            where_name=where_name,
+            where_first_name=where_first_name,
+            where_last_name=where_last_name,
+            where_business_email=where_business_email,
+            query_string=query_string,
+            limit=1,
+            page=1,
         )
+        if not response or "results" not in response:
+            # Don't return None! Plain return is what we need for iterators.
+            # Natural Termination: If the generator does not yield, it behaves
+            # like an empty iterable when used in a loop or converted to a list:
+            return
 
-    # end method definition
+        number_of_users = response["collection"]["paging"]["total_count"]
+        if not number_of_users:
+            self.logger.warning(
+                "No users found! Cannot iterate over users.",
+            )
+            # Don't return None! Plain return is what we need for iterators.
+            # Natural Termination: If the generator does not yield, it behaves
+            # like an empty iterable when used in a loop or converted to a list:
+            return
 
-    def search_user(self, value: str, field: str = "where_name") -> dict | None:
+        # If the group has many members we need to go through all pages
+        # Adding page_size - 1 ensures that any remainder from the division is
+        # accounted for, effectively rounding up. Integer division (//) performs floor division,
+        # giving the desired number of pages:
+        total_pages = (number_of_users + limit - 1) // limit
+
+        for page in range(1, total_pages + 1):
+            # Get the next page of sub node items:
+            response = self.get_users(
+                where_type=where_type,
+                where_name=where_name,
+                where_first_name=where_first_name,
+                where_last_name=where_last_name,
+                where_business_email=where_business_email,
+                query_string=query_string,
+                sort=sort,
+                limit=limit,
+                page=page,
+            )
+            if not response or not response.get("results", None):
+                self.logger.warning(
+                    "Failed to retrieve users (page -> %d)",
+                    page,
+                )
+                return
+
+            # Yield nodes one at a time:
+            yield from response["results"]
+
+        # end for page in range(1, total_pages + 1)
+
+    # end method definition
+
+    @cache
+    def get_user(self, name: str, user_type: int = 0, show_error: bool = False) -> dict | None:
+        """Get a Content Server user based on the login name and type.
+
+        Args:
+            name (str):
+                Name of the user (login).
+            user_type (int, optional):
+                Type ID of user:
+                0 - Regular User
+                17 - Service User
+                Defaults to 0 -> (Regular User)
+
+            show_error (bool, optional):
+                If True, treat as an error if the user is not found. Defaults to False.
+
+        Returns:
+            dict | None:
+                User information as a dictionary, or None if the user could not be found
+                (e.g., because it doesn't exist).
+
+        Example:
+            ```json
+            {
+                'collection': {
+                    'paging': {
+                        'limit': 10,
+                        'page': 1,
+                        'page_total': 1,
+                        'range_max': 1,
+                        'range_min': 1,
+                        'total_count': 1
+                    },
+                    'sorting': {
+                        'sort': [
+                            {
+                                'key': 'sort',
+                                'value': 'asc_id'
+                            }
+                        ]
+                    }
+                },
+                'links': {
+                    'data': {
+                        'self': {
+                            'body': '',
+                            'content_type': '',
+                            'href': '/api/v2/members?where_first_name=Peter',
+                            'method': 'GET',
+                            'name': ''
+                        }
+                    }
+                },
+                'results': [
+                    {
+                        'data': {
+                            'properties': {
+                                'birth_date': None,
+                                'business_email': 'pramos@M365x61936377.onmicrosoft.com',
+                                'business_fax': None,
+                                'business_phone': None,
+                                'cell_phone': None,
+                                'deleted': False,
+                                'display_language': None,
+                                'first_name': 'Peter',
+                                'gender': None,
+                                'group_id': 8006,
+                                'home_address_1': None,
+                                'home_address_2': None,
+                                'home_fax': None,
+                                'home_phone': None,
+                                'id': 8123,
+                                'initials': None,
+                                'last_name': 'Ramos',
+                                'middle_name': None,
+                                'name': 'pramos',
+                                'name_formatted': 'Peter Ramos',
+                                'office_location': None,
+                                'pager': None,
+                                'personal_email': None,
+                                'photo_id': 13981,
+                                'photo_url': 'api/v1/members/8123/photo?v=13981.1',
+                                'privilege_content_manager': False,
+                                'privilege_grant_discovery': False,
+                                'privilege_login': True,
+                                'privilege_modify_groups': False,
+                                'privilege_modify_users': False,
+                                'privilege_public_access': True,
+                                'privilege_system_admin_rights': False,
+                                'privilege_user_admin_rights': False,
+                                'time_zone': -1,
+                                'title': 'Maintenance Planner',
+                                'type': 0,
+                                'type_name': 'User'
+                            }
+                        }
+                    }
+                ]
+            }
+            ```
+
+            To access the (login) name of the first user found, use
+            `["results"][0]["data"]["properties"]["name"]`.
+            Alternatively, use the method `get_result_value(response, "name", 0)`.
+
+        """
+
+        # Add query parameters (embedded in the URL)
+        # Using type = 0 for OTCS groups or type = 17 for service user:
+        query = {"where_type": user_type, "where_name": name}
+        encoded_query = urllib.parse.urlencode(query=query, doseq=True)
+        request_url = self.config()["membersUrlv2"] + "?{}".format(encoded_query)
+
+        request_header = self.request_form_header()
+
+        self.logger.debug(
+            "Get user with login name -> '%s'%s; calling -> %s",
+            name,
+            ", type -> 'service user'" if user_type == 17 else "",
+            request_url,
+        )
+
+        return self.do_request(
+            url=request_url,
+            method="GET",
+            headers=request_header,
+            timeout=None,
+            failure_message="Failed to get user with login -> '{}' and type -> {}".format(name, user_type),
+            warning_message="Couldn't find user with login -> '{}' and type -> {}".format(name, user_type),
+            show_error=show_error,
+        )
+
+    # end method definition
+
+    def search_user(self, value: str, field: str = "where_name") -> dict | None:
         """Find a user based on search criteria.
 
         Args:
             value (str):
                 Field value to search for.
             field (str):
-                User field to search with (e.g. "where_name", "where_first_name", "where_last_name").
+                User field to search with (e.g. "where_type", "where_name",
+                "where_first_name", "where_last_name", "where_business_email", "query").
 
         Returns:
             dict | None:
@@ -2233,11 +2627,34 @@ class OTCS:
             ```json
             {
                 'collection': {
-                    'paging': {...},
-                    'sorting': {...}
+                    'paging': {
+                        'limit': 10,
+                        'links': {'data': {...}},
+                        'page': 1,
+                        'page_total': 2,
+                        'range_max': 10,
+                        'range_min': 1,
+                        'total_count': 11
+                    },
+                    'sorting': {
+                        'sort': [
+                            {
+                                'key': 'sort',
+                                'value': 'asc_id'
+                            }
+                        ]
+                    }
                 },
                 'links': {
-                    'data': {...}
+                    'data': {
+                        'self': {
+                            'body': '',
+                            'content_type': '',
+                            'href': '/api/v2/members?where_first_name=Peter',
+                            'method': 'GET',
+                            'name': ''
+                        }
+                    }
                 },
                 'results': [
                     {
@@ -2263,7 +2680,23 @@ class OTCS:
                                 'middle_name': None,
                                 'name': 'dfoxhoven',
                                 'name_formatted': 'Deke Foxhoven',
-                                ...
+                                'office_location': None,
+                                'pager': None,
+                                'personal_email': None,
+                                'photo_id': 17467,
+                                'photo_url': 'api/v1/members/8123/photo?v=17467.1',
+                                'privilege_content_manager': False,
+                                'privilege_grant_discovery': False,
+                                'privilege_login': True,
+                                'privilege_modify_groups': False,
+                                'privilege_modify_users': False,
+                                'privilege_public_access': True,
+                                'privilege_system_admin_rights': False,
+                                'privilege_user_admin_rights': False,
+                                'time_zone': -1,
+                                'title': 'Contract Manager',
+                                'type': 0,
+                                'type_name': 'User'
                             }
                         }
                     }
@@ -2296,6 +2729,90 @@ class OTCS:
 
     # end method definition
 
+    def add_user(
+        self,
+        name: str,
+        password: str,
+        first_name: str,
+        last_name: str,
+        email: str,
+        title: str,
+        base_group: int,
+        privileges: list | None = None,
+        user_type: int = 0,
+    ) -> dict | None:
+        """Add Content Server user.
+
+        Args:
+            name (str):
+                The login name of the user.
+            password (str):
+                The password of the user.
+            first_name (str):
+                The first name of the user.
+            last_name (str):
+                The last name of the user.
+            email (str):
+                The email address of the user.
+            title (str):
+                The title of the user.
+            base_group (int):
+                The base group id of the user (e.g. department)
+            privileges (list, optional):
+                Possible values are Login, Public Access, Content Manager,
+                Modify Users, Modify Groups, User Admin Rights,
+                Grant Discovery, System Admin Rights
+            user_type (int, optional):
+                The ID of the user type. 0 = regular user, 17 = service user.
+
+        Returns:
+            dict | None:
+                User information or None if the user couldn't be created
+                (e.g. because it exisits already).
+
+        """
+
+        if privileges is None:
+            privileges = ["Login", "Public Access"]
+
+        user_post_body = {
+            "type": user_type,
+            "name": name,
+            "password": password,
+            "first_name": first_name,
+            "last_name": last_name,
+            "business_email": email,
+            "title": title,
+            "group_id": base_group,
+            "privilege_login": ("Login" in privileges),
+            "privilege_public_access": ("Public Access" in privileges),
+            "privilege_content_manager": ("Content Manager" in privileges),
+            "privilege_modify_users": ("Modify Users" in privileges),
+            "privilege_modify_groups": ("Modify Groups" in privileges),
+            "privilege_user_admin_rights": ("User Admin Rights" in privileges),
+            "privilege_grant_discovery": ("Grant Discovery" in privileges),
+            "privilege_system_admin_rights": ("System Admin Rights" in privileges),
+        }
+
+        request_url = self.config()["membersUrlv2"]
+        request_header = self.request_form_header()
+
+        self.logger.debug("Add user -> '%s'; calling -> %s", name, request_url)
+
+        # Clear user cache
+        self.get_user.cache_clear()
+
+        return self.do_request(
+            url=request_url,
+            method="POST",
+            headers=request_header,
+            data=user_post_body,
+            timeout=None,
+            failure_message="Failed to add user -> '{}'".format(name),
+        )
+
+    # end method definition
+
     def update_user(self, user_id: int, field: str, value: str) -> dict | None:
         """Update a defined field for a user.
 
@@ -2657,64 +3174,286 @@ class OTCS:
 
         """
 
-        request_url = self.config()["favoritesUrl"] + "/" + str(node_id)
+        request_url = self.config()["favoritesUrl"] + "/" + str(node_id)
+        request_header = self.request_form_header()
+
+        self.logger.debug(
+            "Adding favorite for node ID -> %s; calling -> %s",
+            node_id,
+            request_url,
+        )
+
+        return self.do_request(
+            url=request_url,
+            method="POST",
+            headers=request_header,
+            timeout=None,
+            failure_message="Failed to add favorite for node ID -> {}".format(node_id),
+        )
+
+    # end method definition
+
+    def add_favorite_tab(self, tab_name: str, order: int) -> dict | None:
+        """Add a favorite tab for the current (authenticated) user.
+
+        Args:
+            tab_name (str):
+                The name of the new tab.
+            order (int):
+                The ordering position of the new tab.
+
+        Returns:
+            dict | None:
+                Request response or None if the favorite tab creation request has failed.
+
+        """
+
+        favorite_tab_post_body = {"name": tab_name, "order": str(order)}
+
+        request_url = self.config()["favoritesUrl"] + "/tabs"
+        request_header = self.request_form_header()
+
+        self.logger.debug(
+            "Adding favorite tab -> %s; calling -> %s",
+            tab_name,
+            request_url,
+        )
+
+        return self.do_request(
+            url=request_url,
+            method="POST",
+            headers=request_header,
+            data=favorite_tab_post_body,
+            timeout=None,
+            failure_message="Failed to add favorite tab -> {}".format(tab_name),
+        )
+
+    # end method definition
+
+    def get_groups(
+        self,
+        where_name: str | None = None,
+        sort: str | None = None,
+        limit: int = 20,
+        page: int = 1,
+        show_error: bool = False,
+    ) -> dict | None:
+        """Get a list of Content Server groups.
+
+        Args:
+            where_name (str | None = None):
+                The name of the group to look up.
+            sort (str | None = None):
+                Order by named column (Using prefixes such as sort=asc_name or sort=desc_name).
+                Format can be sort = id, sort = name, sort = group_id.
+                If the prefix of asc or desc is not used then asc will be assumed.
+                Default is None.
+            limit (int, optional):
+                The maximum number of results per page (internal default is 10). OTCS does
+                not allow values > 20 so this method adjusts values > 20 to 20.
+            page (int, optional):
+                The page number to retrieve.
+            show_error (bool, optional):
+                If True, treats the absence of the group as an error. Defaults to False.
+
+        Returns:
+            dict | None:
+                Group information as a dictionary, or None if the group is not found.
+
+        Example:
+            ```json
+                {
+                    'collection': {
+                        'paging': {
+                            'limit': 10,
+                            'page': 1,
+                            'page_total': 1,
+                            'range_max': 1,
+                            'range_min': 1,
+                            'total_count': 1
+                        },
+                        'sorting': {
+                            'sort': [
+                                {
+                                    'key': 'sort',
+                                    'value': 'asc_id'
+                                }
+                            ]
+                        }
+                    },
+                    'links': {
+                        'data': {
+                            'self': {
+                                'body': '',
+                                'content_type': '',
+                                'href': '/api/v2/members?where_name=Procurement&where_type=1',
+                                'method': 'GET',
+                                'name': ''
+                            }
+                        }
+                    },
+                    'results': [
+                        {
+                            'data': {
+                                'properties': {
+                                    'deleted': False,
+                                    'id': 17649,
+                                    'initials': 'P',
+                                    'leader_id': None,
+                                    'name': 'Procurement',
+                                    'name_formatted': 'Procurement',
+                                    'type': 1,
+                                    'type_name': 'Group'
+                                }
+                            }
+                        }
+                    ]
+                }
+            ```
+
+            To access the ID of the first group found, use ["results"][0]["data"]["properties"]["id"].
+            Or use the method get_result_value(response, key="id")
+
+        """
+
+        # Add query parameters (embedded in the URL)
+        # Using type = 1 for OTCS groups:
+        query = {"where_type": 1}
+        if where_name:
+            query["where_name"] = where_name
+        if sort:
+            query["sort"] = sort
+        if limit:
+            if limit > 20:
+                self.logger.warning(
+                    "Page limit for group query cannot be larger than 20. Adjusting from %d to 20.", limit
+                )
+                limit = 20
+            query["limit"] = limit
+        if page:
+            query["page"] = page
+        encoded_query = urllib.parse.urlencode(query=query, doseq=True)
+        request_url = self.config()["membersUrlv2"] + "?{}".format(encoded_query)
+
         request_header = self.request_form_header()
 
         self.logger.debug(
-            "Adding favorite for node ID -> %s; calling -> %s",
-            node_id,
+            "Get groups%s; calling -> %s",
+            " with name -> '{}'".format(where_name) if where_name else "",
             request_url,
         )
 
         return self.do_request(
             url=request_url,
-            method="POST",
+            method="GET",
             headers=request_header,
             timeout=None,
-            failure_message="Failed to add favorite for node ID -> {}".format(node_id),
+            failure_message="Failed to get groups{}".format(
+                " with name -> '{}'".format(where_name) if where_name else ""
+            ),
+            warning_message="Groups{} do not yet exist!".format(
+                " with name -> '{}'".format(where_name) if where_name else ""
+            ),
+            show_error=show_error,
         )
 
     # end method definition
 
-    def add_favorite_tab(self, tab_name: str, order: int) -> dict | None:
-        """Add a favorite tab for the current (authenticated) user.
+    def get_groups_iterator(
+        self,
+        where_name: str | None = None,
+        sort: str | None = None,
+        limit: int = 20,
+    ) -> iter:
+        """Get an iterator object that can be used to traverse OTCS groups.
+
+        Filters can be applied that are given by the "where" and "query" parameters.
+
+        Using a generator avoids loading a large number of groups into memory at once.
+        Instead you can iterate over the potential large list of groups.
+
+        Example usage:
+            ```python
+            groups = otcs_object.get_groups_iterator(limit=10)
+            for group in groups:
+                logger.info(
+                    "Traversing group -> '%s' (%s)",
+                    otcs_object.get_result_value(response=group, key="name"),
+                    otcs_object.get_result_value(response=group, key="id"),
+                )
+            ```
 
         Args:
-            tab_name (str):
-                The name of the new tab.
-            order (int):
-                The ordering position of the new tab.
+            where_name (str | None = None):
+                Name of the user (login).
+            sort (str | None = None):
+                Order by named column (Using prefixes such as sort=asc_name or sort=desc_name ).
+                Format can be sort = id, sort = name, sort = group_id.
+                If the prefix of asc or desc is not used then asc will be assumed.
+                Default is None.
+            limit (int, optional):
+                The maximum number of results per page (internal default is 10). OTCS does
+                not allow values > 20 so this method adjusts values > 20 to 20.
 
         Returns:
-            dict | None:
-                Request response or None if the favorite tab creation request has failed.
+            iter:
+                A generator yielding one group per iteration.
+                If the REST API fails, returns no value.
 
         """
 
-        favorite_tab_post_body = {"name": tab_name, "order": str(order)}
+        # First we probe how many members we have:
+        response = self.get_groups(
+            where_name=where_name,
+            limit=1,
+            page=1,
+        )
+        if not response or "results" not in response:
+            # Don't return None! Plain return is what we need for iterators.
+            # Natural Termination: If the generator does not yield, it behaves
+            # like an empty iterable when used in a loop or converted to a list:
+            return
 
-        request_url = self.config()["favoritesUrl"] + "/tabs"
-        request_header = self.request_form_header()
+        number_of_users = response["collection"]["paging"]["total_count"]
+        if not number_of_users:
+            self.logger.warning(
+                "No groups found! Cannot iterate over groups.",
+            )
+            # Don't return None! Plain return is what we need for iterators.
+            # Natural Termination: If the generator does not yield, it behaves
+            # like an empty iterable when used in a loop or converted to a list:
+            return
 
-        self.logger.debug(
-            "Adding favorite tab -> %s; calling -> %s",
-            tab_name,
-            request_url,
-        )
+        # If the group has many members we need to go through all pages
+        # Adding page_size - 1 ensures that any remainder from the division is
+        # accounted for, effectively rounding up. Integer division (//) performs floor division,
+        # giving the desired number of pages:
+        total_pages = (number_of_users + limit - 1) // limit
 
-        return self.do_request(
-            url=request_url,
-            method="POST",
-            headers=request_header,
-            data=favorite_tab_post_body,
-            timeout=None,
-            failure_message="Failed to add favorite tab -> {}".format(tab_name),
-        )
+        for page in range(1, total_pages + 1):
+            # Get the next page of sub node items:
+            response = self.get_groups(
+                where_name=where_name,
+                sort=sort,
+                limit=limit,
+                page=page,
+            )
+            if not response or not response.get("results", None):
+                self.logger.warning(
+                    "Failed to retrieve groups (page -> %d)",
+                    page,
+                )
+                return
+
+            # Yield nodes one at a time:
+            yield from response["results"]
+
+        # end for page in range(1, total_pages + 1)
 
     # end method definition
 
     def get_group(self, name: str, show_error: bool = False) -> dict | None:
-        """Look up a Content Server group.
+        """Get the Content Server group with a given name.
 
         Args:
             name (str):
@@ -2725,23 +3464,65 @@ class OTCS:
         Returns:
             dict | None:
                 Group information as a dictionary, or None if the group is not found.
-                The returned information has the following structure:
+
+        Example:
+            ```json
                 {
-                    "data": [
+                    'collection': {
+                        'paging': {
+                            'limit': 10,
+                            'page': 1,
+                            'page_total': 1,
+                            'range_max': 1,
+                            'range_min': 1,
+                            'total_count': 1
+                        },
+                        'sorting': {
+                            'sort': [
+                                {
+                                    'key': 'sort',
+                                    'value': 'asc_id'
+                                }
+                            ]
+                        }
+                    },
+                    'links': {
+                        'data': {
+                            'self': {
+                                'body': '',
+                                'content_type': '',
+                                'href': '/api/v2/members?where_name=Procurement&where_type=1',
+                                'method': 'GET',
+                                'name': ''
+                            }
+                        }
+                    },
+                    'results': [
                         {
-                            "id": 0,
-                            "name": "string",
-                            ...
+                            'data': {
+                                'properties': {
+                                    'deleted': False,
+                                    'id': 17649,
+                                    'initials': 'P',
+                                    'leader_id': None,
+                                    'name': 'Procurement',
+                                    'name_formatted': 'Procurement',
+                                    'type': 1,
+                                    'type_name': 'Group'
+                                }
+                            }
                         }
                     ]
                 }
+            ```
 
-                To access the ID of the first group found, use ["data"][0]["id"].
+            To access the ID of the first group found, use ["results"][0]["data"]["properties"]["id"].
+            Or use the method get_result_value(response, key="id")
 
         """
 
-        # Add query parameters (these are NOT passed via JSon body!)
-        # type = 1 ==> Group
+        # Add query parameters (embedded in the URL)
+        # Using type = 1 for OTCS groups:
         query = {"where_type": 1, "where_name": name}
         encoded_query = urllib.parse.urlencode(query=query, doseq=True)
         request_url = self.config()["membersUrlv2"] + "?{}".format(encoded_query)
@@ -2839,10 +3620,6 @@ class OTCS:
 
         query = {}
         query["where_type"] = str(member_type)
-        if limit:
-            query["limit"] = limit
-        if page:
-            query["page"] = page
         if where_name:
             query["where_name"] = where_name
         if where_first_name:
@@ -2851,12 +3628,13 @@ class OTCS:
             query["where_last_name"] = where_last_name
         if where_business_email:
             query["where_business_email"] = where_business_email
-
+        if limit:
+            query["limit"] = limit
+        if page:
+            query["page"] = page
         encoded_query = urllib.parse.urlencode(query=query, doseq=True)
-
-        # default limit is 25 which may not be enough for groups with many members
-        # where_type = 1 makes sure we just get groups and not users
         request_url = self.config()["membersUrlv2"] + "/" + str(group) + "/members?{}".format(encoded_query)
+
         request_header = self.request_form_header()
 
         self.logger.debug(
@@ -2891,8 +3669,8 @@ class OTCS:
 
         Filters can be applied that are given by the "where" parameters.
 
-        Using a generator avoids loading a large number of nodes into memory at once.
-        Instead you can iterate over the potential large list of related workspaces.
+        Using a generator avoids loading a large number of group members into memory at once.
+        Instead you can iterate over the potential large list of group members.
 
         Example usage:
             ```python
@@ -6106,6 +6884,158 @@ class OTCS:
 
     # end method definition
 
+    def get_document_versions(self, node_id: str) -> list | None:
+        """Get a list of the document versions of a document node.
+
+        Args:
+            node_id (str):
+                Node ID of the document.
+
+        Returns:
+            list | None:
+                The list of document versions.
+
+        Example:
+        {
+            'links': {'data': {...}},
+            'results': [
+                {
+                    'data': {
+                        'versions': {
+                            'create_date': '2025-06-07T05:29:22Z',
+                            'description': '',
+                            'external_create_date': None,
+                            'external_identity': '',
+                            'external_identity_type': '',
+                            'external_modify_date': '2025-06-05T10:06:02',
+                            'external_source': 'file_system',
+                            'file_create_date': '2025-06-07T05:29:22Z',
+                            'file_modify_date': '2025-06-05T10:06:02Z',
+                            'file_name': 'OpenText-PPT-Presentation-FY25-LIGHT-FINAL.pptx',
+                            'file_size': 4057237,
+                            'file_type': 'pptx',
+                            'has_generation': False,
+                            'id': 107044,
+                            'locked': False,
+                            'locked_date': None,
+                            'locked_user_id': None,
+                            'mime_type': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+                            'modify_date': '2025-06-07T05:29:22Z',
+                            'name': 'OpenText-PPT-Presentation-FY25-LIGHT-FINAL.pptx',
+                            'owner_id': 1000,
+                            'provider_id': 103563,
+                            'version_id': 103564,
+                            'version_number': 2,
+                            'version_number_major': 0,
+                            'version_number_minor': 2,
+                            'version_number_name': '2'
+                        }
+                    }
+                }
+            ]
+        }
+
+        """
+
+        request_url = self.config()["nodesUrlv2"] + "/" + str(node_id) + "/versions"
+        request_header = self.request_form_header()
+
+        self.logger.debug(
+            "Get a list of all versions of document with node ID -> %s; calling -> %s",
+            str(node_id),
+            request_url,
+        )
+
+        return self.do_request(
+            url=request_url,
+            method="GET",
+            headers=request_header,
+            timeout=None,
+            failure_message="Failed to get list of versions of document with node ID -> {}".format(
+                str(node_id),
+            ),
+        )
+
+    # end method definition
+
+    def get_document_version(self, node_id: str, version_number: int) -> dict | None:
+        """Get a particular version of a document based on the version number.
+
+        The first version (oldest) typically has the number 1.
+
+        Args:
+            node_id (str):
+                Node ID of the document.
+            version_number (int):
+                The version number.
+
+        Returns:
+            dict | None:
+                The version data.
+
+        Example:
+        {
+            'links': {'data': {...}},
+            'results': {
+                'data': {
+                    'versions': {
+                        'create_date': '2025-06-07T05:29:22Z',
+                        'description': '',
+                        'external_create_date': None,
+                        'external_identity': '',
+                        'external_identity_type': '',
+                        'external_modify_date': '2025-06-05T10:06:02',
+                        'external_source': 'file_system',
+                        'file_create_date': '2025-06-07T05:29:22Z',
+                        'file_modify_date': '2025-06-05T10:06:02Z',
+                        'file_name': 'OpenText-PPT-Presentation-FY25-LIGHT-FINAL.pptx',
+                        'file_size': 4057237,
+                        'file_type': 'pptx',
+                        'has_generation': False,
+                        'id': 107044,
+                        'locked': False,
+                        'locked_date': None,
+                        'locked_user_id': None,
+                        'mime_type': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+                        'modify_date': '2025-06-07T05:29:22Z',
+                        'name': 'OpenText-PPT-Presentation-FY25-LIGHT-FINAL.pptx',
+                        'owner_id': 1000,
+                        'provider_id': 103563,
+                        'version_id': 103564,
+                        'version_number': 2,
+                        'version_number_major': 0,
+                        'version_number_minor': 2,
+                        'version_number_name': '2'
+                    }
+                }
+            }
+        }
+
+        """
+
+        request_url = self.config()["nodesUrlv2"] + "/" + str(node_id) + "/versions/" + str(version_number)
+        request_header = self.request_form_header()
+
+        self.logger.debug(
+            "Get version -> %d of document with node ID -> %s; calling -> %s",
+            version_number,
+            str(node_id),
+            request_url,
+        )
+
+        return self.do_request(
+            url=request_url,
+            method="GET",
+            headers=request_header,
+            timeout=None,
+            failure_message="Failed to get version -> {} of document with node ID -> {}".format(
+                version_number,
+                str(node_id),
+            ),
+        )
+
+    # end method definition
+
     def get_latest_document_version(self, node_id: int) -> dict | None:
         """Get latest version of a document node based on the node ID.
 
@@ -6119,6 +7049,7 @@ class OTCS:
 
         """
 
+        # This Method requires V1of the REST API!
         request_url = self.config()["nodesUrl"] + "/" + str(node_id) + "/versions/latest"
         request_header = self.request_form_header()
 
@@ -6140,6 +7071,63 @@ class OTCS:
 
     # end method definition
 
+    def purge_document_versions(self, node_id: int, versions_to_keep: int = 1) -> dict | None:
+        """Purge versions of a document based on the node ID of the document.
+
+        Args:
+            node_id (int):
+                The ID of the document node to purge versions for.
+            versions_to_keep (int):
+                Number of versions to keep (from the newest to the oldest).
+                The minimum allowed number is 1. This is also the default.
+                If 1 is provided it means to keep the nerwest version only.
+
+        Returns:
+            dict | None:
+                The result data or None if the request fails.
+
+        Example:
+        {
+            'links': {'data': {...}},
+            'results': {}
+        }
+
+        """
+
+        # Sanity check:
+        if versions_to_keep < 1:
+            self.logger.error("Purging to less than 1 version is not possible. The value -> %d is not valid!")
+            return None
+
+        request_url = self.config()["nodesUrlv2"] + "/" + str(node_id) + "/versions"
+        request_header = self.request_form_header()
+
+        purge_delete_body = {
+            "number_to_keep": versions_to_keep,
+        }
+
+        self.logger.debug(
+            "Purge document versions down to the newest%s version%s of document with node ID -> %s; calling -> %s",
+            " {}".format(versions_to_keep) if versions_to_keep > 1 else "",
+            "s" if versions_to_keep > 1 else "",
+            str(node_id),
+            request_url,
+        )
+
+        return self.do_request(
+            url=request_url,
+            method="DELETE",
+            headers=request_header,
+            data=purge_delete_body,
+            timeout=None,
+            failure_message="Failed to purge to {} versions of document with node ID -> {}".format(
+                versions_to_keep,
+                str(node_id),
+            ),
+        )
+
+    # end method definition
+
     def get_document_content(
         self,
         node_id: int,
@@ -6190,7 +7178,7 @@ class OTCS:
             method="GET",
             headers=request_header,
             timeout=None,
-            failure_message="Failed to download document with node ID -> {}".format(
+            failure_message="Failed to get content of document with node ID -> {}".format(
                 node_id,
             ),
             parse_request_response=parse_request_response,
@@ -6214,7 +7202,7 @@ class OTCS:
         node_id: int,
         version_number: str = "",
     ) -> list | dict | None:
-        """Get document content from Extended ECM and read content as JSON.
+        """Get document content from Content Server and parse content as JSON.
 
         Args:
             node_id (int):
@@ -6242,16 +7230,16 @@ class OTCS:
         self,
         node_id: int,
         file_path: str,
-        version_number: str = "",
+        version_number: str | int = "",
     ) -> bool:
-        """Download a document from Extended ECM to local file system.
+        """Download a document from OTCS to local file system.
 
         Args:
             node_id (int):
                 The node ID of the document to download
             file_path (str):
                 The local file path (directory).
-            version_number (str, optional):
+            version_number (str | int, optional):
                 The version of the document to download.
                 If version = "" then download the latest version.
 
@@ -6773,7 +7761,7 @@ class OTCS:
         connection_name: str,
         show_error: bool = False,
     ) -> dict | None:
-        """Get Extended ECM external system connection (e.g. SAP, Salesforce, SuccessFactors).
+        """Get external system connection (e.g. SAP, Salesforce, SuccessFactors).
 
         Args:
             connection_name (str):
@@ -7835,7 +8823,7 @@ class OTCS:
         """Get all workspace types configured in Extended ECM.
 
         This REST API is very limited. It does not return all workspace type properties
-        you can see in Extended ECM admin page.
+        you can see in OTCS business admin page.
 
         Args:
             expand_workspace_info (bool, optional):
@@ -9527,7 +10515,9 @@ class OTCS:
             method="GET",
             headers=request_header,
             timeout=None,
-            failure_message="Failed to get workspace members",
+            failure_message="Failed to get workspace members for workspace with ID -> {} and role with ID -> {}".format(
+                workspace_id, role_id
+            ),
         )
 
     # end method definition
@@ -9891,11 +10881,14 @@ class OTCS:
         """Get definition information for Unique Names.
 
         Args:
-            names (list): list of unique names to lookup.
-            subtype (int): filter unique names for those pointing to a specific subtype
+            names (list):
+                A list of unique names to lookup.
+            subtype (int):
+                A subtype ID to filter unique names to those pointing to a specific subtype.
 
         Returns:
-            dict | None: Unique name definition information or None if REST call fails.
+            dict | None:
+                Unique name definition information or None if REST call fails.
 
         Example:
             ```json
@@ -10555,7 +11548,7 @@ class OTCS:
         description: str = "",
         show_error: bool = True,
     ) -> dict | None:
-        """Create an Extended ECM wiki page.
+        """Create an OTCS wiki page.
 
         Args:
             wiki_id (int):
@@ -10752,11 +11745,11 @@ class OTCS:
     ) -> dict | None:
         """Assign an Content Server item to users and groups.
 
-        This is a function used by Extended ECM for Government.
+        This is a function used by OT Content Management for Government.
 
         Args:
             node_id (int):
-                The node ID of the Extended ECM item (e.g. a workspace or a document)
+                The node ID of the OTCS item (e.g. a workspace or a document)
             subject (str):
                 The title / subject of the assignment.
             instruction (str):
@@ -10895,7 +11888,7 @@ class OTCS:
         or both.
 
         Args:
-            node_id (int): The ID of the Extended ECM item (node) to which permissions are being assigned.
+            node_id (int): The ID of the OTCS item (node) to which permissions are being assigned.
             permissions (list of str): A list of permissions to assign to the assignee. Valid permissions include:
                 - "see"               : View the item
                 - "see_contents"      : View the contents of the item
@@ -11446,8 +12439,10 @@ class OTCS:
         throw an error.
 
         Args:
-            node_id (int): node ID to apply the category to
-            category_id (list): ID of the category definition object
+            node_id (int):
+                The node ID to apply the category to.
+            category_id (list):
+                The ID of the category definition object.
             inheritance (bool | None):
                 If True, turn on inheritance for the category
                 (this makes only sense if the node is a container like a folder or workspace).
@@ -13630,11 +14625,14 @@ class OTCS:
         """Get a list of available workflows for a document ID and a parent ID.
 
         Args:
-            node_id (int): node ID of the document
-            parent_id (int): node ID of the parent
+            node_id (int):
+                The node ID of the document.
+            parent_id (int):
+                The node ID of the parent.
 
         Returns:
-            list: list of available workflows
+            list:
+                The list of available workflows.
 
         Example:
             ```json
@@ -14665,44 +15663,295 @@ class OTCS:
 
     # end method definition
 
-    def volume_translator(
+    def traverse_node(
         self,
-        current_node_id: int,
-        translator: object,
-        languages: list,
-        simulate: bool = False,
-    ) -> None:
-        """Experimental code to translate the item names and descriptions in a hierarchy.
+        node: dict | int,
+        executables: list[callable],
+        current_depth: int = 0,
+        **kwargs: dict,
+    ) -> dict:
+        """Recursively traverse the node an its subnodes.
+
+        This method is preferred for CPU intensive traversals.
+
+        Args:
+            node (dict | int):
+                The node datastructure (like in a V2 REST Call response)
+            executables (list[callable]):
+                A list of methods to call for each traversed node. The node
+                and a optional dictionary of keyword arguments (kwargs)
+                are passed. The executables are called BEFORE the subnodes
+                are traversed. The executables should return a boolean result.
+                If the result is False, then the execution of the executables
+                list is stopped.
+            current_depth (int, optional):
+                The recursion depth - distance in hierarchy from the root note
+                traverse_node() was INITIALLY called from.
+            kwargs:
+                Additional keyword arguments for the executables.
+
+        Returns:
+            dict: {
+                "processed": int,
+                "traversed": int,
+            }
+
+        """
+
+        processed = 0
+        traversed = 0
+
+        # Initialze the traverse flag. If True, container
+        # subnodes will be processed. If executables exist
+        # than at least one executable has to indicate that
+        # further traversal is required:
+        traverse = not (executables)
+
+        if isinstance(node, dict):
+            node_id = self.get_result_value(response=node, key="id")
+        elif isinstance(node, int):
+            node_id = node
+            node = self.get_node(node_id=node_id)
+        else:
+            self.logger.error("Illegal type of node object. Expect 'int' or 'dict'!")
+            return (False, False)
+
+        # Run executables:
+        for executable in executables:
+            result_success, result_traverse = executable(node=node, current_depth=current_depth, **kwargs)
+            if result_traverse:
+                traverse = True
+            if not result_success:
+                break
+        else:
+            # else case is processed only if NO break occured in the for loop
+            # If all executables have been successful than the node counts as processed:
+            processed += 1
+
+        node_type = self.get_result_value(response=node, key="type")
+
+        # We only traverse the subtnodes if the current node is a container type
+        # and the executables have all been executed successfully:
+        if traverse and node_type in self.CONTAINER_ITEM_TYPES:
+            # Get children nodes of the current node:
+            subnodes = self.get_subnodes_iterator(parent_node_id=node_id, page_size=200)
+
+            # Recursive call of all subnodes:
+            for subnode in subnodes:
+                subnode_id = self.get_result_value(response=subnode, key="id")
+                subnode_name = self.get_result_value(response=subnode, key="name")
+                self.logger.info("Traversing node -> '%s' (%s)", subnode_name, str(subnode_id))
+                # Recursive call for current subnode:
+                result = self.traverse_node(
+                    node=subnode,
+                    executables=executables,
+                    current_depth=current_depth + 1,
+                    **kwargs,
+                )
+                processed += result.get("processed", 0)
+                traversed += result.get("traversed", 0)
+            traversed += 1
+
+        return {"processed": processed, "traversed": traversed}
+
+    # end method definition
+
+    def traverse_node_parallel(
+        self,
+        node: dict | int,
+        executables: list[callable],
+        workers: int = 3,
+        strategy: str = "BFS",
+        timeout: float = 1.0,
+        **kwargs: dict,
+    ) -> dict:
+        """Traverse nodes using a queue and thread pool (BFS-style).
+
+        This method is preferred for I/O or API intensive traversals.
+
+        Args:
+            node (dict | int):
+                Root node to start traversal. It can be a node or a node ID.
+            executables (list[callable]):
+                Callables to execute per node.
+            workers (int, optional):
+                Number of parallel workers.
+            strategy (str, optional):
+                Either "DFS" for Depth First Search, or "BFS" for Breadth First Search.
+                "BFS" is the default.
+            timeout (float, optional):
+                Wait time for the queue to have items:
+            kwargs (dict):
+                Additional arguments for executables.
+
+        Returns:
+            dict:
+                Stats with processed and traversed counters.
+
+        """
+
+        results = {"processed": 0, "traversed": 0}
+        lock = threading.Lock()
+        if strategy == "BFS":
+            task_queue = Queue()
+        elif strategy == "DFS":
+            task_queue = LifoQueue()
+
+        # Enqueue initial nodes at depth 0:
+        node_id = self.get_result_value(response=node, key="id") if isinstance(node, dict) else node
+        subnodes = self.get_subnodes_iterator(parent_node_id=node_id, page_size=100)
+        for subnode in subnodes:
+            # Each queue element needs its own copy of traversal data:
+            traversal_data = {
+                "folder_path": [],
+                "workspace_id": None,
+                "workspace_type": None,
+                "workspace_name": None,
+                "workspace_description": None,
+                "current_depth": 0,
+            }
+            task_queue.put((subnode, 0, traversal_data))
+
+        def traverse_node_worker() -> None:
+            """Work on queue.
+
+            Returns:
+                None
+
+            """
+
+            thread_name = threading.current_thread().name
+
+            while True:
+                # Initialze the traverse flag. If True, container
+                # subnodes will be processed. If executables exist
+                # than at least one executable has to return that
+                # further traversal is required:
+                traverse = not (executables)
+
+                try:
+                    node, current_depth, traversal_data = task_queue.get(timeout=timeout)
+                except Empty:
+                    self.logger.info("[%s] No (more) nodes to process - finishing...", thread_name)
+                    return  # Queue is empty - worker is done
+
+                try:
+                    # Fetch node dictionary if just an ID was passed as parameter:
+                    if isinstance(node, int):
+                        node = self.get_node(node_id=node)
+
+                    node_id = self.get_result_value(response=node, key="id")
+                    node_name = self.get_result_value(response=node, key="name")
+                    node_type = self.get_result_value(response=node, key="type")
+
+                    self.logger.info(
+                        "[%s] Traversing node -> '%s' (%s) at depth %d", thread_name, node_name, node_id, current_depth
+                    )
+
+                    # Run all executables
+                    for executable in executables:
+                        try:
+                            result_success, result_traverse = executable(
+                                node=node,
+                                current_depth=current_depth,
+                                traversal_data=traversal_data,
+                                **kwargs,
+                            )
+                            if result_traverse:
+                                traverse = True
+                            if not result_success:
+                                break
+                        except Exception as e:
+                            self.logger.error("Failed to run executable on node -> '%s' (%s), error -> %s", node_name, node_id, str(e))
+                    else:
+                        with lock:
+                            results["processed"] += 1
+
+                    # We only traverse the subtnodes if the current node is a container type
+                    # and at least one executables (if they any) indicate to require further traversal:
+                    if traverse and node_type in self.CONTAINER_ITEM_TYPES:
+                        subnodes = self.get_subnodes_iterator(parent_node_id=node_id, page_size=100)
+                        for subnode in subnodes:
+                            sub_traversal_data = {
+                                **traversal_data,
+                                "folder_path": traversal_data["folder_path"] + [node_name],
+                                "current_depth": current_depth + 1,
+                            }
+                            task_queue.put((subnode, current_depth + 1, sub_traversal_data))
+
+                        with lock:
+                            results["traversed"] += 1
+
+                finally:
+                    # Guarantee task_done() is called even if exceptions occur:
+                    task_queue.task_done()
+
+        # end method traverse_node_worker()
+
+        # Start thread pool with limited concurrency
+        with ThreadPoolExecutor(max_workers=workers, thread_name_prefix="Traversal_Worker") as executor:
+            for i in range(workers):
+                self.logger.info("Starting worker -> %d...", i)
+                executor.submit(traverse_node_worker)
+
+            # Wait for all tasks to complete
+            task_queue.join()
+
+        return results
+
+    # end method definition
+
+    def translate_node(self, node: dict | int, **kwargs: dict) -> bool:
+        """Translate a node.
 
         The actual translation is done by a tranlator object. This recursive method just
         traverses the hierarchy and calls the translate() method of the translator object.
 
         Args:
-            current_node_id (int):
-                The current node ID to translate.
-            translator (object):
-                This object needs to be created based on the "Translator" class
-                and passed to this method.
-            languages (list):
-                A list of target languages to translate into.
-            simulate (bool, optional):
-                If True, do not really rename but just traverse and log info.
-                The default is False.
+            node (dict | int):
+                The current node to translate. This can be the node data structure or just
+                the node ID. If it is just the ID the actual node will be fetched.
+            kwargs (dict):
+                Keyword parameters. The methods expects the follwoing keyword parameters:
+                * simulate (bool):
+                    If True, do not really rename but just traverse and log info.
+                * translator (object):
+                    This object needs to be created based on the "Translator" class
+                    and passed to this method.
+                * languages (list):
+                    A list of target languages to translate into.
+
+        Returns:
+            bool:
+                True for success, False for error.
 
         """
 
-        # Get current node based on the ID:
-        current_node = self.get_node(current_node_id)
-        current_node_id = self.get_result_value(response=current_node, key="id")
+        translator = kwargs.get("translator")
+        languages = kwargs.get("languages", [])
+        simulate = kwargs.get("simulate", False)
+
+        if not translator:
+            self.logger.error("Missing 'translator' parameter (object)!")
+            return False
+        if not languages:
+            self.logger.error("Missing or empty 'languages' parameter (list)!")
+            return False
+
+        if isinstance(node, dict):
+            current_node_id = self.get_result_value(response=node, key="id")
+        else:
+            current_node_id = node
+            node = self.get_node(node_id=current_node_id)
 
-        name = self.get_result_value(response=current_node, key="name")
-        description = self.get_result_value(response=current_node, key="description")
+        name = self.get_result_value(response=node, key="name")
+        description = self.get_result_value(response=node, key="description")
         names_multilingual = self.get_result_value(
-            response=current_node,
+            response=node,
             key="name_multilingual",
         )
         descriptions_multilingual = self.get_result_value(
-            response=current_node,
+            response=node,
             key="description_multilingual",
         )
 
@@ -14717,7 +15966,7 @@ class OTCS:
                     language,
                     names_multilingual["en"],
                 )
-                self.logger.debug(
+                self.logger.info(
                     "Translate name of node -> %s from -> '%s' (%s) to -> '%s' (%s)",
                     current_node_id,
                     name,
@@ -14735,7 +15984,7 @@ class OTCS:
                     language,
                     descriptions_multilingual["en"],
                 )
-                self.logger.debug(
+                self.logger.info(
                     "Translate description of node -> %s from -> '%s' (%s) to -> '%s' (%s)",
                     current_node_id,
                     descriptions_multilingual["en"],
@@ -14746,24 +15995,17 @@ class OTCS:
 
         # Rename node multi-lingual:
         if not simulate:
-            self.rename_node(
+            response = self.rename_node(
                 node_id=current_node_id,
                 name=name,
                 description=description,
                 name_multilingual=names_multilingual,
                 description_multilingual=descriptions_multilingual,
             )
+            if not response:
+                return False
 
-        # Get children nodes of the current node:
-        results = self.get_subnodes(parent_node_id=current_node_id, limit=200)["results"]
-
-        # Recursive call of all subnodes:
-        for result in results:
-            self.volume_translator(
-                current_node_id=result["data"]["properties"]["id"],
-                translator=translator,
-                languages=languages,
-            )
+        return True
 
     # end method definition
 
@@ -15601,10 +16843,12 @@ class OTCS:
                         subnode["id"],
                         subnode["type"],
                     )
+            # end match subnode["type"]:
 
             # Wait for all download threads to complete:
             for thread in download_threads:
                 thread.join()
+        # end for subnode in subnodes:
 
         # Wait for all traversal threads to complete:
         for thread in traversal_threads:
@@ -15614,6 +16858,481 @@ class OTCS:
 
     # end method definition
 
+    def load_items_new(
+        self,
+        node_id: int,
+        filter_workspace_depth: int | None = None,
+        filter_workspace_subtypes: list | None = None,
+        filter_workspace_category: str | None = None,
+        filter_workspace_attributes: dict | list | None = None,
+        filter_item_depth: int | None = None,
+        filter_item_subtypes: list | None = None,
+        filter_item_category: str | None = None,
+        filter_item_attributes: dict | list | None = None,
+        filter_item_in_workspace: bool = True,
+        exclude_node_ids: list | None = None,
+        workspace_metadata: bool = True,
+        item_metadata: bool = True,
+        download_documents: bool = True,
+        skip_existing_downloads: bool = True,
+        extract_zip: bool = False,
+        workers: int = 3,
+    ) -> dict | None:
+        """Create a Pandas Data Frame by traversing a given Content Server hierarchy.
+
+        This method collects workspace and document items.
+
+        Args:
+            node_id (int):
+                The root Node ID the traversal should start at.
+            filter_workspace_depth (int | None, optional):
+                Additive filter criterium for workspace path depth.
+                Defaults to None = filter not active.
+            filter_workspace_subtypes (list | None, optional):
+                Additive filter criterium for workspace type.
+                Defaults to None = filter not active.
+            filter_workspace_category (str | None, optional):
+                Additive filter criterium for workspace category.
+                Defaults to None = filter not active.
+            filter_workspace_attributes (dict | list, optional):
+                Additive filter criterium for workspace attribute values.
+                Defaults to None = filter not active
+            filter_item_depth (int | None, optional):
+                Additive filter criterium for item path depth.
+                Defaults to None = filter not active.
+            filter_item_subtypes (list | None, optional):
+                Additive filter criterium for item types.
+                Defaults to None = filter not active.
+            filter_item_category (str | None, optional):
+                Additive filter criterium for item category.
+                Defaults to None = filter not active.
+            filter_item_attributes (dict | list, optional):
+                Additive filter criterium for item attribute values.
+                Defaults to None = filter not active.
+            filter_item_in_workspace (bool, optional):
+                Defines if item filters should be applied to
+                items inside workspaces as well. If False,
+                then items inside workspaces are always included.
+            exclude_node_ids (list, optional):
+                List of node IDs to exclude from traversal.
+            workspace_metadata (bool, optional):
+                If True, include workspace metadata.
+            item_metadata (bool, optional):
+                if True, include item metadata.
+            download_documents (bool, optional):
+                Whether or not documents should be downloaded.
+            skip_existing_downloads (bool, optional):
+                If True, reuse already existing downloads in the file system.
+            extract_zip (bool, optional):
+                If True, documents that are downloaded with mime-type
+                "application/x-zip-compressed" will be extracted recursively.
+            workers (int, optional):
+                Number of worker threads to start.
+
+        Returns:
+            dict:
+                Stats with processed and traversed counters.
+
+        """
+
+        # Initiaze download threads for this subnode:
+        download_threads = []
+
+        def check_node_exclusions(node: dict, **kwargs: dict) -> tuple[bool, bool]:
+            """Check if the processed node is on the exclusion list.
+
+            Stop processing and traversing if the node is excluded.
+
+            Args:
+                node (dict):
+                    The current node being processed.
+                kwargs (dict):
+                    Additional keyword arguments that are specific for the method.
+
+            Returns:
+                tuple[bool, bool]:
+                    success (bool) - if node was processed successfully
+                    traverse (bool) - if subnodes should be processed
+
+            """
+
+            exclude_node_ids = kwargs.get("exclude_node_ids")
+            if exclude_node_ids is None:
+                self.logger.error("Missing keyword arguments for executable in node traversal!")
+                return (False, False)
+
+            node_id = self.get_result_value(response=node, key="id")
+            node_name = self.get_result_value(response=node, key="name")
+
+            if node_id and exclude_node_ids is not None and (node_id in exclude_node_ids):
+                self.logger.info(
+                    "Node -> '%s' (%s) is in exclusion list. Skip traversal of this node.",
+                    node_name,
+                    node_id,
+                )
+                return (False, False)
+            return (True, True)
+
+        # end check_node_exclusions()
+
+        def check_node_workspace(node: dict, **kwargs: dict) -> tuple[bool, bool]:
+            """Check if the processed node should be recorded as a workspace in the data frame.
+
+            Args:
+                node (dict):
+                    The current node being processed.
+                kwargs (dict):
+                    Additional keyword arguments that are specific for the method.
+
+            Returns:
+                tuple[bool, bool]:
+                    success (bool) - if node was processed successfully
+                    traverse (bool) - if subnodes should be processed
+
+            """
+
+            traversal_data = kwargs.get("traversal_data")
+            filter_workspace_data = kwargs.get("filter_workspace_data")
+            control_flags = kwargs.get("control_flags")
+
+            if not traversal_data or not filter_workspace_data or not control_flags:
+                self.logger.error("Missing keyword arguments for executable in node traversal!")
+                return False
+
+            node_id = self.get_result_value(response=node, key="id")
+            node_name = self.get_result_value(response=node, key="name")
+            node_description = self.get_result_value(response=node, key="description")
+            node_type = self.get_result_value(response=node, key="type")
+
+            #
+            # 1. Check if the traversal is already inside a workflow. Then we can skip
+            #    the workspace processing. We currently don't support sub-workspaces.
+            #
+            workspace_id = traversal_data["workspace_id"]
+            if workspace_id:
+                self.logger.debug(
+                    "Found folder or workspace -> '%s' (%s) inside workspace with ID -> %s. So this container cannot be a workspace.",
+                    node_name,
+                    node_id,
+                    workspace_id,
+                )
+                # Success = False, Traverse = True
+                return (False, True)
+
+            #
+            # 2. Check if metadata is required (either for columns or for filters)
+            #
+            if (
+                control_flags["workspace_metadata"]
+                or filter_workspace_data["filter_workspace_category"]
+                or filter_workspace_data["filter_workspace_attributes"]
+            ):
+                categories = self.get_node_categories(
+                    node_id=node_id,
+                    metadata=(
+                        filter_workspace_data["filter_workspace_category"] is not None
+                        or filter_workspace_data["filter_workspace_attributes"] is not None
+                        or not self._use_numeric_category_identifier
+                    ),
+                )
+            else:
+                categories = None
+
+            #
+            # 3. Apply the defined filters to the current node to see
+            #    if we want to 'interpret' it as a workspace
+            #
+            # See if it is a node that we want to interpret as a workspace.
+            # Only "workspaces" that comply with ALL provided filters are
+            # considered and written into the data frame as a workspace row:
+            # Root nodes may have a "results" dict. The subnode iterators don't have it:
+            node_properties = node["results"]["data"]["properties"] if "results" in node else node["data"]["properties"]
+            if not self.apply_filter(
+                node=node_properties,
+                node_categories=categories,
+                current_depth=traversal_data["current_depth"],
+                filter_depth=filter_workspace_data["filter_workspace_depth"],
+                filter_subtypes=filter_workspace_data["filter_workspace_subtypes"],
+                filter_category=filter_workspace_data["filter_workspace_category"],
+                filter_attributes=filter_workspace_data["filter_workspace_attributes"],
+            ):
+                # Success = False, Traverse = True
+                return (False, True)
+
+            self.logger.debug(
+                "Found workspace -> '%s' (%s) in depth -> %s.",
+                node_name,
+                node_id,
+                traversal_data["current_depth"],
+            )
+
+            #
+            # 4. Create the data frame row from the node / traversal data:
+            #
+            row = {}
+            row["workspace_type"] = node_type
+            row["workspace_id"] = node_id
+            row["workspace_name"] = node_name
+            row["workspace_description"] = node_description
+            row["workspace_outer_path"] = traversal_data["folder_path"]
+            # If we want (and have) metadata then add it as columns:
+            if control_flags["workspace_metadata"] and categories and categories.get("results", None):
+                # Add columns for workspace node categories have been determined above.
+                self.add_attribute_columns(row=row, categories=categories, prefix="workspace_cat_")
+
+            # Now we add the article to the Pandas Data Frame in the Data class:
+            with self._data.lock():
+                self._data.append(row)
+
+            #
+            # 5. Update the traversal data:
+            #
+            traversal_data["workspace_id"] = node_id
+            traversal_data["workspace_name"] = node_name
+            traversal_data["workspace_type"] = node_type
+            traversal_data["workspace_description"] = node_description
+            self.logger.debug("Updated traversal data -> %s", str(traversal_data))
+
+            # Success = True, Traverse = False
+            # We have traverse = True because we need to
+            # keep traversing into the workspace folders.
+            return (True, True)
+
+        # end check_node_workspace()
+
+        def check_node_item(node: dict, **kwargs: dict) -> tuple[bool, bool]:
+            """Check if the processed node should be recorded as an item in the data frame.
+
+            Args:
+                node (dict):
+                    The current node being processed.
+                kwargs (dict):
+                    Additional keyword arguments that are specific for the method.
+
+            Returns:
+                tuple[bool, bool]:
+                    success (bool) - if node was processed successfully
+                    traverse (bool) - if subnodes should be processed
+
+            """
+
+            traversal_data = kwargs.get("traversal_data")
+            filter_item_data = kwargs.get("filter_item_data")
+            control_flags = kwargs.get("control_flags")
+
+            if not traversal_data or not filter_item_data or not control_flags:
+                self.logger.error("Missing keyword arguments for executable in node item traversal!")
+                return (False, False)
+
+            node_id = self.get_result_value(response=node, key="id")
+            node_name = self.get_result_value(response=node, key="name")
+            node_description = self.get_result_value(response=node, key="description")
+            node_type = self.get_result_value(response=node, key="type")
+
+            current_depth = traversal_data["current_depth"]
+            folder_path = traversal_data["folder_path"]
+            workspace_id = traversal_data["workspace_id"]
+            workspace_name = traversal_data["workspace_name"]
+            workspace_description = traversal_data["workspace_description"]
+            workspace_type = traversal_data["workspace_type"]
+
+            #
+            # 1. Check if metadata is required (either for columns or for filters)
+            #
+            if (
+                control_flags["item_metadata"]
+                or filter_item_data["filter_item_category"]
+                or filter_item_data["filter_item_attributes"]
+            ):
+                categories = self.get_node_categories(
+                    node_id=node_id,
+                    metadata=(
+                        filter_item_data["filter_item_category"] is not None
+                        or filter_item_data["filter_item_attributes"] is not None
+                        or not self._use_numeric_category_identifier
+                    ),
+                )
+            else:
+                categories = None
+
+            #
+            # 2. Apply the defined filters to the current node to see
+            #    if we want to add it to the data frame as an item.
+            #
+            # If filter_item_in_workspace is false, then documents
+            # inside workspaces are included in the data frame unconditionally!
+            # We apply the defined filters to the current node. Only "documents"
+            # that comply with ALL provided filters are considered and written into the data frame
+            node_properties = node["results"]["data"]["properties"] if "results" in node else node["data"]["properties"]
+            if (not workspace_id or filter_item_in_workspace) and not self.apply_filter(
+                node=node_properties,
+                node_categories=categories,
+                current_depth=current_depth,
+                filter_depth=filter_item_data["filter_item_depth"],
+                filter_subtypes=filter_item_data["filter_item_subtypes"],
+                filter_category=filter_item_data["filter_item_category"],
+                filter_attributes=filter_item_data["filter_item_attributes"],
+            ):
+                # Success = False, Traverse = True
+                return (False, True)
+
+            # We only consider documents that are inside the defined "workspaces":
+            if workspace_id:
+                self.logger.debug(
+                    "Found %s item -> '%s' (%s) in depth -> %s inside workspace -> '%s' (%s).",
+                    "document" if node_type == self.ITEM_TYPE_DOCUMENT else "URL",
+                    node_name,
+                    node_id,
+                    current_depth,
+                    workspace_name,
+                    workspace_id,
+                )
+            else:
+                self.logger.debug(
+                    "Found %s item -> '%s' (%s) in depth -> %s outside of workspace.",
+                    "document" if node_type == self.ITEM_TYPE_DOCUMENT else "URL",
+                    node_name,
+                    node_id,
+                    current_depth,
+                )
+
+            # Special handling for documents: download them if requested:
+            if node_type == self.ITEM_TYPE_DOCUMENT:
+                # We use the node ID as the filename to avoid any
+                # issues with too long or not valid file names.
+                # As the Pandas DataFrame has all information
+                # this is easy to resolve at upload time.
+                file_path = "{}/{}".format(self._download_dir, node_id)
+
+                # We download only if not downloaded before or if downloaded
+                # before but forced to re-download:
+                if control_flags["download_documents"] and (
+                    not os.path.exists(file_path) or not control_flags["skip_existing_downloads"]
+                ):
+                    #
+                    # Start anasynchronous Download Thread:
+                    #
+                    self.logger.debug(
+                        "Downloading file -> '%s'...",
+                        file_path,
+                    )
+
+                    extract_after_download = node["mime_type"] == "application/x-zip-compressed" and extract_zip
+                    thread = threading.Thread(
+                        target=self.download_document_multi_threading,
+                        args=(node_id, file_path, extract_after_download),
+                        name="download_document_node_{}".format(node_id),
+                    )
+                    thread.start()
+                    download_threads.append(thread)
+                else:
+                    self.logger.debug(
+                        "File -> %s has been downloaded before or download is not requested. Skipping download...",
+                        file_path,
+                    )
+            # end if document
+
+            #
+            # Construct a dictionary 'row' that we will add
+            # to the resulting data frame:
+            #
+            row = {}
+            # First we include some key workspace data to associate
+            # the item with the workspace:
+            row["workspace_type"] = workspace_type
+            row["workspace_id"] = workspace_id
+            row["workspace_name"] = workspace_name
+            row["workspace_description"] = workspace_description
+            # Then add item specific data:
+            row["item_id"] = str(node_id)
+            row["item_type"] = node_type
+            row["item_name"] = node_name
+            row["item_description"] = node_description
+            # We take the sub-path of the folder path inside the workspace
+            # as the item path:
+            try:
+                # Item path are the list elements after the item that is the workspace name:
+                row["item_path"] = folder_path[folder_path.index(workspace_name) + 1 :]
+            except ValueError:
+                self.logger.warning("Cannot access folder path while processing -> '%s' (%s)!", node_name, node_id)
+                row["item_path"] = []
+            row["item_download_name"] = str(node_id) if node_type == self.ITEM_TYPE_DOCUMENT else ""
+            row["item_mime_type"] = (
+                self.get_result_value(response=node, key="mime_type") if node_type == self.ITEM_TYPE_DOCUMENT else ""
+            )
+            # URL specific data:
+            row["item_url"] = (
+                self.get_result_value(response=node, key="mime_type") if node_type == self.ITEM_TYPE_URL else ""
+            )
+            if item_metadata and categories and categories["results"]:
+                # Add columns for workspace node categories have been determined above.
+                self.add_attribute_columns(row=row, categories=categories, prefix="item_cat_")
+
+            # Now we add the row to the Pandas Data Frame in the Data class:
+            self.logger.info(
+                "Adding %s -> '%s' (%s) to data frame...",
+                "document" if node_type == self.ITEM_TYPE_DOCUMENT else "URL",
+                row["item_name"],
+                row["item_id"],
+            )
+            with self._data.lock():
+                self._data.append(row)
+
+            return True
+
+        # end check_node_item()
+
+        #
+        # Start Main method:
+        #
+
+        # Create folder if it does not exist
+        if download_documents and not os.path.exists(self._download_dir):
+            os.makedirs(self._download_dir)
+
+        # These won't change during processing - stays the same for all nodes:
+        filter_workspace_data = {
+            "filter_workspace_depth": filter_workspace_depth,
+            "filter_workspace_subtypes": filter_workspace_subtypes,
+            "filter_workspace_category": filter_workspace_category,
+            "filter_workspace_attributes": filter_workspace_attributes,
+        }
+
+        # These won't change during processing - stays the same for all nodes:
+        filter_item_data = {
+            "filter_item_depth": filter_item_depth,
+            "filter_item_subtypes": filter_item_subtypes,
+            "filter_item_category": filter_item_category,
+            "filter_item_attributes": filter_item_attributes,
+            "filter_item_in_workspace": filter_item_in_workspace,
+        }
+
+        # These won't change during processing - stays the same for all nodes:
+        control_flags = {
+            "workspace_metadata": workspace_metadata,
+            "item_metadata": item_metadata,
+            "download_documents": download_documents,
+            "skip_existing_downloads": skip_existing_downloads,
+            "extract_zip": extract_zip,
+        }
+
+        #
+        # Start the traversal of the nodes:
+        #
+        result = self.traverse_node_parallel(
+            node=node_id,
+            executables=[check_node_exclusions, check_node_workspace, check_node_item],
+            exclude_node_ids=exclude_node_ids,
+            filter_workspace_data=filter_workspace_data,
+            filter_item_data=filter_item_data,
+            control_flags=control_flags,
+            workers=workers,
+        )
+
+        return result
+
+    # end method definition
+
     def aviator_embed_metadata(
         self,
         node_id: int,
@@ -15641,7 +17360,7 @@ class OTCS:
                 Defines if the method waits for the completion of the embedding. Defaults to True.
             message_override (dict | None, optional):
                 Overwrite specific message details. Defaults to None.
-            timeout (float):
+            timeout (float, optional):
                 Time in seconds to wait until the WebSocket times out. Defaults to 10.0.
             document_metadata (bool, optional):
                 Defines whether or not to embed document metadata.