pyxecm 1.4__py3-none-any.whl → 1.6__py3-none-any.whl

pyxecm/otds.py

@@ -27,30 +27,22 @@ groups_url : returns OTDS Groups REST URL
 system_config_url : returns OTDS System Config REST URL
 consolidation_url: returns OTDS consolidation URL
 
-authenticate : authenticates at OTDS server
+do_request: call an OTDS REST API in a safe way.
+parse_request_response: Converts the request response to a Python dict in a safe way
 
-add_license_to_resource : Add (or update) a product license to OTDS
-get_license_for_resource : Get list of licenses for a resource
-delete_license_from_resource : Delete a license from a resource
-assign_user_to_license : Assign an OTDS user to a product license (feature) in OTDS.
-assign_partition_to_license: Assign an OTDS user partition to a license (feature) in OTDS.
-get_licensed_objects: Return the licensed objects (users, groups, partitions) an OTDS for a
-                      license + license feature associated with an OTDS resource (like "cs").
-is_user_licensed: Check if a user is licensed for a license and license feature associated
-                  with a particular OTDS resource.
-is_group_licensed: Check if a group is licensed for a license and license feature associated
-                   with a particular OTDS resource.
-is_partition_licensed: Check if a user partition is licensed for a license and license feature
-                       associated with a particular OTDS resource.
+authenticate : authenticates at OTDS server
 
+add_synchronized_partition: Add a Synchronized partition to OTDS 
 add_partition : Add an OTDS partition
 get_partition : Get a partition with a specific name
+
 add_user : Add a user to a partion
 get_user : Get a user with a specific user ID (= login name @ partition)
 get_users: get all users (with option to filter)
 update_user : Update attributes of on OTDS user
 delete_user : Delete a user with a specific ID in a specific partition
 reset_user_password : Reset a password of a specific user ID
+
 add_group: Add an OTDS group
 get_group: Get a OTDS group by its name
 add_user_to_group : Add an OTDS user to a OTDS group
@@ -68,6 +60,20 @@ add_user_to_access_role : Add an OTDS user to to an OTDS Access Role
 add_group_to_access_role : Add an OTDS group to to an OTDS Access Role
 update_access_role_attributes: Update attributes of an existing access role
 
+add_license_to_resource : Add (or update) a product license to OTDS
+get_license_for_resource : Get list of licenses for a resource
+delete_license_from_resource : Delete a license from a resource
+assign_user_to_license : Assign an OTDS user to a product license (feature) in OTDS.
+assign_partition_to_license: Assign an OTDS user partition to a license (feature) in OTDS.
+get_licensed_objects: Return the licensed objects (users, groups, partitions) an OTDS for a
+                      license + license feature associated with an OTDS resource (like "cs").
+is_user_licensed: Check if a user is licensed for a license and license feature associated
+                  with a particular OTDS resource.
+is_group_licensed: Check if a group is licensed for a license and license feature associated
+                   with a particular OTDS resource.
+is_partition_licensed: Check if a user partition is licensed for a license and license feature
+                       associated with a particular OTDS resource.
+
 add_system_attribute : Add an OTDS System Attribute
 
 get_trusted_sites : Get OTDS Trusted Sites
@@ -106,6 +112,9 @@ import logging
 import json
 import urllib.parse
 import base64
+import time
+
+from http import HTTPStatus
 import requests
 
 logger = logging.getLogger("pyxecm.otds")
@@ -121,6 +130,8 @@ REQUEST_FORM_HEADERS = {
 }
 
 REQUEST_TIMEOUT = 60
+REQUEST_RETRY_DELAY = 20
+REQUEST_MAX_RETRIES = 2
 
 
 class OTDS:
@@ -138,6 +149,7 @@ class OTDS:
         username: str | None = None,
         password: str | None = None,
         otds_ticket: str | None = None,
+        bindPassword:str | None = None,
     ):
         """Initialize the OTDS object
 
@@ -177,6 +189,11 @@ class OTDS:
             otds_config["password"] = password
         else:
             otds_config["password"] = ""
+        
+        if bindPassword:
+            otds_config["bindPassword"] = bindPassword
+        else:
+            otds_config["bindPassword"] = ""
 
         if otds_ticket:
             self._cookie = {"OTDSTicket": otds_ticket}
@@ -191,6 +208,7 @@ class OTDS:
         otds_config["restUrl"] = otdsRestUrl
 
         otds_config["partitionUrl"] = otdsRestUrl + "/partitions"
+        otds_config["identityproviderprofiles"] = otdsRestUrl + "/identityproviderprofiles"
         otds_config["accessRoleUrl"] = otdsRestUrl + "/accessroles"
         otds_config["credentialUrl"] = otdsRestUrl + "/authentication/credentials"
         otds_config["oauthClientUrl"] = otdsRestUrl + "/oauthclients"
@@ -213,6 +231,8 @@ class OTDS:
         """
         return self._config
 
+    # end method definition
+
     def cookie(self) -> dict:
         """Returns the login cookie of OTDS.
            This is set by the authenticate() method
@@ -222,6 +242,8 @@ class OTDS:
         """
         return self._cookie
 
+    # end method definition
+
     def credentials(self) -> dict:
         """Returns the credentials (username + password)
 
@@ -233,6 +255,8 @@ class OTDS:
             "password": self.config()["password"],
         }
 
+    # end method definition
+
     def base_url(self) -> str:
         """Returns the base URL of OTDS
 
@@ -241,6 +265,8 @@ class OTDS:
         """
         return self.config()["baseUrl"]
 
+    # end method definition
+
     def rest_url(self) -> str:
         """Returns the REST URL of OTDS
 
@@ -249,6 +275,8 @@ class OTDS:
         """
         return self.config()["restUrl"]
 
+    # end method definition
+
     def credential_url(self) -> str:
         """Returns the Credentials URL of OTDS
 
@@ -257,6 +285,8 @@ class OTDS:
         """
         return self.config()["credentialUrl"]
 
+    # end method definition
+
     def auth_handler_url(self) -> str:
         """Returns the Auth Handler URL of OTDS
 
@@ -265,6 +295,16 @@ class OTDS:
         """
         return self.config()["authHandlerUrl"]
 
+    # end method definition
+    def synchronized_partition_url(self) -> str:
+        """Returns the Partition URL of OTDS
+
+        Returns:
+            str: synchronized partition url
+        """
+        return self.config()["identityproviderprofiles"]
+    # end of method definition   
+
     def partition_url(self) -> str:
         """Returns the Partition URL of OTDS
 
@@ -273,6 +313,8 @@ class OTDS:
         """
         return self.config()["partitionUrl"]
 
+    # end method definition
+
     def access_role_url(self) -> str:
         """Returns the Access Role URL of OTDS
 
@@ -281,6 +323,8 @@ class OTDS:
         """
         return self.config()["accessRoleUrl"]
 
+    # end method definition
+
     def oauth_client_url(self) -> str:
         """Returns the OAuth Client URL of OTDS
 
@@ -289,6 +333,8 @@ class OTDS:
         """
         return self.config()["oauthClientUrl"]
 
+    # end method definition
+
     def resource_url(self) -> str:
         """Returns the Resource URL of OTDS
 
@@ -297,6 +343,8 @@ class OTDS:
         """
         return self.config()["resourceUrl"]
 
+    # end method definition
+
     def license_url(self) -> str:
         """Returns the License URL of OTDS
 
@@ -305,6 +353,8 @@ class OTDS:
         """
         return self.config()["licenseUrl"]
 
+    # end method definition
+
     def token_url(self) -> str:
         """Returns the Token URL of OTDS
 
@@ -313,6 +363,8 @@ class OTDS:
         """
         return self.config()["tokenUrl"]
 
+    # end method definition
+
     def users_url(self) -> str:
         """Returns the Users URL of OTDS
 
@@ -321,6 +373,8 @@ class OTDS:
         """
         return self.config()["usersUrl"]
 
+    # end method definition
+
     def groups_url(self) -> str:
         """Returns the Groups URL of OTDS
 
@@ -329,6 +383,8 @@ class OTDS:
         """
         return self.config()["groupsUrl"]
 
+    # end method definition
+
     def system_config_url(self) -> str:
         """Returns the System Config URL of OTDS
 
@@ -337,6 +393,8 @@ class OTDS:
         """
         return self.config()["systemConfigUrl"]
 
+    # end method definition
+
     def consolidation_url(self) -> str:
         """Returns the Consolidation URL of OTDS
 
@@ -345,6 +403,166 @@ class OTDS:
         """
         return self.config()["consolidationUrl"]
 
+    # end method definition
+
+    def do_request(
+        self,
+        url: str,
+        method: str = "GET",
+        headers: dict | None = None,
+        data: dict | None = None,
+        json_data: dict | None = None,
+        files: dict | None = None,
+        timeout: int | None = REQUEST_TIMEOUT,
+        show_error: bool = True,
+        show_warning: bool = False,
+        warning_message: str = "",
+        failure_message: str = "",
+        success_message: str = "",
+        max_retries: int = REQUEST_MAX_RETRIES,
+        retry_forever: bool = False,
+        parse_request_response: bool = True,
+    ) -> dict | None:
+        """Call an OTDS REST API in a safe way
+
+        Args:
+            url (str): URL to send the request to.
+            method (str, optional): HTTP method (GET, POST, etc.). Defaults to "GET".
+            headers (dict | None, optional): Request Headers. Defaults to None.
+            data (dict | None, optional): Request payload. Defaults to None
+            files (dict | None, optional): Dictionary of {"name": file-tuple} for multipart encoding upload.
+                                           file-tuple can be a 2-tuple ("filename", fileobj) or a 3-tuple ("filename", fileobj, "content_type")
+            timeout (int | None, optional): Timeout for the request in seconds. Defaults to REQUEST_TIMEOUT.
+            show_error (bool, optional): Whether or not an error should be logged in case of a failed REST call.
+                                         If False, then only a warning is logged. Defaults to True.
+            warning_message (str, optional): Specific warning message. Defaults to "". If not given the error_message will be used.
+            failure_message (str, optional): Specific error message. Defaults to "".
+            success_message (str, optional): Specific success message. Defaults to "".
+            max_retries (int, optional): How many retries on Connection errors? Default is REQUEST_MAX_RETRIES.
+            retry_forever (bool, optional): Eventually wait forever - without timeout. Defaults to False.
+            parse_request_response (bool, optional): should the response.text be interpreted as json and loaded into a dictionary. True is the default.
+
+        Returns:
+            dict | None: Response of OTDS REST API or None in case of an error.
+        """
+
+        if headers is None:
+            headers = REQUEST_HEADERS
+
+        # In case of an expired session we reauthenticate and
+        # try 1 more time. Session expiration should not happen
+        # twice in a row:
+        retries = 0
+
+        while True:
+            try:
+                response = requests.request(
+                    method=method,
+                    url=url,
+                    data=data,
+                    json=json_data,
+                    files=files,
+                    headers=headers,
+                    cookies=self.cookie(),
+                    timeout=timeout,
+                )
+
+                if response.ok:
+                    if success_message:
+                        logger.info(success_message)
+                    if parse_request_response:
+                        return self.parse_request_response(response)
+                    else:
+                        return response
+                # Check if Session has expired - then re-authenticate and try once more
+                elif response.status_code == 401 and retries == 0:
+                    logger.debug("Session has expired - try to re-authenticate...")
+                    self.authenticate(revalidate=True)
+                    retries += 1
+                else:
+                    # Handle plain HTML responses to not pollute the logs
+                    content_type = response.headers.get("content-type", None)
+                    if content_type == "text/html":
+                        response_text = "HTML content (only printed in debug log)"
+                    else:
+                        response_text = response.text
+
+                    if show_error:
+                        logger.error(
+                            "%s; status -> %s/%s; error -> %s",
+                            failure_message,
+                            response.status_code,
+                            HTTPStatus(response.status_code).phrase,
+                            response_text,
+                        )
+                    elif show_warning:
+                        logger.warning(
+                            "%s; status -> %s/%s; warning -> %s",
+                            warning_message if warning_message else failure_message,
+                            response.status_code,
+                            HTTPStatus(response.status_code).phrase,
+                            response_text,
+                        )
+                    if content_type == "text/html":
+                        logger.debug(
+                            "%s; status -> %s/%s; warning -> %s",
+                            failure_message,
+                            response.status_code,
+                            HTTPStatus(response.status_code).phrase,
+                            response.text,
+                        )
+                    return None
+            except requests.exceptions.Timeout:
+                if retries <= max_retries:
+                    logger.warning(
+                        "Request timed out. Retrying in %s seconds...",
+                        str(REQUEST_RETRY_DELAY),
+                    )
+                    retries += 1
+                    time.sleep(REQUEST_RETRY_DELAY)  # Add a delay before retrying
+                else:
+                    logger.error(
+                        "%s; timeout error",
+                        failure_message,
+                    )
+                    if retry_forever:
+                        # If it fails after REQUEST_MAX_RETRIES retries we let it wait forever
+                        logger.warning("Turn timeouts off and wait forever...")
+                        timeout = None
+                    else:
+                        return None
+            except requests.exceptions.ConnectionError:
+                if retries <= max_retries:
+                    logger.warning(
+                        "Connection error. Retrying in %s seconds...",
+                        str(REQUEST_RETRY_DELAY),
+                    )
+                    retries += 1
+                    time.sleep(REQUEST_RETRY_DELAY)  # Add a delay before retrying
+                else:
+                    logger.error(
+                        "%s; connection error",
+                        failure_message,
+                    )
+                    if retry_forever:
+                        # If it fails after REQUEST_MAX_RETRIES retries we let it wait forever
+                        logger.warning("Turn timeouts off and wait forever...")
+                        timeout = None
+                        time.sleep(REQUEST_RETRY_DELAY)  # Add a delay before retrying
+                    else:
+                        return None
+            # end try
+            logger.debug(
+                "Retrying REST API %s call -> %s... (retry = %s, cookie -> %s)",
+                method,
+                url,
+                str(retries),
+                str(self.cookie()),
+            )
+        # end while True
+
+    # end method definition
+
     def parse_request_response(
         self,
         response_object: object,
@@ -365,6 +583,10 @@ class OTDS:
         if not response_object:
             return None
 
+        if not response_object.text:
+            logger.warning("Response text is empty. Cannot decode response.")
+            return None
+
         try:
             dict_object = json.loads(response_object.text)
         except json.JSONDecodeError as e:
@@ -396,7 +618,7 @@ class OTDS:
 
         # Already authenticated and session still valid?
         if self._cookie and not revalidate:
-            logger.info(
+            logger.debug(
                 "Session still valid - return existing cookie -> %s",
                 str(self._cookie),
             )
@@ -404,7 +626,7 @@ class OTDS:
 
         otds_ticket = "NotSet"
 
-        logger.info("Requesting OTDS ticket from -> %s", self.credential_url())
+        logger.debug("Requesting OTDS ticket from -> %s", self.credential_url())
 
         response = None
         try:
@@ -429,7 +651,7 @@ class OTDS:
                 return None
             else:
                 otds_ticket = authenticate_dict["ticket"]
-                logger.info("Ticket -> %s", otds_ticket)
+                logger.debug("Ticket -> %s", otds_ticket)
         else:
             logger.error("Failed to request an OTDS ticket; error -> %s", response.text)
             return None
@@ -442,1813 +664,1563 @@ class OTDS:
 
     # end method definition
 
-    def add_license_to_resource(
-        self,
-        path_to_license_file: str,
-        product_name: str,
-        product_description: str,
-        resource_id: str,
-        update: bool = True,
-    ) -> dict | None:
-        """Add a product license to an OTDS resource.
+    def add_partition(self, name: str, description: str) -> dict | None:
+        """Add a new user partition to OTDS
 
         Args:
-            path_to_license_file (str): fully qualified filename of the license file
-            product_name (str): product name
-            product_description (str): product description
-            resource_id (str): OTDS resource ID (this is ID not the resource name!)
-            update (bool, optional): whether or not an existing license should be updated (default = True)
+            name (str): name of the new partition
+            description (str): description of the new partition
         Returns:
-            dict: Request response (dictionary) or None if the REST call fails
+            dict: Request response or None if the creation fails.
         """
 
-        logger.info("Reading license file -> %s...", path_to_license_file)
-        try:
-            with open(path_to_license_file, "rt", encoding="UTF-8") as license_file:
-                license_content = license_file.read()
-        except IOError as exception:
-            logger.error(
-                "Error opening license file -> %s; error -> %s",
-                path_to_license_file,
-                exception.strerror,
-            )
-            return None
-
-        licensePostBodyJson = {
-            "description": product_description,
-            "name": product_name,
-            "values": [
-                {"name": "oTLicenseFile", "values": license_content},
-                {"name": "oTLicenseResource", "values": resource_id},
-                {"name": "oTLicenseFingerprintGenerator", "values": [None]},
-            ],
-        }
+        partition_post_body_json = {"name": name, "description": description}
 
-        request_url = self.license_url()
-        # Check if we want to update an existing license:
-        if update:
-            existing_license = self.get_license_for_resource(resource_id)
-            if existing_license:
-                request_url += "/" + existing_license[0]["id"]
-            else:
-                logger.info(
-                    "No existing license for resource -> %s found - adding a new license...",
-                    resource_id,
-                )
-                # change strategy to create a new license:
-                update = False
+        request_url = self.partition_url()
 
-        logger.info(
-            "Adding product license -> %s for product -> %s to resource -> %s; calling -> %s",
-            path_to_license_file,
-            product_description,
-            resource_id,
+        logger.debug(
+            "Adding user partition -> '%s' (%s); calling -> %s",
+            name,
+            description,
             request_url,
         )
 
-        retries = 0
-        while True:
-            if update:
-                # Do a REST PUT call for update an existing license:
-                response = requests.put(
-                    url=request_url,
-                    json=licensePostBodyJson,
-                    headers=REQUEST_HEADERS,
-                    cookies=self.cookie(),
-                    timeout=None,
-                )
-            else:
-                # Do a REST POST call for creation of a new license:
-                response = requests.post(
-                    url=request_url,
-                    json=licensePostBodyJson,
-                    headers=REQUEST_HEADERS,
-                    cookies=self.cookie(),
-                    timeout=None,
-                )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add product license -> %s for product -> %s; error -> %s (%s)",
-                    path_to_license_file,
-                    product_description,
-                    response.text,
-                    response.status_code,
-                )
-                return None
+        return self.do_request(
+            url=request_url,
+            method="POST",
+            json_data=partition_post_body_json,
+            timeout=None,
+            failure_message="Failed to add user partition -> '{}'".format(name),
+        )
 
     # end method definition
 
-    def get_license_for_resource(self, resource_id: str):
-        """Get a product license for a resource in OTDS.
+    def get_partition(self, name: str, show_error: bool = True) -> dict | None:
+        """Get an existing user partition from OTDS
 
         Args:
-            resource_id (str): OTDS resource ID (this is ID not the resource name!)
+            name (str): name of the partition to retrieve
+            show_error (bool, optional): whether or not we want to log an error
+                                         if partion is not found
         Returns:
-            Licenses for a resource or None if the REST call fails
-
-        licenses have this format:
-        {
-          '_oTLicenseType': 'NON-PRODUCTION',
-          '_oTLicenseResource': '7382094f-a434-4714-9696-82864b6803da',
-          '_oTLicenseResourceName': 'cs',
-          '_oTLicenseProduct': 'EXTENDED_ECM',
-          'name': 'EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da',
-          'location': 'cn=EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da,ou=Licenses,dc=identity,dc=opentext,dc=net',
-          'id': 'cn=EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da,ou=Licenses,dc=identity,dc=opentext,dc=net',
-          'description': 'CS license',
-          'values': [{...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, ...]
-        }
+            dict: Request response or None if the REST call fails.
         """
 
-        request_url = (
-            self.license_url()
-            + "/assignedlicenses?resourceID="
-            + resource_id
-            + "&validOnly=false"
-        )
+        request_url = "{}/{}".format(self.config()["partitionUrl"], name)
 
-        logger.info(
-            "Get license for resource -> %s; calling -> %s", resource_id, request_url
-        )
+        logger.debug("Get user partition -> '%s'; calling -> %s", name, request_url)
 
-        retries = 0
-        while True:
-            response = requests.get(
-                url=request_url,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                response_dict = self.parse_request_response(response)
-                if not response_dict:
-                    return None
-                return response_dict["licenseObjects"]["_licenses"]
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to get license for resource -> %s; error -> %s (%s)",
-                    resource_id,
-                    response.text,
-                    response.status_code,
-                )
-                return None
+        return self.do_request(
+            url=request_url,
+            method="GET",
+            timeout=None,
+            failure_message="Failed to get user partition -> '{}'".format(name),
+            show_error=show_error,
+        )
 
     # end method definition
 
-    def delete_license_from_resource(self, resource_id: str, license_id: str) -> bool:
-        """Delete a product license for a resource in OTDS.
+    def add_user(
+        self,
+        partition: str,
+        name: str,
+        description: str = "",
+        first_name: str = "",
+        last_name: str = "",
+        email: str = "",
+    ) -> dict | None:
+        """Add a new user to a user partition in OTDS
 
         Args:
-            resource_id (str): OTDS resource ID (this is ID not the resource name!)
-            license_id (str): OTDS license ID (this is the ID not the license name!)
+            partition (str): name of the OTDS user partition (needs to exist)
+            name (str): login name of the new user
+            description (str, optional): description of the new user
+            first_name (str, optional): first name of the new user
+            last_name (str, optional): last name of the new user
+            email (str, optional): email address of the new user
         Returns:
-            bool: True if successful or False if the REST call fails
+            dict: Request response or None if the creation fails.
         """
 
-        request_url = "{}/{}".format(self.license_url(), license_id)
-
-        logger.info(
-            "Deleting product license -> %s from resource -> %s; calling -> %s",
-            license_id,
-            resource_id,
+        user_post_body_json = {
+            "userPartitionID": partition,
+            "values": [
+                {"name": "sn", "values": [last_name]},
+                {"name": "givenName", "values": [first_name]},
+                {"name": "mail", "values": [email]},
+            ],
+            "name": name,
+            "description": description,
+        }
+
+        request_url = self.users_url()
+
+        logger.debug(
+            "Adding user -> '%s' to partition -> '%s'; calling -> %s",
+            name,
+            partition,
             request_url,
         )
+        logger.debug("User Attributes -> %s", str(user_post_body_json))
 
-        retries = 0
-        while True:
-            response = requests.delete(
-                url=request_url,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return True
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to delete license -> %s for resource -> %s; error -> %s (%s)",
-                    license_id,
-                    resource_id,
-                    response.text,
-                    response.status_code,
-                )
-                return False
+        return self.do_request(
+            url=request_url,
+            method="POST",
+            json_data=user_post_body_json,
+            timeout=None,
+            failure_message="Failed to add user -> '{}'".format(name),
+        )
 
     # end method definition
 
-    def assign_user_to_license(
-        self,
-        partition: str,
-        user_id: str,
-        resource_id: str,
-        license_feature: str,
-        license_name: str,
-        license_type: str = "Full",
-    ) -> bool:
-        """Assign an OTDS user to a product license (feature) in OTDS.
+    def get_user(self, partition: str, user_id: str) -> dict | None:
+        """Get a user by its partition and user ID
 
         Args:
-            partition (str): user partition in OTDS, e.g. "Content Server Members"
+            partition (str): name of the partition
             user_id (str): ID of the user (= login name)
-            resource_id (str): OTDS resource ID (this is ID not the resource name!)
-            license_feature (str): name of the license feature
-            license_name (str): name of the license to assign
-            license_type (str, optional): deault is "Full", Extended ECM also has "Occasional"
         Returns:
-            bool: True if successful or False if the REST call fails or the license is not found
+            dict: Request response or None if the user was not found.
         """
 
-        licenses = self.get_license_for_resource(resource_id)
-
-        for lic in licenses:
-            if lic["_oTLicenseProduct"] == license_name:
-                license_location = lic["id"]
-
-        try:
-            license_location
-        except UnboundLocalError:
-            logger.error(
-                "Cannot find license -> %s for resource -> %s",
-                license_name,
-                resource_id,
-            )
-            return False
-
-        user = self.get_user(partition, user_id)
-        if user:
-            user_location = user["location"]
-        else:
-            logger.error("Cannot find location for user -> %s", user_id)
-            return False
-
-        licensePostBodyJson = {
-            "_oTLicenseType": license_type,
-            "_oTLicenseProduct": "users",
-            "name": user_location,
-            "values": [{"name": "counter", "values": [license_feature]}],
-        }
-
-        request_url = self.license_url() + "/object/" + license_location
+        request_url = self.users_url() + "/" + user_id + "@" + partition
 
-        logger.info(
-            "Assign license feature -> %s of license -> %s associated with resource -> %s to user -> %s; calling -> %s",
-            license_feature,
-            license_location,
-            resource_id,
+        logger.debug(
+            "Get user -> '%s' in partition -> '%s'; calling -> %s",
             user_id,
+            partition,
             request_url,
         )
 
-        retries = 0
-        while True:
-            response = requests.post(
-                url=request_url,
-                json=licensePostBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                logger.info(
-                    "Added license feature -> %s for user -> %s",
-                    license_feature,
-                    user_id,
-                )
-                return True
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add license feature -> %s associated with resource -> %s to user -> %s; error -> %s (%s)",
-                    license_feature,
-                    resource_id,
-                    user_id,
-                    response.text,
-                    response.status_code,
-                )
-                return False
+        return self.do_request(
+            url=request_url,
+            method="GET",
+            timeout=None,
+            failure_message="Failed to get user -> '{}'".format(user_id),
+        )
 
     # end method definition
 
-    def assign_partition_to_license(
-        self,
-        partition_name: str,
-        resource_id: str,
-        license_feature: str,
-        license_name: str,
-        license_type: str = "Full",
-    ) -> bool:
-        """Assign an OTDS partition to a product license (feature).
+    def get_users(self, partition: str = "", limit: int | None = None) -> dict | None:
+        """Get all users in a partition partition
 
         Args:
-            partition_name (str): user partition in OTDS, e.g. "Content Server Members"
-            resource_id (str): OTDS resource ID (this is ID not the resource name!)
-            license_feature (str): name of the license feature, e.g. "X2" or "ADDON_ENGINEERING"
-            license_name (str): name of the license to assign, e.g. "EXTENDED_ECM" or "INTELLGENT_VIEWIMG"
-            license_type (str, optional): deault is "Full", Extended ECM also has "Occasional"
+            partition (str, optional): name of the partition
+            limit (int): maximum number of users to return
         Returns:
-            bool: True if successful or False if the REST call fails or the license is not found
+            dict: Request response or None if the user was not found.
         """
 
-        licenses = self.get_license_for_resource(resource_id)
-        if not licenses:
-            logger.error(
-                "Resource with ID -> %s does not exist or has no licenses", resource_id
-            )
-            return False
-
-        # licenses have this format:
-        # {
-        #   '_oTLicenseType': 'NON-PRODUCTION',
-        #   '_oTLicenseResource': '7382094f-a434-4714-9696-82864b6803da',
-        #   '_oTLicenseResourceName': 'cs',
-        #   '_oTLicenseProduct': 'EXTENDED_ECM',
-        #   'name': 'EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da',
-        #   'location': 'cn=EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da,ou=Licenses,dc=identity,dc=opentext,dc=net',
-        #   'id': 'cn=EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da,ou=Licenses,dc=identity,dc=opentext,dc=net',
-        #   'description': 'CS license',
-        #   'values': [{...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, ...]
-        # }
-        for lic in licenses:
-            if lic["_oTLicenseProduct"] == license_name:
-                license_location = lic["id"]
+        # Add query parameters (these are NOT passed via JSon body!)
+        query = {}
+        if limit:
+            query["limit"] = limit
+        if partition:
+            query["where_partition_name"] = partition
 
-        try:
-            license_location
-        except UnboundLocalError:
-            logger.error(
-                "Cannot find license -> %s for resource -> %s",
-                license_name,
-                resource_id,
-            )
-            return False
+        encoded_query = urllib.parse.urlencode(query, doseq=True)
 
-        licensePostBodyJson = {
-            "_oTLicenseType": license_type,
-            "_oTLicenseProduct": "partitions",
-            "name": partition_name,
-            "values": [{"name": "counter", "values": [license_feature]}],
-        }
+        request_url = self.users_url()
+        if query:
+            request_url += "?{}".format(encoded_query)
 
-        request_url = self.license_url() + "/object/" + license_location
+        if partition:
+            logger.debug(
+                "Get all users in partition -> '%s' (limit -> %s); calling -> %s",
+                partition,
+                limit,
+                request_url,
+            )
+            failure_message = "Failed to get all users in partition -> '{}'".format(
+                partition
+            )
+        else:
+            logger.debug(
+                "Get all users (limit -> %s); calling -> %s",
+                limit,
+                request_url,
+            )
+            failure_message = "Failed to get all users"
 
-        logger.info(
-            "Assign license feature -> %s of license -> %s associated with resource -> %s to partition -> %s; calling -> %s",
-            license_feature,
-            license_location,
-            resource_id,
-            partition_name,
-            request_url,
+        return self.do_request(
+            url=request_url, method="GET", timeout=None, failure_message=failure_message
         )
 
-        retries = 0
-        while True:
-            response = requests.post(
-                url=request_url,
-                json=licensePostBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                logger.info(
-                    "Added license feature -> %s for partition -> %s",
-                    license_feature,
-                    partition_name,
-                )
-                return True
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add license feature -> %s associated with resource -> %s to partition -> %s; error -> %s (%s)",
-                    license_feature,
-                    resource_id,
-                    partition_name,
-                    response.text,
-                    response.status_code,
-                )
-                return False
-
     # end method definition
 
-    def get_licensed_objects(
-        self,
-        resource_id: str,
-        license_feature: str,
-        license_name: str,
+    def update_user(
+        self, partition: str, user_id: str, attribute_name: str, attribute_value: str
     ) -> dict | None:
-        """Return the licensed objects (users, groups, partitions) in OTDS for a license + license feature
-           associated with an OTDS resource (like "cs").
+        """Update a user attribute with a new value
 
         Args:
-            resource_id (str): OTDS resource ID (this is ID not the resource name!)
-            license_feature (str): name of the license feature, e.g. "X2" or "ADDON_ENGINEERING"
-            license_name (str): name of the license to assign, e.g. "EXTENDED_ECM" or "INTELLGENT_VIEWIMG"
-        Returns:
-            dict: data structure of licensed objects
-
-            Example return value:
-            {
-                'status': 0,
-                'displayString': 'Success',
-                'exceptions': None,
-                'retValue': 0,
-                'listGroupsResults': {'groups': [...], 'actualPageSize': 0, 'nextPageCookie': None, 'requestedPageSize': 250},
-                'listUsersResults': {'users': [...], 'actualPageSize': 53, 'nextPageCookie': None, 'requestedPageSize': 250},
-                'listUserPartitionResult': {'_userPartitions': [...], 'warningMessage': None, 'actualPageSize': 0, 'nextPageCookie': None, 'requestedPageSize': 250},
-                'version': 1
-            }
+            partition (str): name of the partition
+            user_id (str): ID of the user (= login name)
+            attribute_name (str): name of the attribute
+            attribute_value (str): new value of the attribute
+        Return:
+            dict: Request response or None if the update fails.
         """
 
-        licenses = self.get_license_for_resource(resource_id)
-        if not licenses:
-            logger.error(
-                "Resource with ID -> %s does not exist or has no licenses", resource_id
-            )
-            return False
+        if attribute_name in ["description"]:
+            user_patch_body_json = {
+                "userPartitionID": partition,
+                attribute_name: attribute_value,
+            }
+        else:
+            user_patch_body_json = {
+                "userPartitionID": partition,
+                "values": [{"name": attribute_name, "values": [attribute_value]}],
+            }
 
-        # licenses have this format:
-        # {
-        #   '_oTLicenseType': 'NON-PRODUCTION',
-        #   '_oTLicenseResource': '7382094f-a434-4714-9696-82864b6803da',
-        #   '_oTLicenseResourceName': 'cs',
-        #   '_oTLicenseProduct': 'EXTENDED_ECM',
-        #   'name': 'EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da',
-        #   'location': 'cn=EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da,ou=Licenses,dc=identity,dc=opentext,dc=net',
-        #   'id': 'cn=EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da,ou=Licenses,dc=identity,dc=opentext,dc=net',
-        #   'description': 'CS license',
-        #   'values': [{...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, ...]
-        # }
-        for lic in licenses:
-            if lic["_oTLicenseProduct"] == license_name:
-                license_location = lic["location"]
+        request_url = self.users_url() + "/" + user_id
 
-        try:
-            license_location
-        except UnboundLocalError:
-            logger.error(
-                "Cannot find license -> %s for resource -> %s",
-                license_name,
-                resource_id,
-            )
-            return False
+        logger.debug(
+            "Update user -> '%s' attribute -> '%s' to value -> '%s'; calling -> %s",
+            user_id,
+            attribute_name,
+            attribute_value,
+            request_url,
+        )
 
-        request_url = (
-            self.license_url()
-            + "/object/"
-            + license_location
-            + "?counter="
-            + license_feature
+        return self.do_request(
+            url=request_url,
+            method="PATCH",
+            json_data=user_patch_body_json,
+            timeout=None,
+            failure_message="Failed to update user -> '{}'".format(user_id),
         )
 
-        logger.info(
-            "Get licensed objects for license -> %s and license feature -> %s associated with resource -> %s; calling -> %s",
-            license_name,
-            license_feature,
-            resource_id,
+    # end method definition
+
+    def delete_user(self, partition: str, user_id: str) -> bool:
+        """Delete an existing user
+
+        Args:
+            partition (str): name of the partition
+            user_id (str): Id (= login name) of the user
+        Returns:
+            bool: True = success, False = error
+        """
+
+        request_url = self.users_url() + "/" + user_id + "@" + partition
+
+        logger.debug(
+            "Delete user -> '%s' in partition -> '%s'; calling -> %s",
+            user_id,
+            partition,
             request_url,
         )
 
-        retries = 0
-        while True:
-            response = requests.get(
-                url=request_url,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to get licensed objects for license -> %s and license feature -> %s associated with resource -> %s; error -> %s (%s)",
-                    license_name,
-                    license_feature,
-                    resource_id,
-                    response.text,
-                    response.status_code,
-                )
-                return None
+        response = self.do_request(
+            url=request_url,
+            method="DELETE",
+            timeout=None,
+            failure_message="Failed to delete user -> '{}'".format(user_id),
+            parse_request_response=False,
+        )
+
+        if response and response.ok:
+            return True
+
+        return False
 
     # end method definition
 
-    def is_user_licensed(
-        self, user_name: str, resource_id: str, license_feature: str, license_name: str
-    ) -> bool:
-        """Check if a user is licensed for a license and license feature associated with a particular OTDS resource.
+    def reset_user_password(self, user_id: str, password: str) -> bool:
+        """Reset a password of an existing user
 
         Args:
-            user_name (str): login name of the OTDS user
-            resource_id (str): OTDS resource ID (this is ID not the resource name!)
-            license_feature (str): name of the license feature, e.g. "X2" or "ADDON_ENGINEERING"
-            license_name (str): name of the license to assign, e.g. "EXTENDED_ECM" or "INTELLGENT_VIEWIMG"
-
+            user_id (str): Id (= login name) of the user
+            password (str): new password of the user
         Returns:
-            bool: True if the user is licensed and False otherwise
+            bool: True = success, False = error.
         """
 
-        response = self.get_licensed_objects(
-            resource_id=resource_id,
-            license_feature=license_feature,
-            license_name=license_name,
-        )
-
-        if not response or not response["listUsersResults"]:
-            return False
+        user_post_body_json = {"newPassword": password}
 
-        users = response["listUsersResults"]["users"]
+        request_url = "{}/{}/password".format(self.users_url(), user_id)
 
-        if not users:
-            return False
+        logger.debug(
+            "Resetting password for user -> '%s'; calling -> %s", user_id, request_url
+        )
 
-        user = next(
-            (item for item in users if item["name"] == user_name),
-            None,
+        response = self.do_request(
+            url=request_url,
+            method="PUT",
+            json_data=user_post_body_json,
+            timeout=None,
+            failure_message="Failed to reset password for user -> '{}'".format(user_id),
+            parse_request_response=False,
         )
 
-        if user:
+        if response and response.ok:
             return True
 
         return False
 
     # end method definition
 
-    def is_group_licensed(
-        self, group_name: str, resource_id: str, license_feature: str, license_name: str
-    ) -> bool:
-        """Check if a group is licensed for a license and license feature associated with a particular OTDS resource.
+    def add_group(self, partition: str, name: str, description: str) -> dict | None:
+        """Add a new user group to a user partition in OTDS
 
         Args:
-            group_name (str): name of the OTDS user group
-            resource_id (str): OTDS resource ID (this is ID not the resource name!)
-            license_feature (str): name of the license feature, e.g. "X2" or "ADDON_ENGINEERING"
-            license_name (str): name of the license to assign, e.g. "EXTENDED_ECM" or "INTELLGENT_VIEWIMG"
-
+            partition (str): name of the OTDS user partition (needs to exist)
+            name (str): name of the new group
+            description (str): description of the new group
         Returns:
-            bool: True if the group is licensed and False otherwise
+            dict: Request response (json) or None if the creation fails.
         """
 
-        response = self.get_licensed_objects(
-            resource_id=resource_id,
-            license_feature=license_feature,
-            license_name=license_name,
+        group_post_body_json = {
+            "userPartitionID": partition,
+            "name": name,
+            "description": description,
+        }
+
+        request_url = self.groups_url()
+
+        logger.debug(
+            "Adding group -> '%s' to partition -> '%s'; calling -> %s",
+            name,
+            partition,
+            request_url,
         )
+        logger.debug("Group Attributes -> %s", str(group_post_body_json))
 
-        if not response or not response["listGroupsResults"]:
-            return False
+        return self.do_request(
+            url=request_url,
+            method="POST",
+            json_data=group_post_body_json,
+            timeout=None,
+            failure_message="Failed to reset password for user -> '{}'".format(name),
+        )
 
-        groups = response["listGroupsResults"]["groups"]
+    # end method definition
 
-        if not groups:
-            return False
+    def get_group(self, group: str, show_error: bool = True) -> dict | None:
+        """Get a OTDS group by its group name
 
-        group = next(
-            (item for item in groups if item["name"] == group_name),
-            None,
-        )
+        Args:
+            group (str): ID of the group (= group name)
+            show_error (bool, optional): treat as error if resource is not found
+        Return:
+            dict: Request response or None if the group was not found.
+            Example values:
+            {
+                'numMembers': 7,
+                'userPartitionID': 'Content Server Members',
+                'name': 'Sales',
+                'location': 'oTGroup=3f921294-b92a-4c9e-bf7c-b50df16bb937,orgunit=groups,partition=Content Server Members,dc=identity,dc=opentext,dc=net',
+                'id': 'Sales@Content Server Members',
+                'values': [{...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, ...],
+                'description': None,
+                'uuid': '3f921294-b92a-4c9e-bf7c-b50df16bb937',
+                'objectClass': 'oTGroup',
+                'customAttributes': None,
+                'originUUID': None,
+                'urlId': 'Sales@Content Server Members',
+                'urlLocation': 'oTGroup=3f921294-b92a-4c9e-bf7c-b50df16bb937,orgunit=groups,partition=Content Server Members,dc=identity,dc=opentext,dc=net'
+            }
+        """
 
-        if group:
-            return True
+        request_url = self.groups_url() + "/" + group
 
-        return False
+        logger.debug("Get group -> '%s'; calling -> %s", group, request_url)
+
+        return self.do_request(
+            url=request_url,
+            method="GET",
+            timeout=None,
+            failure_message="Failed to get group -> '{}'".format(group),
+            show_error=show_error,
+        )
 
     # end method definition
 
-    def is_partition_licensed(
-        self,
-        partition_name: str,
-        resource_id: str,
-        license_feature: str,
-        license_name: str,
-    ) -> bool:
-        """Check if a partition is licensed for a license and license feature associated with a particular OTDS resource.
+    def add_user_to_group(self, user: str, group: str) -> bool:
+        """Add an existing user to an existing group in OTDS
 
         Args:
-            partition_name (str): name of the OTDS user partition, e.g. "Content Server Members"
-            resource_id (str): OTDS resource ID (this is ID not the resource name!)
-            license_feature (str): name of the license feature, e.g. "X2" or "ADDON_ENGINEERING"
-            license_name (str): name of the license to assign, e.g. "EXTENDED_ECM" or "INTELLGENT_VIEWIMG"
-
+            user (str): name of the OTDS user (needs to exist)
+            group (str): name of the OTDS group (needs to exist)
         Returns:
-            bool: True if the partition is licensed and False otherwise
+            bool: True, if request is successful, False otherwise.
         """
 
-        response = self.get_licensed_objects(
-            resource_id=resource_id,
-            license_feature=license_feature,
-            license_name=license_name,
-        )
-
-        if not response or not response["listUserPartitionResult"]:
-            return False
+        user_to_group_post_body_json = {"stringList": [group]}
 
-        partitions = response["listUserPartitionResult"]["_userPartitions"]
+        request_url = self.users_url() + "/" + user + "/memberof"
 
-        if not partitions:
-            return False
+        logger.debug(
+            "Adding user -> '%s' to group -> '%s'; calling -> %s",
+            user,
+            group,
+            request_url,
+        )
 
-        partition = next(
-            (item for item in partitions if item["name"] == partition_name),
-            None,
+        # OTDS delivers an empty response.text for the API, so we don't parse it here:
+        response = self.do_request(
+            url=request_url,
+            method="POST",
+            json_data=user_to_group_post_body_json,
+            timeout=None,
+            failure_message="Failed to add user -> '{}' to group -> '{}'".format(
+                user, group
+            ),
+            parse_request_response=False,
         )
 
-        if partition:
+        if response and response.ok:
             return True
 
         return False
 
     # end method definition
 
-    def add_partition(self, name: str, description: str) -> dict | None:
-        """Add a new user partition to OTDS
+    def add_group_to_parent_group(self, group: str, parent_group: str) -> bool:
+        """Add an existing group to an existing parent group in OTDS
 
         Args:
-            name (str): name of the new partition
-            description (str): description of the new partition
+            group (str): name of the OTDS group (needs to exist)
+            parent_group (str): name of the OTDS parent group (needs to exist)
         Returns:
-            dict: Request response or None if the creation fails.
+            bool: True, if request is successful, False otherwise.
         """
 
-        partitionPostBodyJson = {"name": name, "description": description}
+        group_to_parent_group_post_body_json = {"stringList": [parent_group]}
 
-        request_url = self.partition_url()
+        request_url = self.groups_url() + "/" + group + "/memberof"
 
-        logger.info(
-            "Adding user partition -> %s (%s); calling -> %s",
-            name,
-            description,
+        logger.debug(
+            "Adding group -> '%s' to parent group -> '%s'; calling -> %s",
+            group,
+            parent_group,
             request_url,
         )
 
-        retries = 0
-        while True:
-            response = requests.post(
-                url=request_url,
-                json=partitionPostBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add user partition -> %s; error -> %s (%s)",
-                    name,
-                    response.text,
-                    response.status_code,
-                )
-                return None
-
-    # end method definition
-
-    def get_partition(self, name: str, show_error: bool = True) -> dict | None:
-        """Get an existing user partition from OTDS
-
-        Args:
-            name (str): name of the partition to retrieve
-            show_error (bool, optional): whether or not we want to log an error
-                                         if partion is not found
-        Returns:
-            dict: Request response or None if the REST call fails.
-        """
-
-        request_url = "{}/{}".format(self.config()["partitionUrl"], name)
+        # OTDS delivers an empty response.text for the API, so we don't parse it here:
+        response = self.do_request(
+            url=request_url,
+            method="POST",
+            json_data=group_to_parent_group_post_body_json,
+            timeout=None,
+            failure_message="Failed to add group -> '{}' to parent group -> '{}'".format(
+                group, parent_group
+            ),
+            parse_request_response=False,
+        )
 
-        logger.info("Getting user partition -> %s; calling -> %s", name, request_url)
+        if response and response.ok:
+            return True
 
-        retries = 0
-        while True:
-            response = requests.get(
-                url=request_url,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                if show_error:
-                    logger.error(
-                        "Failed to get partition -> %s; warning -> %s (%s)",
-                        name,
-                        response.text,
-                        response.status_code,
-                    )
-                return None
+        return False
 
     # end method definition
 
-    def add_user(
+    def add_resource(
         self,
-        partition: str,
         name: str,
         description: str = "",
-        first_name: str = "",
-        last_name: str = "",
-        email: str = "",
+        display_name: str = "",
+        allow_impersonation: bool = True,
+        resource_id: str | None = None,
+        secret: str | None = None,  # needs to be 16 bytes!
+        additional_payload: dict | None = None,
     ) -> dict | None:
-        """Add a new user to a user partition in OTDS
+        """Add an OTDS resource
 
         Args:
-            partition (str): name of the OTDS user partition (needs to exist)
-            name (str): login name of the new user
-            description (str, optional): description of the new user
-            first_name (str, optional): first name of the new user
-            last_name (str, optional): last name of the new user
-            email (str, optional): email address of the new user
+            name (str): name of the new OTDS resource
+            description (str): description of the new OTDS resource
+            display_name (str): display name of the OTDS resource
+            additional_payload (dict, optional): additional values for the json payload
         Returns:
-            dict: Request response or None if the creation fails.
+            dict: Request response (dictionary) or None if the REST call fails.
         """
 
-        userPostBodyJson = {
-            "userPartitionID": partition,
-            "values": [
-                {"name": "sn", "values": [last_name]},
-                {"name": "givenName", "values": [first_name]},
-                {"name": "mail", "values": [email]},
-            ],
-            "name": name,
+        resource_post_body = {
+            "resourceName": name,
             "description": description,
+            "displayName": display_name,
+            "allowImpersonation": allow_impersonation,
         }
 
-        request_url = self.users_url()
+        if resource_id and not secret:
+            logger.error(
+                "A resource ID can only be specified if a secret value is also provided!"
+            )
+            return None
+
+        if resource_id:
+            resource_post_body["resourceID"] = resource_id
+        if secret:
+            if len(secret) != 24 or not secret.endswith("=="):
+                logger.warning(
+                    "The secret should by 24 characters long and should end with '=='"
+                )
+            resource_post_body["secretKey"] = secret
+
+        # Check if there's additional payload for the body provided to handle special cases:
+        if additional_payload:
+            # Merge additional payload:
+            resource_post_body.update(additional_payload)
 
-        logger.info(
-            "Adding user -> %s to partition -> %s; calling -> %s",
+        request_url = self.config()["resourceUrl"]
+
+        logger.debug(
+            "Adding resource -> '%s' ('%s'); calling -> %s",
             name,
-            partition,
+            description,
             request_url,
         )
-        logger.debug("User Attributes -> %s", str(userPostBodyJson))
 
-        retries = 0
-        while True:
-            response = requests.post(
-                url=request_url,
-                json=userPostBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add user -> %s; error -> %s (%s)",
-                    name,
-                    response.text,
-                    response.status_code,
-                )
-                return None
+        return self.do_request(
+            url=request_url,
+            method="POST",
+            json_data=resource_post_body,
+            timeout=None,
+            failure_message="Failed to add resource -> '{}'".format(name),
+        )
 
     # end method definition
 
-    def get_user(self, partition: str, user_id: str) -> dict | None:
-        """Get a user by its partition and user ID
+    def get_resource(self, name: str, show_error: bool = False) -> dict | None:
+        """Get an existing OTDS resource
 
         Args:
-            partition (str): name of the partition
-            user_id (str): ID of the user (= login name)
+            name (str): name of the new OTDS resource
+            show_error (bool, optional): treat as error if resource is not found
         Returns:
-            dict: Request response or None if the user was not found.
+            dict: Request response or None if the REST call fails.
+
+            Example:
+            {
+                'resourceName': 'cs',
+                'id': 'cs',
+                'description': 'Content Server',
+                'displayName': 'IDEA-TE DEV - Extended ECM 24.4.0',
+                'resourceID': 'd441e5cb-68ef-4cb7-a8a0-037ba6b35522',
+                'resourceState': 1,
+                'userSynchronizationState': True,
+                'resourceDN': 'oTResource=d441e5cb-68ef-4cb7-a8a0-037ba6b35522,dc=identity,dc=opentext,dc=net',
+                'resourceType': 'cs',
+                'accessRoleList': [{...}],
+                'impersonateList': None,
+                'impersonateAnonymousList': None,
+                'pcCreatePermissionAllowed': True,
+                'pcModifyPermissionAllowed': True,
+                'pcDeletePermissionAllowed': True,
+                'logoutURL': 'https://otawp.dev.idea-te.eimdemo.com/home/system/wcp/sso/sso_logout.htm',
+                'logoutMethod': 'GET',
+                'allowImpersonation': True,
+                'connectionHealthy': True,
+                'connectorName': 'Content Server',
+                'connectorid': 'cs',
+                'userAttributeMapping': [{...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}],
+                'groupAttributeMapping': [{...}, {...}],
+                'connectionParamInfo': [{...}, {...}, {...}, {...}, {...}, {...}, {...}],
+                'logonStyle': None,
+                'logonUXVersion': 0
+            }
         """
 
-        request_url = self.users_url() + "/" + user_id + "@" + partition
+        request_url = "{}/{}".format(self.config()["resourceUrl"], name)
 
-        logger.info(
-            "Get user -> %s in partition -> %s; calling -> %s",
-            user_id,
-            partition,
-            request_url,
-        )
+        logger.debug("Get resource -> '%s'; calling -> %s", name, request_url)
 
-        retries = 0
-        while True:
-            response = requests.get(
-                url=request_url,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to get user -> %s; error -> %s (%s)",
-                    user_id,
-                    response.text,
-                    response.status_code,
-                )
-                return None
+        return self.do_request(
+            url=request_url,
+            method="GET",
+            timeout=None,
+            failure_message="Failed to get resource -> '{}'".format(name),
+            show_error=show_error,
+        )
 
     # end method definition
 
-    def get_users(self, partition: str = "", limit: int | None = None) -> dict | None:
-        """Get all users in a partition partition
+    def update_resource(
+        self, name: str, resource: object, show_error: bool = True
+    ) -> dict | None:
+        """Update an existing OTDS resource
 
         Args:
-            partition (str, optional): name of the partition
-            limit (int): maximum number of users to return
+            name (str): name of the new OTDS resource
+            resource (object): updated resource object of get_resource called before
+            show_error (bool, optional): treat as error if resource is not found
         Returns:
-            dict: Request response or None if the user was not found.
+            dict: Request response (json) or None if the REST call fails.
         """
 
-        # Add query parameters (these are NOT passed via JSon body!)
-        query = {}
-        if limit:
-            query["limit"] = limit
-        if partition:
-            query["where_partition_name"] = partition
-
-        encodedQuery = urllib.parse.urlencode(query, doseq=True)
-
-        request_url = self.users_url()
-        if query:
-            request_url += "?{}".format(encodedQuery)
+        request_url = "{}/{}".format(self.config()["resourceUrl"], name)
 
-        if partition:
-            logger.info(
-                "Get all users in partition -> %s (limit -> %s); calling -> %s",
-                partition,
-                limit,
-                request_url,
-            )
-        else:
-            logger.info(
-                "Get all users (limit -> %s); calling -> %s",
-                limit,
-                request_url,
-            )
+        logger.debug("Updating resource -> '%s'; calling -> %s", name, request_url)
 
-        retries = 0
-        while True:
-            response = requests.get(
-                url=request_url,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                if partition:
-                    logger.error(
-                        "Failed to get users in partition -> %s; error -> %s (%s)",
-                        partition,
-                        response.text,
-                        response.status_code,
-                    )
-                else:
-                    logger.error(
-                        "Failed to get users; error -> %s (%s)",
-                        response.text,
-                        response.status_code,
-                    )
-                return None
+        return self.do_request(
+            url=request_url,
+            method="PUT",
+            json_data=resource,
+            timeout=None,
+            failure_message="Failed to update resource -> '{}'".format(name),
+            show_error=show_error,
+        )
 
     # end method definition
 
-    def update_user(
-        self, partition: str, user_id: str, attribute_name: str, attribute_value: str
-    ) -> dict | None:
-        """Update a user attribute with a new value
+    def activate_resource(self, resource_id: str) -> dict | None:
+        """Activate an OTDS resource
 
         Args:
-            partition (str): name of the partition
-            user_id (str): ID of the user (= login name)
-            attribute_name (str): name of the attribute
-            attribute_value (str): new value of the attribute
-        Return:
-            dict: Request response or None if the update fails.
+            resource_id (str): ID of the OTDS resource
+        Returns:
+            dict: Request response (json) or None if the REST call fails.
         """
 
-        if attribute_name in ["description"]:
-            userPatchBodyJson = {
-                "userPartitionID": partition,
-                attribute_name: attribute_value,
-            }
-        else:
-            userPatchBodyJson = {
-                "userPartitionID": partition,
-                "values": [{"name": attribute_name, "values": [attribute_value]}],
-            }
+        resource_post_body_json = {}
 
-        request_url = self.users_url() + "/" + user_id
+        request_url = "{}/{}/activate".format(self.config()["resourceUrl"], resource_id)
 
-        logger.info(
-            "Update user -> %s attribute -> %s to value -> %s; calling -> %s",
-            user_id,
-            attribute_name,
-            attribute_value,
-            request_url,
+        logger.debug(
+            "Activating resource -> '%s'; calling -> %s", resource_id, request_url
         )
 
-        retries = 0
-        while True:
-            response = requests.patch(
-                url=request_url,
-                json=userPatchBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to update user -> %s; error -> %s (%s)",
-                    user_id,
-                    response.text,
-                    response.status_code,
-                )
-                return None
+        return self.do_request(
+            url=request_url,
+            method="POST",
+            json_data=resource_post_body_json,
+            timeout=None,
+            failure_message="Failed to activate resource -> '{}'".format(resource_id),
+        )
 
     # end method definition
 
-    def delete_user(self, partition: str, user_id: str) -> bool:
-        """Delete an existing user
+    def get_access_roles(self) -> dict | None:
+        """Get a list of all OTDS access roles
 
         Args:
-            partition (str): name of the partition
-            user_id (str): Id (= login name) of the user
+            None
         Returns:
-            bool: True = success, False = error
+            dict: Request response or None if the REST call fails.
         """
 
-        request_url = self.users_url() + "/" + user_id + "@" + partition
+        request_url = self.config()["accessRoleUrl"]
 
-        logger.info(
-            "Delete user -> %s in partition -> %s; calling -> %s",
-            user_id,
-            partition,
-            request_url,
-        )
+        logger.debug("Retrieving access roles; calling -> %s", request_url)
 
-        retries = 0
-        while True:
-            response = requests.delete(
-                url=request_url,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return True
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to delete user -> %s; error -> %s (%s)",
-                    user_id,
-                    response.text,
-                    response.status_code,
-                )
-                return False
+        return self.do_request(
+            url=request_url,
+            method="GET",
+            timeout=None,
+            failure_message="Failed to get access roles",
+        )
 
     # end method definition
 
-    def reset_user_password(self, user_id: str, password: str) -> bool:
-        """Reset a password of an existing user
+    def get_access_role(self, access_role: str) -> dict | None:
+        """Get an OTDS access role
 
         Args:
-            user_id (str): Id (= login name) of the user
-            password (str): new password of the user
+            name (str): name of the access role
         Returns:
-            bool: True = success, False = error.
+            dict: Request response (json) or None if the REST call fails.
         """
 
-        userPostBodyJson = {"newPassword": password}
+        request_url = self.config()["accessRoleUrl"] + "/" + access_role
 
-        request_url = "{}/{}/password".format(self.users_url(), user_id)
+        logger.debug("Get access role -> '%s'; calling -> %s", access_role, request_url)
 
-        logger.info(
-            "Resetting password for user -> %s; calling -> %s", user_id, request_url
+        return self.do_request(
+            url=request_url,
+            method="GET",
+            timeout=None,
+            failure_message="Failed to get access role -> '{}'".format(access_role),
         )
 
-        retries = 0
-        while True:
-            response = requests.put(
-                url=request_url,
-                json=userPostBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return True
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to reset password for user -> %s; error -> %s (%s)",
-                    user_id,
-                    response.text,
-                    response.status_code,
-                )
-                return False
-
     # end method definition
 
-    def add_group(self, partition: str, name: str, description: str) -> dict | None:
-        """Add a new user group to a user partition in OTDS
+    def add_partition_to_access_role(
+        self, access_role: str, partition: str, location: str = ""
+    ) -> bool:
+        """Add an OTDS partition to an OTDS access role
 
         Args:
-            partition (str): name of the OTDS user partition (needs to exist)
-            name (str): name of the new group
-            description (str): description of the new group
+            access_role (str): name of the OTDS access role
+            partition (str): name of the partition
+            location (str, optional): this is kind of a unique identifier DN (Distinguished Name)
+                                      most of the times you will want to keep it to empty string ("")
         Returns:
-            dict: Request response (json) or None if the creation fails.
+            bool: True if partition is in access role or has been successfully added.
+                  False if partition has been not been added (error)
         """
 
-        groupPostBodyJson = {
-            "userPartitionID": partition,
-            "name": name,
-            "description": description,
+        access_role_post_body_json = {
+            "userPartitions": [{"name": partition, "location": location}]
         }
 
-        request_url = self.groups_url()
+        request_url = "{}/{}/members".format(
+            self.config()["accessRoleUrl"], access_role
+        )
 
-        logger.info(
-            "Adding group -> %s to partition -> %s; calling -> %s",
-            name,
+        logger.debug(
+            "Add user partition -> '%s' to access role -> '%s'; calling -> %s",
             partition,
+            access_role,
             request_url,
         )
-        logger.debug("Group Attributes -> %s", str(groupPostBodyJson))
 
-        retries = 0
-        while True:
-            response = requests.post(
-                url=request_url,
-                json=groupPostBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add group -> %s; error -> %s (%s)",
-                    name,
-                    response.text,
-                    response.status_code,
-                )
-                return None
+        response = self.do_request(
+            url=request_url,
+            method="POST",
+            json_data=access_role_post_body_json,
+            timeout=None,
+            failure_message="Failed to add partition -> '{}' to access role -> '{}'".format(
+                partition, access_role
+            ),
+            parse_request_response=False,
+        )
+
+        if response and response.ok:
+            return True
+
+        return False
 
     # end method definition
 
-    def get_group(self, group: str) -> dict | None:
-        """Get a OTDS group by its group name
+    def add_user_to_access_role(
+        self, access_role: str, user_id: str, location: str = ""
+    ) -> bool:
+        """Add an OTDS user to an OTDS access role
 
         Args:
-            group (str): ID of the group (= group name)
-        Return:
-            dict: Request response or None if the group was not found.
-            Example values:
-            {
-                'numMembers': 7,
-                'userPartitionID': 'Content Server Members',
-                'name': 'Sales',
-                'location': 'oTGroup=3f921294-b92a-4c9e-bf7c-b50df16bb937,orgunit=groups,partition=Content Server Members,dc=identity,dc=opentext,dc=net',
-                'id': 'Sales@Content Server Members',
-                'values': [{...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, ...],
-                'description': None,
-                'uuid': '3f921294-b92a-4c9e-bf7c-b50df16bb937',
-                'objectClass': 'oTGroup',
-                'customAttributes': None,
-                'originUUID': None,
-                'urlId': 'Sales@Content Server Members',
-                'urlLocation': 'oTGroup=3f921294-b92a-4c9e-bf7c-b50df16bb937,orgunit=groups,partition=Content Server Members,dc=identity,dc=opentext,dc=net'
-            }
+            access_role (str): name of the OTDS access role
+            user_id (str): ID of the user (= login name)
+            location (str, optional): this is kind of a unique identifier DN (Distinguished Name)
+                                      most of the times you will want to keep it to empty string ("")
+        Returns:
+            bool: True if user is in access role or has been successfully added.
+                  False if user has not been added (error)
         """
 
-        request_url = self.groups_url() + "/" + group
-
-        logger.info("Get group -> %s; calling -> %s", group, request_url)
+        # get existing members to check if user is already a member:
+        access_roles_get_response = self.get_access_role(access_role)
+        if not access_roles_get_response:
+            return False
 
-        retries = 0
-        while True:
-            response = requests.get(
-                url=request_url,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to get group -> %s; error -> %s (%s)",
-                    group,
-                    response.text,
-                    response.status_code,
+        # Checking if user already added to access role
+        accessRoleUsers = access_roles_get_response["accessRoleMembers"]["users"]
+        for user in accessRoleUsers:
+            if user["displayName"] == user_id:
+                logger.debug(
+                    "User -> '%s' already added to access role -> '%s'",
+                    user_id,
+                    access_role,
                 )
-                return None
+                return True
+
+        logger.debug(
+            "User -> '%s' is not yet in access role -> '%s' - adding...",
+            user_id,
+            access_role,
+        )
+
+        # create payload for REST call:
+        access_role_post_body_json = {
+            "users": [{"name": user_id, "location": location}]
+        }
+
+        request_url = "{}/{}/members".format(
+            self.config()["accessRoleUrl"], access_role
+        )
+
+        logger.debug(
+            "Add user -> %s to access role -> %s; calling -> %s",
+            user_id,
+            access_role,
+            request_url,
+        )
+
+        response = self.do_request(
+            url=request_url,
+            method="POST",
+            json_data=access_role_post_body_json,
+            timeout=None,
+            failure_message="Failed to add user -> '{}' to access role -> '{}'".format(
+                user_id, access_role
+            ),
+            parse_request_response=False,
+        )
+
+        if response and response.ok:
+            return True
+
+        return False
 
     # end method definition
 
-    def add_user_to_group(self, user: str, group: str) -> bool:
-        """Add an existing user to an existing group in OTDS
+    def add_group_to_access_role(
+        self, access_role: str, group: str, location: str = ""
+    ) -> bool:
+        """Add an OTDS group to an OTDS access role
 
         Args:
-            user (str): name of the OTDS user (needs to exist)
-            group (str): name of the OTDS group (needs to exist)
+            access_role (str): name of the OTDS access role
+            group (str): name of the group
+            location (str, optional): this is kind of a unique identifier DN (Distinguished Name)
+                                      most of the times you will want to keep it to empty string ("")
         Returns:
-            bool: True, if request is successful, False otherwise.
+            bool: True if group is in access role or has been successfully added.
+                  False if group has been not been added (error)
         """
 
-        userToGroupPostBodyJson = {"stringList": [group]}
-
-        request_url = self.users_url() + "/" + user + "/memberof"
+        # get existing members to check if user is already a member:
+        access_roles_get_response = self.get_access_role(access_role)
+        if not access_roles_get_response:
+            return False
 
-        logger.info(
-            "Adding user -> %s to group -> %s; calling -> %s", user, group, request_url
-        )
-
-        retries = 0
-        while True:
-            response = requests.post(
-                url=request_url,
-                json=userToGroupPostBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return True
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add user -> %s to group -> %s; error -> %s (%s)",
-                    user,
+        # Checking if group already added to access role
+        access_role_groups = access_roles_get_response["accessRoleMembers"]["groups"]
+        for access_role_group in access_role_groups:
+            if access_role_group["name"] == group:
+                logger.debug(
+                    "Group -> '%s' already added to access role -> '%s'",
                     group,
-                    response.text,
-                    response.status_code,
+                    access_role,
                 )
-                return False
+                return True
+
+        logger.debug(
+            "Group -> '%s' is not yet in access role -> '%s' - adding...",
+            group,
+            access_role,
+        )
+
+        # create payload for REST call:
+        access_role_post_body_json = {"groups": [{"name": group, "location": location}]}
+
+        request_url = "{}/{}/members".format(
+            self.config()["accessRoleUrl"], access_role
+        )
+
+        logger.debug(
+            "Add group -> '%s' to access role -> '%s'; calling -> %s",
+            group,
+            access_role,
+            request_url,
+        )
+
+        response = self.do_request(
+            url=request_url,
+            method="POST",
+            json_data=access_role_post_body_json,
+            timeout=None,
+            failure_message="Failed to add group -> '{}' to access role -> '{}'".format(
+                group, access_role
+            ),
+            parse_request_response=False,
+        )
+
+        if response and response.ok:
+            return True
+
+        return False
 
     # end method definition
 
-    def add_group_to_parent_group(self, group: str, parent_group: str) -> bool:
-        """Add an existing group to an existing parent group in OTDS
+    def update_access_role_attributes(
+        self, name: str, attribute_list: list
+    ) -> dict | None:
+        """Update some attributes of an existing OTDS Access Role
 
         Args:
-            group (str): name of the OTDS group (needs to exist)
-            parent_group (str): name of the OTDS parent group (needs to exist)
+            name (str): name of the existing access role
+            attribute_list (list): list of attribute name and attribute value pairs
+                                   The values need to be a list as well. Example:
+                                   [{name: "pushAllGroups", values: ["True"]}]
         Returns:
-            bool: True, if request is successful, False otherwise.
+            dict: Request response (json) or None if the REST call fails.
         """
 
-        groupToParentGroupPostBodyJson = {"stringList": [parent_group]}
+        # Return if list is empty:
+        if not attribute_list:
+            return None
 
-        request_url = self.groups_url() + "/" + group + "/memberof"
+        # create payload for REST call:
+        access_role = self.get_access_role(name)
+        if not access_role:
+            logger.error("Failed to get access role -> '%s'", name)
+            return None
 
-        logger.info(
-            "Adding group -> %s to parent group -> %s; calling -> %s",
-            group,
-            parent_group,
+        access_role_put_body_json = {"attributes": attribute_list}
+
+        request_url = "{}/{}/attributes".format(self.config()["accessRoleUrl"], name)
+
+        logger.debug(
+            "Update access role -> '%s' with attributes -> %s; calling -> %s",
+            name,
+            str(access_role_put_body_json),
             request_url,
         )
 
-        retries = 0
-        while True:
-            response = requests.post(
-                url=request_url,
-                json=groupToParentGroupPostBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-
-            if response.ok:
-                return True
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add group -> %s to parent group -> %s; error -> %s (%s)",
-                    group,
-                    parent_group,
-                    response.text,
-                    response.status_code,
-                )
-                return False
+        return self.do_request(
+            url=request_url,
+            method="PUT",
+            json_data=access_role_put_body_json,
+            timeout=None,
+            failure_message="Failed to update access role -> '{}'".format(access_role),
+        )
 
     # end method definition
 
-    def add_resource(
+    def add_license_to_resource(
         self,
-        name: str,
-        description: str,
-        display_name: str,
-        additional_payload: dict | None = None,
+        path_to_license_file: str,
+        product_name: str,
+        product_description: str,
+        resource_id: str,
+        update: bool = True,
     ) -> dict | None:
-        """Add an OTDS resource
+        """Add a product license to an OTDS resource.
 
         Args:
-            name (str): name of the new OTDS resource
-            description (str): description of the new OTDS resource
-            display_name (str): display name of the OTDS resource
-            additional_payload (dict, optional): additional values for the json payload
+            path_to_license_file (str): fully qualified filename of the license file
+            product_name (str): product name
+            product_description (str): product description
+            resource_id (str): OTDS resource ID (this is ID not the resource name!)
+            update (bool, optional): whether or not an existing license should be updated (default = True)
         Returns:
-            dict: Request response (dictionary) or None if the REST call fails.
+            dict: Request response (dictionary) or None if the REST call fails
         """
 
-        resourcePostBodyJson = {
-            "resourceName": name,
-            "description": description,
-            "displayName": display_name,
-        }
+        logger.debug("Reading license file -> '%s'...", path_to_license_file)
+        try:
+            with open(path_to_license_file, "rt", encoding="UTF-8") as license_file:
+                license_content = license_file.read()
+        except IOError as exception:
+            logger.error(
+                "Error opening license file -> '%s'; error -> %s",
+                path_to_license_file,
+                exception.strerror,
+            )
+            return None
 
-        # Check if there's additional payload for the body provided to handle special cases:
-        if additional_payload:
-            # Merge additional payload:
-            resourcePostBodyJson.update(additional_payload)
+        license_post_body_json = {
+            "description": product_description,
+            "name": product_name,
+            "values": [
+                {"name": "oTLicenseFile", "values": license_content},
+                {"name": "oTLicenseResource", "values": resource_id},
+                {"name": "oTLicenseFingerprintGenerator", "values": [None]},
+            ],
+        }
 
-        request_url = self.config()["resourceUrl"]
+        request_url = self.license_url()
+        # Check if we want to update an existing license:
+        if update:
+            existing_license = self.get_license_for_resource(resource_id)
+            if existing_license:
+                request_url += "/" + existing_license[0]["id"]
+            else:
+                logger.debug(
+                    "No existing license found for resource -> '%s' - adding a new license...",
+                    resource_id,
+                )
+                # change strategy to create a new license:
+                update = False
 
-        logger.info(
-            "Adding resource -> %s (%s); calling -> %s", name, description, request_url
+        logger.debug(
+            "Adding product license -> '%s' for product -> '%s' to resource ->'%s'; calling -> %s",
+            path_to_license_file,
+            product_description,
+            resource_id,
+            request_url,
         )
 
-        retries = 0
-        while True:
-            response = requests.post(
+        if update:
+            # Do a REST PUT call for update an existing license:
+            return self.do_request(
                 url=request_url,
-                json=resourcePostBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
+                method="PUT",
+                json_data=license_post_body_json,
                 timeout=None,
+                failure_message="Failed to update product license -> '{}' for product -> '{}'".format(
+                    path_to_license_file, product_description
+                ),
+            )
+        else:
+            # Do a REST POST call for creation of a new license:
+            return self.do_request(
+                url=request_url,
+                method="POST",
+                json_data=license_post_body_json,
+                timeout=None,
+                failure_message="Failed to add product license -> '{}' for product -> '{}'".format(
+                    path_to_license_file, product_description
+                ),
             )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add resource -> %s; error -> %s (%s)",
-                    name,
-                    response.text,
-                    response.status_code,
-                )
-                return None
 
     # end method definition
 
-    def get_resource(self, name: str, show_error: bool = False) -> dict | None:
-        """Get an existing OTDS resource
+    def get_license_for_resource(self, resource_id: str):
+        """Get a product license for a resource in OTDS.
 
         Args:
-            name (str): name of the new OTDS resource
-            show_error (bool, optional): treat as error if resource is not found
+            resource_id (str): OTDS resource ID (this is ID not the resource name!)
         Returns:
-            dict: Request response or None if the REST call fails.
+            Licenses for a resource or None if the REST call fails
+
+        licenses have this format:
+        {
+          '_oTLicenseType': 'NON-PRODUCTION',
+          '_oTLicenseResource': '7382094f-a434-4714-9696-82864b6803da',
+          '_oTLicenseResourceName': 'cs',
+          '_oTLicenseProduct': 'EXTENDED_ECM',
+          'name': 'EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da',
+          'location': 'cn=EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da,ou=Licenses,dc=identity,dc=opentext,dc=net',
+          'id': 'cn=EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da,ou=Licenses,dc=identity,dc=opentext,dc=net',
+          'description': 'CS license',
+          'values': [{...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, ...]
+        }
         """
 
-        request_url = "{}/{}".format(self.config()["resourceUrl"], name)
+        request_url = (
+            self.license_url()
+            + "/assignedlicenses?resourceID="
+            + resource_id
+            + "&validOnly=false"
+        )
 
-        logger.info("Retrieving resource -> %s; calling -> %s", name, request_url)
+        logger.debug(
+            "Get license for resource -> %s; calling -> %s", resource_id, request_url
+        )
 
-        retries = 0
-        while True:
-            response = requests.get(
-                url=request_url,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                # We don't necessarily want to log an error as this function
-                # is also used in wait loops:
-                if show_error:
-                    logger.warning(
-                        "Failed to retrieve resource -> %s; warning -> %s",
-                        name,
-                        response.text,
-                    )
-                else:
-                    logger.info("Resource -> %s not found.", name)
-                return None
+        response = self.do_request(
+            url=request_url,
+            method="GET",
+            timeout=None,
+            failure_message="Failed to get license for resource -> '{}'".format(
+                resource_id
+            ),
+        )
+
+        if not response:
+            return None
+
+        return response["licenseObjects"]["_licenses"]
 
     # end method definition
 
-    def update_resource(
-        self, name: str, resource: object, show_error: bool = True
-    ) -> dict | None:
-        """Update an existing OTDS resource
+    def delete_license_from_resource(self, resource_id: str, license_id: str) -> bool:
+        """Delete a product license for a resource in OTDS.
 
         Args:
-            name (str): name of the new OTDS resource
-            resource (object): updated resource object of get_resource called before
-            show_error (bool, optional): treat as error if resource is not found
+            resource_id (str): OTDS resource ID (this is ID not the resource name!)
+            license_id (str): OTDS license ID (this is the ID not the license name!)
         Returns:
-            dict: Request response (json) or None if the REST call fails.
+            bool: True if successful or False if the REST call fails
         """
 
-        request_url = "{}/{}".format(self.config()["resourceUrl"], name)
-
-        logger.info("Updating resource -> %s; calling -> %s", name, request_url)
+        request_url = "{}/{}".format(self.license_url(), license_id)
 
-        retries = 0
-        while True:
-            response = requests.put(
-                url=request_url,
-                json=resource,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                # We don't necessarily want to log an error as this function
-                # is also used in wait loops:
-                if show_error:
-                    logger.warning(
-                        "Failed to retrieve resource -> %s; warning -> %s",
-                        name,
-                        response.text,
-                    )
-                else:
-                    logger.info("Resource -> %s not found.", name)
-                return None
+        logger.debug(
+            "Deleting product license -> '%s' from resource -> '%s'; calling -> %s",
+            license_id,
+            resource_id,
+            request_url,
+        )
+
+        response = self.do_request(
+            url=request_url,
+            method="DELETE",
+            timeout=None,
+            failure_message="Failed to delete license -> '{}' for resource -> '{}'".format(
+                license_id, resource_id
+            ),
+            parse_request_response=False,
+        )
+
+        if response and response.ok:
+            return True
+
+        return False
 
     # end method definition
 
-    def activate_resource(self, resource_id: str) -> dict | None:
-        """Activate an OTDS resource
+    def assign_user_to_license(
+        self,
+        partition: str,
+        user_id: str,
+        resource_id: str,
+        license_feature: str,
+        license_name: str,
+        license_type: str = "Full",
+    ) -> bool:
+        """Assign an OTDS user to a product license (feature) in OTDS.
 
         Args:
-            resource_id (str): ID of the OTDS resource
+            partition (str): user partition in OTDS, e.g. "Content Server Members"
+            user_id (str): ID of the user (= login name)
+            resource_id (str): OTDS resource ID (this is ID not the resource name!)
+            license_feature (str): name of the license feature
+            license_name (str): name of the license to assign
+            license_type (str, optional): deault is "Full", Extended ECM also has "Occasional"
         Returns:
-            dict: Request response (json) or None if the REST call fails.
+            bool: True if successful or False if the REST call fails or the license is not found
         """
 
-        resourcePostBodyJson = {}
+        licenses = self.get_license_for_resource(resource_id)
 
-        request_url = "{}/{}/activate".format(self.config()["resourceUrl"], resource_id)
+        for lic in licenses:
+            if lic["_oTLicenseProduct"] == license_name:
+                license_location = lic["id"]
+
+        try:
+            license_location
+        except UnboundLocalError:
+            logger.error(
+                "Cannot find license -> '%s' for resource -> %s",
+                license_name,
+                resource_id,
+            )
+            return False
+
+        user = self.get_user(partition, user_id)
+        if user:
+            user_location = user["location"]
+        else:
+            logger.error("Cannot find location for user -> '%s'", user_id)
+            return False
+
+        license_post_body_json = {
+            "_oTLicenseType": license_type,
+            "_oTLicenseProduct": "users",
+            "name": user_location,
+            "values": [{"name": "counter", "values": [license_feature]}],
+        }
+
+        request_url = self.license_url() + "/object/" + license_location
 
-        logger.info(
-            "Activating resource -> %s; calling -> %s", resource_id, request_url
+        logger.debug(
+            "Assign license feature -> '%s' of license -> '%s' associated with resource -> '%s' to user -> '%s'; calling -> %s",
+            license_feature,
+            license_location,
+            resource_id,
+            user_id,
+            request_url,
         )
 
-        retries = 0
-        while True:
-            response = requests.post(
-                url=request_url,
-                json=resourcePostBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
+        response = self.do_request(
+            url=request_url,
+            method="POST",
+            json_data=license_post_body_json,
+            timeout=None,
+            failure_message="Failed to add license feature -> '{}' associated with resource -> '{}' to user -> '{}'".format(
+                license_feature, resource_id, user_id
+            ),
+            parse_request_response=False,
+        )
+
+        if response and response.ok:
+            logger.debug(
+                "Added license feature -> '%s' to user -> '%s'",
+                license_feature,
+                user_id,
             )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to activate resource -> %s; error -> %s (%s)",
-                    resource_id,
-                    response.text,
-                    response.status_code,
-                )
-                return None
+            return True
+
+        return False
 
     # end method definition
 
-    def get_access_roles(self) -> dict | None:
-        """Get a list of all OTDS access roles
+    def assign_partition_to_license(
+        self,
+        partition_name: str,
+        resource_id: str,
+        license_feature: str,
+        license_name: str,
+        license_type: str = "Full",
+    ) -> bool:
+        """Assign an OTDS partition to a product license (feature).
 
         Args:
-            None
+            partition_name (str): user partition in OTDS, e.g. "Content Server Members"
+            resource_id (str): OTDS resource ID (this is ID not the resource name!)
+            license_feature (str): name of the license feature, e.g. "X2" or "ADDON_ENGINEERING"
+            license_name (str): name of the license to assign, e.g. "EXTENDED_ECM" or "INTELLGENT_VIEWIMG"
+            license_type (str, optional): deault is "Full", Extended ECM also has "Occasional"
         Returns:
-            dict: Request response or None if the REST call fails.
+            bool: True if successful or False if the REST call fails or the license is not found
         """
 
-        request_url = self.config()["accessRoleUrl"]
+        licenses = self.get_license_for_resource(resource_id)
+        if not licenses:
+            logger.error(
+                "Resource with ID -> '%s' does not exist or has no licenses",
+                resource_id,
+            )
+            return False
 
-        logger.info("Retrieving access roles; calling -> %s", request_url)
+        # licenses have this format:
+        # {
+        #   '_oTLicenseType': 'NON-PRODUCTION',
+        #   '_oTLicenseResource': '7382094f-a434-4714-9696-82864b6803da',
+        #   '_oTLicenseResourceName': 'cs',
+        #   '_oTLicenseProduct': 'EXTENDED_ECM',
+        #   'name': 'EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da',
+        #   'location': 'cn=EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da,ou=Licenses,dc=identity,dc=opentext,dc=net',
+        #   'id': 'cn=EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da,ou=Licenses,dc=identity,dc=opentext,dc=net',
+        #   'description': 'CS license',
+        #   'values': [{...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, ...]
+        # }
+        for lic in licenses:
+            if lic["_oTLicenseProduct"] == license_name:
+                license_location = lic["id"]
 
-        retries = 0
-        while True:
-            response = requests.get(
-                url=request_url,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
+        try:
+            license_location
+        except UnboundLocalError:
+            logger.error(
+                "Cannot find license -> %s for resource -> %s",
+                license_name,
+                resource_id,
             )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to retrieve access roles; error -> %s (%s)",
-                    response.text,
-                    response.status_code,
-                )
-                return None
+            return False
+
+        license_post_body_json = {
+            "_oTLicenseType": license_type,
+            "_oTLicenseProduct": "partitions",
+            "name": partition_name,
+            "values": [{"name": "counter", "values": [license_feature]}],
+        }
+
+        request_url = self.license_url() + "/object/" + license_location
+
+        logger.debug(
+            "Assign license feature -> '%s' of license -> '%s' associated with resource -> '%s' to partition -> '%s'; calling -> %s",
+            license_feature,
+            license_location,
+            resource_id,
+            partition_name,
+            request_url,
+        )
+
+        response = self.do_request(
+            url=request_url,
+            method="POST",
+            json_data=license_post_body_json,
+            timeout=None,
+            failure_message="Failed to add license feature -> '{}' associated with resource -> '{}' to partition -> '{}'".format(
+                license_feature, resource_id, partition_name
+            ),
+            parse_request_response=False,
+        )
+
+        if response and response.ok:
+            logger.debug(
+                "Added license feature -> '%s' to partition -> '%s'",
+                license_feature,
+                partition_name,
+            )
+            return True
+
+        return False
 
     # end method definition
 
-    def get_access_role(self, access_role: str) -> dict | None:
-        """Get an OTDS access role
+    def get_licensed_objects(
+        self,
+        resource_id: str,
+        license_feature: str,
+        license_name: str,
+    ) -> dict | None:
+        """Return the licensed objects (users, groups, partitions) in OTDS for a license + license feature
+           associated with an OTDS resource (like "cs").
 
         Args:
-            name (str): name of the access role
+            resource_id (str): OTDS resource ID (this is ID not the resource name!)
+            license_feature (str): name of the license feature, e.g. "X2" or "ADDON_ENGINEERING"
+            license_name (str): name of the license to assign, e.g. "EXTENDED_ECM" or "INTELLGENT_VIEWIMG"
         Returns:
-            dict: Request response (json) or None if the REST call fails.
+            dict: data structure of licensed objects
+
+            Example return value:
+            {
+                'status': 0,
+                'displayString': 'Success',
+                'exceptions': None,
+                'retValue': 0,
+                'listGroupsResults': {'groups': [...], 'actualPageSize': 0, 'nextPageCookie': None, 'requestedPageSize': 250},
+                'listUsersResults': {'users': [...], 'actualPageSize': 53, 'nextPageCookie': None, 'requestedPageSize': 250},
+                'listUserPartitionResult': {'_userPartitions': [...], 'warningMessage': None, 'actualPageSize': 0, 'nextPageCookie': None, 'requestedPageSize': 250},
+                'version': 1
+            }
         """
 
-        request_url = self.config()["accessRoleUrl"] + "/" + access_role
+        licenses = self.get_license_for_resource(resource_id)
+        if not licenses:
+            logger.error(
+                "Resource with ID -> '%s' does not exist or has no licenses",
+                resource_id,
+            )
+            return False
 
-        logger.info(
-            "Retrieving access role -> %s; calling -> %s", access_role, request_url
-        )
+        # licenses have this format:
+        # {
+        #   '_oTLicenseType': 'NON-PRODUCTION',
+        #   '_oTLicenseResource': '7382094f-a434-4714-9696-82864b6803da',
+        #   '_oTLicenseResourceName': 'cs',
+        #   '_oTLicenseProduct': 'EXTENDED_ECM',
+        #   'name': 'EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da',
+        #   'location': 'cn=EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da,ou=Licenses,dc=identity,dc=opentext,dc=net',
+        #   'id': 'cn=EXTENDED_ECM¹7382094f-a434-4714-9696-82864b6803da,ou=Licenses,dc=identity,dc=opentext,dc=net',
+        #   'description': 'CS license',
+        #   'values': [{...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, {...}, ...]
+        # }
+        for lic in licenses:
+            if lic["_oTLicenseProduct"] == license_name:
+                license_location = lic["location"]
 
-        retries = 0
-        while True:
-            response = requests.get(
-                url=request_url,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
+        try:
+            license_location
+        except UnboundLocalError:
+            logger.error(
+                "Cannot find license -> %s for resource -> %s",
+                license_name,
+                resource_id,
             )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to retrieve access role -> %s; error -> %s (%s)",
-                    access_role,
-                    response.text,
-                    response.status_code,
-                )
-                return None
+            return False
+
+        request_url = (
+            self.license_url()
+            + "/object/"
+            + license_location
+            + "?counter="
+            + license_feature
+        )
+
+        logger.debug(
+            "Get licensed objects for license -> %s and license feature -> %s associated with resource -> %s; calling -> %s",
+            license_name,
+            license_feature,
+            resource_id,
+            request_url,
+        )
+
+        return self.do_request(
+            url=request_url,
+            method="GET",
+            timeout=None,
+            failure_message="Failed to get licensed objects for license -> '{}' and license feature -> '{}' associated with resource -> '{}'".format(
+                license_name, license_feature, resource_id
+            ),
+        )
 
     # end method definition
 
-    def add_partition_to_access_role(
-        self, access_role: str, partition: str, location: str = ""
+    def is_user_licensed(
+        self, user_name: str, resource_id: str, license_feature: str, license_name: str
     ) -> bool:
-        """Add an OTDS partition to an OTDS access role
+        """Check if a user is licensed for a license and license feature associated with a particular OTDS resource.
 
         Args:
-            access_role (str): name of the OTDS access role
-            partition (str): name of the partition
-            location (str, optional): this is kind of a unique identifier DN (Distinguished Name)
-                                      most of the times you will want to keep it to empty string ("")
+            user_name (str): login name of the OTDS user
+            resource_id (str): OTDS resource ID (this is ID not the resource name!)
+            license_feature (str): name of the license feature, e.g. "X2" or "ADDON_ENGINEERING"
+            license_name (str): name of the license to assign, e.g. "EXTENDED_ECM" or "INTELLGENT_VIEWIMG"
+
         Returns:
-            bool: True if partition is in access role or has been successfully added.
-                  False if partition has been not been added (error)
+            bool: True if the user is licensed and False otherwise
         """
 
-        accessRolePostBodyJson = {
-            "userPartitions": [{"name": partition, "location": location}]
-        }
-
-        request_url = "{}/{}/members".format(
-            self.config()["accessRoleUrl"], access_role
-        )
-
-        logger.info(
-            "Add user partition -> %s to access role -> %s; calling -> %s",
-            partition,
-            access_role,
-            request_url,
+        response = self.get_licensed_objects(
+            resource_id=resource_id,
+            license_feature=license_feature,
+            license_name=license_name,
         )
 
-        retries = 0
-        while True:
-            response = requests.post(
-                url=request_url,
-                json=accessRolePostBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return True
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add partition -> %s to access role -> %s; error -> %s (%s)",
-                    partition,
-                    access_role,
-                    response.text,
-                    response.status_code,
-                )
-                return False
+        if not response or not response["listUsersResults"]:
+            return False
+
+        users = response["listUsersResults"]["users"]
+
+        if not users:
+            return False
+
+        user = next(
+            (item for item in users if item["name"] == user_name),
+            None,
+        )
+
+        if user:
+            return True
+
+        return False
 
     # end method definition
 
-    def add_user_to_access_role(
-        self, access_role: str, user_id: str, location: str = ""
+    def is_group_licensed(
+        self, group_name: str, resource_id: str, license_feature: str, license_name: str
     ) -> bool:
-        """Add an OTDS user to an OTDS access role
+        """Check if a group is licensed for a license and license feature associated with a particular OTDS resource.
 
         Args:
-            access_role (str): name of the OTDS access role
-            user_id (str): ID of the user (= login name)
-            location (str, optional): this is kind of a unique identifier DN (Distinguished Name)
-                                      most of the times you will want to keep it to empty string ("")
+            group_name (str): name of the OTDS user group
+            resource_id (str): OTDS resource ID (this is ID not the resource name!)
+            license_feature (str): name of the license feature, e.g. "X2" or "ADDON_ENGINEERING"
+            license_name (str): name of the license to assign, e.g. "EXTENDED_ECM" or "INTELLGENT_VIEWIMG"
+
         Returns:
-            bool: True if user is in access role or has been successfully added.
-                  False if user has not been added (error)
+            bool: True if the group is licensed and False otherwise
         """
 
-        # get existing members to check if user is already a member:
-        accessRolesGetResponse = self.get_access_role(access_role)
+        response = self.get_licensed_objects(
+            resource_id=resource_id,
+            license_feature=license_feature,
+            license_name=license_name,
+        )
 
-        if not accessRolesGetResponse:
+        if not response or not response["listGroupsResults"]:
             return False
 
-        # Checking if user already added to access role
-        accessRoleUsers = accessRolesGetResponse["accessRoleMembers"]["users"]
-        for user in accessRoleUsers:
-            if user["displayName"] == user_id:
-                logger.info(
-                    "User -> %s already added to access role -> %s",
-                    user_id,
-                    access_role,
-                )
-                return True
-
-        logger.info(
-            "User -> %s is not yet in access role -> %s - adding...",
-            user_id,
-            access_role,
-        )
+        groups = response["listGroupsResults"]["groups"]
 
-        # create payload for REST call:
-        accessRolePostBodyJson = {"users": [{"name": user_id, "location": location}]}
+        if not groups:
+            return False
 
-        request_url = "{}/{}/members".format(
-            self.config()["accessRoleUrl"], access_role
+        group = next(
+            (item for item in groups if item["name"] == group_name),
+            None,
         )
 
-        logger.info(
-            "Add user -> %s to access role -> %s; calling -> %s",
-            user_id,
-            access_role,
-            request_url,
-        )
+        if group:
+            return True
 
-        retries = 0
-        while True:
-            response = requests.post(
-                url=request_url,
-                json=accessRolePostBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return True
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add user -> %s to access role -> %s; error -> %s (%s)",
-                    user_id,
-                    access_role,
-                    response.text,
-                    response.status_code,
-                )
-                return False
+        return False
 
     # end method definition
 
-    def add_group_to_access_role(
-        self, access_role: str, group: str, location: str = ""
+    def is_partition_licensed(
+        self,
+        partition_name: str,
+        resource_id: str,
+        license_feature: str,
+        license_name: str,
     ) -> bool:
-        """Add an OTDS group to an OTDS access role
+        """Check if a partition is licensed for a license and license feature associated with a particular OTDS resource.
 
         Args:
-            access_role (str): name of the OTDS access role
-            group (str): name of the group
-            location (str, optional): this is kind of a unique identifier DN (Distinguished Name)
-                                      most of the times you will want to keep it to empty string ("")
+            partition_name (str): name of the OTDS user partition, e.g. "Content Server Members"
+            resource_id (str): OTDS resource ID (this is ID not the resource name!)
+            license_feature (str): name of the license feature, e.g. "X2" or "ADDON_ENGINEERING"
+            license_name (str): name of the license to assign, e.g. "EXTENDED_ECM" or "INTELLGENT_VIEWIMG"
+
         Returns:
-            bool: True if group is in access role or has been successfully added.
-                  False if group has been not been added (error)
+            bool: True if the partition is licensed and False otherwise
         """
 
-        # get existing members to check if user is already a member:
-        accessRolesGetResponse = self.get_access_role(access_role)
-        if not accessRolesGetResponse:
+        response = self.get_licensed_objects(
+            resource_id=resource_id,
+            license_feature=license_feature,
+            license_name=license_name,
+        )
+
+        if not response or not response["listUserPartitionResult"]:
             return False
 
-        # Checking if group already added to access role
-        accessRoleGroups = accessRolesGetResponse["accessRoleMembers"]["groups"]
-        for accessRoleGroup in accessRoleGroups:
-            if accessRoleGroup["name"] == group:
-                logger.info(
-                    "Group -> %s already added to access role -> %s", group, access_role
-                )
-                return True
+        partitions = response["listUserPartitionResult"]["_userPartitions"]
 
-        logger.info(
-            "Group -> %s is not yet in access role -> %s - adding...",
-            group,
-            access_role,
+        if not partitions:
+            return False
+
+        partition = next(
+            (item for item in partitions if item["name"] == partition_name),
+            None,
         )
 
-        # create payload for REST call:
-        accessRolePostBodyJson = {"groups": [{"name": group, "location": location}]}
+        if partition:
+            return True
 
-        request_url = "{}/{}/members".format(
-            self.config()["accessRoleUrl"], access_role
-        )
+        return False
 
-        logger.info(
-            "Add group -> %s to access role -> %s; calling -> %s",
-            group,
-            access_role,
+    # end method definition
+    
+    def import_synchronized_partition_members(self, name: str) -> dict:
+        """Import users and groups to partition
+
+        Args:
+            name (str): name of the partition in which users need to be imported
+        Returns:
+            dict: Request response or None if the creation fails.
+        """
+        command = {"command": "import"}
+        request_url = self.synchronized_partition_url() + f'/{name}/command'
+        logger.debug(
+            "Importing users and groups in to partition -> %s; calling -> %s",
+            name,
             request_url,
         )
-
         retries = 0
         while True:
             response = requests.post(
                 url=request_url,
-                json=accessRolePostBodyJson,
+                json=command,
                 headers=REQUEST_HEADERS,
                 cookies=self.cookie(),
                 timeout=None,
             )
-            if response.ok:
+            if response.status_code == 204:
                 return True
+            # Check if Session has expired - then re-authenticate and try once more
             elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
+                logger.debug("Session has expired - try to re-authenticate...")
                 self.authenticate(revalidate=True)
                 retries += 1
             else:
                 logger.error(
-                    "Failed to add group -> %s to access role -> %s; error -> %s (%s)",
-                    group,
-                    access_role,
+                    "Failed to Import users and groups to synchronized partition -> %s; error -> %s (%s)",
+                    name,
                     response.text,
                     response.status_code,
                 )
-                return False
-
-    # end method definition
-
-    def update_access_role_attributes(
-        self, name: str, attribute_list: list
-    ) -> dict | None:
-        """Update some attributes of an existing OTDS Access Role
+                return None
+        
+    # end of method definition
+    
+    def add_synchronized_partition(self, name: str, description: str, data: str) -> dict:
+        """Add a new synchronized partition to OTDS
 
         Args:
-            name (str): name of the existing access role
-            attribute_list (list): list of attribute name and attribute value pairs
-                                   The values need to be a list as well. Example:
-                                   [{name: "pushAllGroups", values: ["True"]}]
+            name (str): name of the new partition
+            description (str): description of the new partition
+            data (dict): data for creating synchronized partition
         Returns:
-            dict: Request response (json) or None if the REST call fails.
+            dict: Request response or None if the creation fails.
         """
-
-        # Return if list is empty:
-        if not attribute_list:
-            return None
-
-        # create payload for REST call:
-        access_role = self.get_access_role(name)
-        if not access_role:
-            logger.error("Failed to get access role -> %s", name)
-            return None
-
-        accessRolePutBodyJson = {"attributes": attribute_list}
-
-        request_url = "{}/{}/attributes".format(self.config()["accessRoleUrl"], name)
-
-        logger.info(
-            "Update access role -> %s with attributes -> %s; calling -> %s",
+        synchronizedPartitionPostBodyJson = {
+                "ipConnectionParameter": [
+                ],
+                "ipAuthentication": {
+                },
+                "objectClassNameMapping": [
+                    
+                ],
+                "basicInfo": {
+                },
+                "basicAttributes": []
+        }
+        synchronizedPartitionPostBodyJson.update(data)
+        request_url = self.synchronized_partition_url()
+        logger.debug(
+            "Adding synchronized partition -> %s (%s); calling -> %s",
             name,
-            accessRolePutBodyJson,
+            description,
             request_url,
         )
-
+        synchronizedPartitionPostBodyJson["ipAuthentication"]["bindPassword"] = self.config()["bindPassword"]
         retries = 0
         while True:
-            response = requests.put(
+            response = requests.post(
                 url=request_url,
-                json=accessRolePutBodyJson,
+                json=synchronizedPartitionPostBodyJson,
                 headers=REQUEST_HEADERS,
                 cookies=self.cookie(),
                 timeout=None,
@@ -2257,19 +2229,19 @@ class OTDS:
                 return self.parse_request_response(response)
             # Check if Session has expired - then re-authenticate and try once more
             elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
+                logger.debug("Session has expired - try to re-authenticate...")
                 self.authenticate(revalidate=True)
                 retries += 1
             else:
                 logger.error(
-                    "Failed to update access role -> %s; error -> %s (%s)",
+                    "Failed to add synchronized partition -> %s; error -> %s (%s)",
                     name,
                     response.text,
                     response.status_code,
                 )
                 return None
-
-    # end method definition
+        
+    # end of method definition
 
     def add_system_attribute(
         self, name: str, value: str, description: str = ""
@@ -2284,7 +2256,7 @@ class OTDS:
             dict: Request response (dictionary) or None if the REST call fails.
         """
 
-        systemAttributePostBodyJson = {
+        system_attribute_post_body_json = {
             "name": name,
             "value": value,
             "friendlyName": description,
@@ -2293,46 +2265,30 @@ class OTDS:
         request_url = "{}/system_attributes".format(self.config()["systemConfigUrl"])
 
         if description:
-            logger.info(
-                "Add system attribute -> %s (%s) with value -> %s; calling -> %s",
+            logger.debug(
+                "Add system attribute -> '%s' ('%s') with value -> %s; calling -> %s",
                 name,
                 description,
                 value,
                 request_url,
             )
         else:
-            logger.info(
-                "Add system attribute -> %s with value -> %s; calling -> %s",
+            logger.debug(
+                "Add system attribute -> '%s' with value -> %s; calling -> %s",
                 name,
                 value,
                 request_url,
             )
 
-        retries = 0
-        while True:
-            response = requests.post(
-                url=request_url,
-                json=systemAttributePostBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add system attribute -> %s with value -> %s; error -> %s (%s)",
-                    name,
-                    value,
-                    response.text,
-                    response.status_code,
-                )
-                return None
+        return self.do_request(
+            url=request_url,
+            method="POST",
+            json_data=system_attribute_post_body_json,
+            timeout=None,
+            failure_message="Failed to add system attribute -> '{}' with value -> '{}'".format(
+                name, value
+            ),
+        )
 
     # end method definition
 
@@ -2347,30 +2303,14 @@ class OTDS:
 
         request_url = "{}/whitelist".format(self.config()["systemConfigUrl"])
 
-        logger.info("Retrieving trusted sites; calling -> %s", request_url)
+        logger.debug("Get trusted sites; calling -> %s", request_url)
 
-        retries = 0
-        while True:
-            response = requests.get(
-                url=request_url,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to retrieve trusted sites; error -> %s (%s)",
-                    response.text,
-                    response.status_code,
-                )
-                return None
+        return self.do_request(
+            url=request_url,
+            method="GET",
+            timeout=None,
+            failure_message="Failed to get trusted sites",
+        )
 
     # end method definition
 
@@ -2383,38 +2323,36 @@ class OTDS:
             dict: Request response or None if the REST call fails.
         """
 
-        trustedSitePostBodyJson = {"stringList": [trusted_site]}
+        trusted_site_post_body_json = {"stringList": [trusted_site]}
 
         # we need to first retrieve the existing sites and then
         # append the new one:
-        existingTrustedSites = self.get_trusted_sites()
+        existing_trusted_sites = self.get_trusted_sites()
 
-        if existingTrustedSites:
-            trustedSitePostBodyJson["stringList"].extend(
-                existingTrustedSites["stringList"]
+        if existing_trusted_sites:
+            trusted_site_post_body_json["stringList"].extend(
+                existing_trusted_sites["stringList"]
             )
 
         request_url = "{}/whitelist".format(self.config()["systemConfigUrl"])
 
-        logger.info("Add trusted site -> %s; calling -> %s", trusted_site, request_url)
+        logger.debug(
+            "Add trusted site -> '%s'; calling -> %s", trusted_site, request_url
+        )
 
-        response = requests.put(
+        response = self.do_request(
             url=request_url,
-            json=trustedSitePostBodyJson,
-            headers=REQUEST_HEADERS,
-            cookies=self.cookie(),
+            method="PUT",
+            json_data=trusted_site_post_body_json,
             timeout=None,
+            failure_message="Failed to add trusted site -> '{}'".format(trusted_site),
+            parse_request_response=False,  # don't parse it!
         )
+
         if not response.ok:
-            logger.error(
-                "Failed to add trusted site -> %s; error -> %s (%s)",
-                trusted_site,
-                response.text,
-                response.status_code,
-            )
             return None
 
-        return response  # don't parse it!
+        return response
 
     # end method definition
 
@@ -2427,7 +2365,7 @@ class OTDS:
             Request response (json) or None if the REST call fails.
         """
 
-        auditPutBodyJson = {
+        audit_put_body_json = {
             "daysToKeep": "7",
             "enabled": "true",
             "auditTo": "DATABASE",
@@ -2484,22 +2422,16 @@ class OTDS:
 
         request_url = "{}/audit".format(self.config()["systemConfigUrl"])
 
-        logger.info("Enable audit; calling -> %s", request_url)
-
-        response = requests.put(
-            url=request_url,
-            json=auditPutBodyJson,
-            headers=REQUEST_HEADERS,
-            cookies=self.cookie(),
-            timeout=None,
-        )
-        if not response.ok:
-            logger.error(
-                "Failed to enable audit; error -> %s (%s)",
-                response.text,
-                response.status_code,
-            )
-        return response
+        logger.debug("Enable audit; calling -> %s", request_url)
+
+        return self.do_request(
+            url=request_url,
+            method="PUT",
+            json_data=audit_put_body_json,
+            timeout=None,
+            failure_message="Failed to enable audit",
+            parse_request_response=False,
+        )
 
     # end method definition
 
@@ -2583,7 +2515,7 @@ class OTDS:
         if default_scopes is None:
             default_scopes = []
 
-        oauthClientPostBodyJson = {
+        oauth_client_post_body_json = {
             "id": client_id,
             "description": description,
             "redirectURLs": redirect_urls,
@@ -2601,41 +2533,24 @@ class OTDS:
 
         # Do we have a predefined client secret?
         if secret:
-            oauthClientPostBodyJson["secret"] = secret
+            oauth_client_post_body_json["secret"] = secret
 
         request_url = self.oauth_client_url()
 
-        logger.info(
-            "Adding oauth client -> %s (%s); calling -> %s",
+        logger.debug(
+            "Adding oauth client -> '%s' (%s); calling -> %s",
             description,
             client_id,
             request_url,
         )
 
-        retries = 0
-        while True:
-            response = requests.post(
-                url=request_url,
-                json=oauthClientPostBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add OAuth client -> %s; error -> %s (%s)",
-                    client_id,
-                    response.text,
-                    response.status_code,
-                )
-                return None
+        return self.do_request(
+            url=request_url,
+            method="POST",
+            json_data=oauth_client_post_body_json,
+            timeout=None,
+            failure_message="Failed to add OAuth client -> {}".format(client_id),
+        )
 
     # end method definition
 
@@ -2651,32 +2566,15 @@ class OTDS:
 
         request_url = "{}/{}".format(self.oauth_client_url(), client_id)
 
-        logger.info("Get oauth client -> %s; calling -> %s", client_id, request_url)
+        logger.debug("Get oauth client -> '%s'; calling -> %s", client_id, request_url)
 
-        retries = 0
-        while True:
-            response = requests.get(
-                url=request_url,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                if show_error:
-                    logger.error(
-                        "Failed to get oauth client -> %s; error -> %s (%s)",
-                        client_id,
-                        response.text,
-                        response.status_code,
-                    )
-                return None
+        return self.do_request(
+            url=request_url,
+            method="GET",
+            timeout=None,
+            failure_message="Failed to get oauth client -> '{}'".format(client_id),
+            show_error=show_error,
+        )
 
     # end method definition
 
@@ -2692,41 +2590,24 @@ class OTDS:
             dict: Request response (json) or None if the REST call fails.
         """
 
-        oauthClientPatchBodyJson = updates
+        oauth_client_patch_body_json = updates
 
         request_url = "{}/{}".format(self.oauth_client_url(), client_id)
 
-        logger.info(
-            "Update OAuth client -> %s with -> %s; calling -> %s",
+        logger.debug(
+            "Update OAuth client -> '%s' with -> %s; calling -> %s",
             client_id,
-            updates,
+            str(updates),
             request_url,
         )
 
-        retries = 0
-        while True:
-            response = requests.patch(
-                url=request_url,
-                json=oauthClientPatchBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to update OAuth client -> %s; error -> %s (%s)",
-                    client_id,
-                    response.text,
-                    response.status_code,
-                )
-                return None
+        return self.do_request(
+            url=request_url,
+            method="PATCH",
+            json_data=oauth_client_patch_body_json,
+            timeout=None,
+            failure_message="Failed to update OAuth client -> '{}'".format(client_id),
+        )
 
     # end method definition
 
@@ -2741,40 +2622,25 @@ class OTDS:
 
         request_url = self.config()["accessRoleUrl"] + "/" + access_role_name
 
-        logger.info(
-            "Get access role -> %s; calling -> %s", access_role_name, request_url
+        logger.debug(
+            "Get access role -> '%s'; calling -> %s", access_role_name, request_url
         )
 
-        retries = 0
-        while True:
-            response = requests.get(
-                url=request_url,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                accessRolesJson = self.parse_request_response(response)
-                break
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to retrieve role -> %s; url -> %s : error -> %s (%s)",
-                    access_role_name,
-                    request_url,
-                    response.text,
-                    response.status_code,
-                )
-                return None
+        access_role = self.do_request(
+            url=request_url,
+            method="GET",
+            timeout=None,
+            failure_message="Failed to retrieve access role -> '{}'".format(
+                access_role_name
+            ),
+        )
+        if not access_role:
+            return None
 
         # Checking if OAuthClients partition already added to access role
-        userPartitions = accessRolesJson["accessRoleMembers"]["userPartitions"]
-        for userPartition in userPartitions:
-            if userPartition["userPartition"] == "OAuthClients":
+        user_partitions = access_role["accessRoleMembers"]["userPartitions"]
+        for user_partition in user_partitions:
+            if user_partition["userPartition"] == "OAuthClients":
                 logger.error(
                     "OAuthClients partition already added to role -> %s",
                     access_role_name,
@@ -2784,58 +2650,42 @@ class OTDS:
         # Getting location info for the OAuthClients partition
         # so it can be added to access roles json
         request_url = self.config()["partitionsUrl"] + "/OAuthClients"
-        partitionsResponse = requests.get(
+
+        response = self.do_request(
             url=request_url,
-            headers=REQUEST_HEADERS,
-            cookies=self.cookie(),
+            method="GET",
             timeout=None,
+            failure_message="Failed to get partition info for OAuthClients for role -> '{}'".format(
+                access_role_name
+            ),
         )
-        if partitionsResponse.ok:
-            response_dict = self.parse_request_response(partitionsResponse)
-            if not response_dict:
-                return None
-            oauthClientLocation = response_dict["location"]
-        else:
-            logger.error(
-                "Failed to get partition info for OAuthClients; url -> %s : error -> %s (%s)",
-                request_url,
-                partitionsResponse.text,
-                response.status_code,
-            )
+        if not response:
             return None
 
+        oauth_client_location = response["location"]
+
         # adding OAuthClients info to acess roles organizational units
-        oauthClientsOuBlock = {
-            "location": oauthClientLocation,
-            "name": oauthClientLocation,
+        oauth_clients_ou_block = {
+            "location": oauth_client_location,
+            "name": oauth_client_location,
             "userPartition": None,
         }
-        accessRolesJson["accessRoleMembers"]["organizationalUnits"].append(
-            oauthClientsOuBlock
+        access_role["accessRoleMembers"]["organizationalUnits"].append(
+            oauth_clients_ou_block
         )
 
-        response = requests.put(
+        return self.do_request(
             url=request_url,
-            json=accessRolesJson,
-            headers=REQUEST_HEADERS,
-            cookies=self.cookie(),
+            method="PUT",
             timeout=None,
+            warning_message="Failed to add OAuthClients to access role -> '{}'".format(
+                access_role_name
+            ),
+            show_error=False,
+            show_warning=True,
+            parse_request_response=False,
         )
 
-        if response.ok:
-            logger.info(
-                "OauthClients partition successfully added to access role -> %s",
-                access_role_name,
-            )
-        else:
-            logger.warning(
-                "Status code of -> %s returned attempting to add OAuthClients to access role -> %s: error -> %s",
-                response.status_code,
-                access_role_name,
-                response.text,
-            )
-        return response
-
     # end method definition
 
     def get_access_token(self, client_id: str, client_secret: str) -> str | None:
@@ -2925,34 +2775,17 @@ class OTDS:
 
         request_url = "{}/{}".format(self.auth_handler_url(), name)
 
-        logger.info(
-            "Getting authentication handler -> %s; calling -> %s", name, request_url
+        logger.debug(
+            "Getting authentication handler -> '%s'; calling -> %s", name, request_url
         )
 
-        retries = 0
-        while True:
-            response = requests.get(
-                url=request_url,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                if show_error:
-                    logger.error(
-                        "Failed to get authentication handler -> %s; warning -> %s (%s)",
-                        name,
-                        response.text,
-                        response.status_code,
-                    )
-                return None
+        return self.do_request(
+            url=request_url,
+            method="GET",
+            timeout=None,
+            failure_message="Failed to get authentication handler -> '{}'".format(name),
+            show_error=show_error,
+        )
 
     # end method definition
 
@@ -2995,7 +2828,7 @@ class OTDS:
         if auth_principal_attributes is None:
             auth_principal_attributes = ["oTExternalID1", "oTUserID1"]
 
-        authHandlerPostBodyJson = {
+        auth_handler_post_body_json = {
             "_name": name,
             "_description": description,
             "_class": "com.opentext.otds.as.drivers.saml.SAML2Handler",
@@ -3005,107 +2838,292 @@ class OTDS:
             "_scope": scope,
             "_properties": [
                 {
-                    "_key": "com.opentext.otds.as.drivers.saml.provider_name",
-                    "_name": "Identity Provider (IdP) Name",
-                    "_description": "The name of the identity provider. This should be a single word since it will be part of the metadata URL.",
-                    "_value": provider_name,
+                    "_key": "com.opentext.otds.as.drivers.saml.provider_name",
+                    "_name": "Identity Provider (IdP) Name",
+                    "_description": "The name of the identity provider. This should be a single word since it will be part of the metadata URL.",
+                    "_value": provider_name,
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.provider_metadata_description",
+                    "_name": "IdP Metadata URL",
+                    "_description": "The URL for the IdP's federation metadata. The metadata will be automatically updated by OTDS daily at midnight.",
+                    "_value": saml_url,
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.provider_nameid_format",
+                    "_name": "IdP NameID Format",
+                    "_description": "Specifies which NameID format supported by the identity provider contains the desired user identifier. The value in this identifier must correspond to the value of the user attribute specified for the authentication principal attribute. This value is usually set to urn:oasis:names:tc:SAML:2.0:nameid-format:persistent or urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress. Please ensure this is consistent with the identity provider's configuration.",
+                    "_value": nameid_format,
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml._impersonator_claim",
+                    "_name": "Claim for impersonating user",
+                    "_description": "A claim that contains the ID of the actor/impersonator for the user identified by NameID. It must be in the same format as NameID.",
+                    "_value": "loggedinuserid",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.sp_url",
+                    "_name": "OTDS SP Endpoint",
+                    "_description": "Specifies the service provider URL that will be used to identify OTDS to the identity provider. If not specified, the URL will be taken from the request. This generally needs to be configured for environments in which OTDS is behind a reverse-proxy.",
+                    "_value": otds_sp_endpoint,
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.enable_sp_sso",
+                    "_name": "Active By Default",
+                    "_description": "Whether to activate this handler for any request to the OTDS login page. If true, any login request to the OTDS login page will be redirected to the IdP. If false, the user has to select the provider on the login page.",
+                    "_value": active_by_default,
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml._signature_alg",
+                    "_name": "XML Signature Algorithm",
+                    "_description": "Only relevant when certificate and private key are configured. Default is http://www.w3.org/2000/09/xmldsig#rsa-sha1. Valid values are defined at http://www.w3.org/TR/xmldsig-core1/#sec-AlgID.",
+                    "_value": "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.use_acs_url",
+                    "_name": "Use AssertionConsumerServiceURL",
+                    "_description": "Set to true to have the SAML AuthnRequest use AssertionConsumerServiceURL instead of AssertionConsumerServiceIndex",
+                    "_value": "true",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.grace_period",
+                    "_name": "Grace Period",
+                    "_description": 'Specifies the number of minutes to allow for "NotBefore" and "NotOnOrAfter" fields when validating assertions in order to account for time difference between the identity provider and this service provider.',
+                    "_value": "5",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.auth_request_binding",
+                    "_name": "Auth Request Binding",
+                    "_description": "Specifies the preferred SAML binding to use for sending the AuthnRequest, provided it is supported by the identity provider.",
+                    "_value": "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.auth_response_binding",
+                    "_name": "Auth Response Binding",
+                    "_description": "Specifies the SAML binding to use for the response to an AuthnRequest",
+                    "_value": "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claim1",
+                    "_name": "Claim 1",
+                    "_description": "SAML attribute/claim that should be mapped to an OTDS user attribute. This value is case sensitive. Note that mapped claims are only relevant if the corresponding account is auto-provisioned in OTDS. See the Administration Guide for details.",
+                    "_value": "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute1",
+                    "_name": "OTDS Attribute 1",
+                    "_description": "OTDS user attribute to which the SAML attribute/claim should be mapped",
+                    "_value": "mail",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claim2",
+                    "_name": "Claim 2",
+                    "_value": "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/givenname",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute2",
+                    "_name": "OTDS Attribute 2",
+                    "_value": "givenName",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claim3",
+                    "_name": "Claim 3",
+                    "_value": "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/surname",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute3",
+                    "_name": "OTDS Attribute 3",
+                    "_value": "sn",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claim4",
+                    "_name": "Claim 4",
+                    "_value": "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute4",
+                    "_name": "OTDS Attribute 4",
+                    "_value": "displayName",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claim5",
+                    "_name": "Claim 5",
+                    "_value": "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/streetaddress",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute5",
+                    "_name": "OTDS Attribute 5",
+                    "_value": "oTStreetAddress",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claim6",
+                    "_name": "Claim 6",
+                    "_value": "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/locality",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute6",
+                    "_name": "OTDS Attribute 6",
+                    "_value": "l",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claim7",
+                    "_name": "Claim 7",
+                    "_value": "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/stateorprovince",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute7",
+                    "_name": "OTDS Attribute 7",
+                    "_value": "st",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claim8",
+                    "_name": "Claim 8",
+                    "_value": "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/postalcode",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute8",
+                    "_name": "OTDS Attribute 8",
+                    "_value": "postalCode",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claim9",
+                    "_name": "Claim 9",
+                    "_value": "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/country",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute9",
+                    "_name": "OTDS Attribute 9",
+                    "_value": "countryName",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claim10",
+                    "_name": "Claim 10",
+                    "_value": "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/otherphone",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute10",
+                    "_name": "OTDS Attribute 10",
+                    "_value": "oTTelephoneNumber",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claim11",
+                    "_name": "Claim 11",
+                    "_value": "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/homephone",
                 },
                 {
-                    "_key": "com.opentext.otds.as.drivers.saml.provider_metadata_description",
-                    "_name": "IdP Metadata URL",
-                    "_description": "The URL for the IdP's federation metadata. The metadata will be automatically updated by OTDS daily at midnight.",
-                    "_value": saml_url,
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute11",
+                    "_name": "OTDS Attribute 11",
+                    "_value": "homePhone",
                 },
                 {
-                    "_key": "com.opentext.otds.as.drivers.saml.provider_nameid_format",
-                    "_name": "IdP NameID Format",
-                    "_description": "Specifies which NameID format supported by the identity provider contains the desired user identifier. The value in this identifier must correspond to the value of the user attribute specified for the authentication principal attribute. This value is usually set to urn:oasis:names:tc:SAML:2.0:nameid-format:persistent or urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress. Please ensure this is consistent with the identity provider's configuration.",
-                    "_value": nameid_format,
+                    "_key": "com.opentext.otds.as.drivers.saml.claim12",
+                    "_name": "Claim 12",
+                    "_value": "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/dateofbirth",
                 },
                 {
-                    "_key": "com.opentext.otds.as.drivers.saml._impersonator_claim",
-                    "_name": "Claim for impersonating user",
-                    "_description": "A claim that contains the ID of the actor/impersonator for the user identified by NameID. It must be in the same format as NameID.",
-                    "_value": "loggedinuserid",
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute12",
+                    "_name": "OTDS Attribute 12",
+                    "_value": "birthDate",
                 },
                 {
-                    "_key": "com.opentext.otds.as.drivers.saml.sp_url",
-                    "_name": "OTDS SP Endpoint",
-                    "_description": "Specifies the service provider URL that will be used to identify OTDS to the identity provider. If not specified, the URL will be taken from the request. This generally needs to be configured for environments in which OTDS is behind a reverse-proxy.",
-                    "_value": otds_sp_endpoint,
+                    "_key": "com.opentext.otds.as.drivers.saml.claim13",
+                    "_name": "Claim 13",
+                    "_value": "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/gender",
                 },
                 {
-                    "_key": "com.opentext.otds.as.drivers.saml.enable_sp_sso",
-                    "_name": "Active By Default",
-                    "_description": "Whether to activate this handler for any request to the OTDS login page. If true, any login request to the OTDS login page will be redirected to the IdP. If false, the user has to select the provider on the login page.",
-                    "_value": active_by_default,
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute13",
+                    "_name": "OTDS Attribute 13",
+                    "_value": "gender",
                 },
                 {
-                    "_key": "com.opentext.otds.as.drivers.saml._signature_alg",
-                    "_name": "XML Signature Algorithm",
-                    "_description": "Only relevant when certificate and private key are configured. Default is http://www.w3.org/2000/09/xmldsig#rsa-sha1. Valid values are defined at http://www.w3.org/TR/xmldsig-core1/#sec-AlgID.",
-                    "_value": "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256",
+                    "_key": "com.opentext.otds.as.drivers.saml.claim14",
+                    "_name": "Claim 14",
+                    "_value": "",
                 },
                 {
-                    "_key": "com.opentext.otds.as.drivers.saml.use_acs_url",
-                    "_name": "Use AssertionConsumerServiceURL",
-                    "_description": "Set to true to have the SAML AuthnRequest use AssertionConsumerServiceURL instead of AssertionConsumerServiceIndex",
-                    "_value": "true",
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute14",
+                    "_name": "OTDS Attribute 14",
+                    "_value": "",
                 },
                 {
-                    "_key": "com.opentext.otds.as.drivers.saml.grace_period",
-                    "_name": "Grace Period",
-                    "_description": 'Specifies the number of minutes to allow for "NotBefore" and "NotOnOrAfter" fields when validating assertions in order to account for time difference between the identity provider and this service provider.',
-                    "_value": "5",
+                    "_key": "com.opentext.otds.as.drivers.saml.claim15",
+                    "_name": "Claim 15",
+                    "_value": "http://schemas.xmlsoap.org/claims/Group",
                 },
                 {
-                    "_key": "com.opentext.otds.as.drivers.saml.auth_request_binding",
-                    "_name": "Auth Request Binding",
-                    "_description": "Specifies the preferred SAML binding to use for sending the AuthnRequest, provided it is supported by the identity provider.",
-                    "_value": "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST",
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute15",
+                    "_name": "OTDS Attribute 15",
+                    "_value": "oTMemberOf",
                 },
                 {
-                    "_key": "com.opentext.otds.as.drivers.saml.auth_response_binding",
-                    "_name": "Auth Response Binding",
-                    "_description": "Specifies the SAML binding to use for the response to an AuthnRequest",
-                    "_value": "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST",
+                    "_key": "com.opentext.otds.as.drivers.saml.claim16",
+                    "_name": "Claim 16",
+                    "_value": "http://schemas.xmlsoap.org/claims/Department",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute16",
+                    "_name": "OTDS Attribute 16",
+                    "_value": "oTDepartment",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claim17",
+                    "_name": "Claim 17",
+                    "_value": "http://schemas.xmlsoap.org/claims/Title",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute17",
+                    "_name": "OTDS Attribute 17",
+                    "_value": "title",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claim18",
+                    "_name": "Claim 18",
+                    "_value": "",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute18",
+                    "_name": "OTDS Attribute 18",
+                    "_value": "",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claim19",
+                    "_name": "Claim 19",
+                    "_value": "http://schemas.microsoft.com/ws/2008/06/identity/claims/role",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute19",
+                    "_name": "OTDS Attribute 19",
+                    "_value": "oTMemberOf",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claim20",
+                    "_name": "Claim 20",
+                    "_value": "",
+                },
+                {
+                    "_key": "com.opentext.otds.as.drivers.saml.claimAttribute20",
+                    "_name": "OTDS Attribute 20",
+                    "_value": "",
                 },
             ],
         }
 
         request_url = self.auth_handler_url()
 
-        logger.info(
-            "Adding SAML auth handler -> %s (%s); calling -> %s",
+        logger.debug(
+            "Adding SAML auth handler -> '%s' ('%s'); calling -> %s",
             name,
             description,
             request_url,
         )
 
-        retries = 0
-        while True:
-            response = requests.post(
-                url=request_url,
-                json=authHandlerPostBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add SAML auth handler -> %s; error -> %s (%s)",
-                    name,
-                    response.text,
-                    response.status_code,
-                )
-                return None
+        return self.do_request(
+            url=request_url,
+            method="POST",
+            json_data=auth_handler_post_body_json,
+            timeout=None,
+            failure_message="Failed to add SAML auth handler -> '{}'".format(name),
+        )
 
     # end method definition
 
@@ -3140,7 +3158,7 @@ class OTDS:
             auth_principal_attributes = ["oTExternalID1"]
 
         # 1. Prepare the body for the AuthHandler REST call:
-        authHandlerPostBodyJson = {
+        auth_handler_post_body_json = {
             "_name": name,
             "_description": description,
             "_class": "com.opentext.otds.as.drivers.sapssoext.SAPSSOEXTAuthHandler",
@@ -3196,43 +3214,40 @@ class OTDS:
         # 2. Create the auth handler in OTDS
         request_url = self.auth_handler_url()
 
-        logger.info(
-            "Adding SAP auth handler -> %s (%s); calling -> %s",
+        logger.debug(
+            "Adding SAP auth handler -> '%s' ('%s'); calling -> %s",
             name,
             description,
             request_url,
         )
 
-        response = requests.post(
+        response = self.do_request(
             url=request_url,
-            json=authHandlerPostBodyJson,
-            headers=REQUEST_HEADERS,
-            cookies=self.cookie(),
+            method="POST",
+            json_data=auth_handler_post_body_json,
             timeout=None,
+            failure_message="Failed to add SAP auth handler -> '{}'".format(name),
+            parse_request_response=False,
         )
-        if not response.ok:
-            logger.error(
-                "Failed to add SAP auth handler -> %s; error -> %s (%s)",
-                name,
-                response.text,
-                response.status_code,
-            )
+        if not response or not response.ok:
             return None
 
         # 3. Upload the certificate file:
 
         # Check that the certificate (PSE) file is readable:
-        logger.info("Reading certificate file -> %s...", certificate_file)
+        logger.debug("Reading certificate file -> '%s'...", certificate_file)
         try:
             # PSE files are binary - so we need to open with "rb":
-            with open(certificate_file, "rb") as certFile:
-                certContent = certFile.read()
-                if not certContent:
-                    logger.error("No data in certificate file -> %s", certificate_file)
+            with open(certificate_file, "rb") as cert_file:
+                cert_content = cert_file.read()
+                if not cert_content:
+                    logger.error(
+                        "No data in certificate file -> '%s'", certificate_file
+                    )
                     return None
         except IOError as exception:
             logger.error(
-                "Unable to open certificate file -> %s; error -> %s",
+                "Unable to open certificate file -> '%s'; error -> %s",
                 certificate_file,
                 exception.strerror,
             )
@@ -3243,43 +3258,45 @@ class OTDS:
         try:
             # If file is not base64 encoded the next statement will throw an exception
             # (this is good)
-            certContentDecoded = base64.b64decode(certContent, validate=True)
-            certContentEncoded = base64.b64encode(certContentDecoded).decode("utf-8")
-            if certContentEncoded == certContent.decode("utf-8"):
-                logger.info(
-                    "Certificate file -> %s is base64 encoded", certificate_file
+            cert_content_decoded = base64.b64decode(cert_content, validate=True)
+            cert_content_encoded = base64.b64encode(cert_content_decoded).decode(
+                "utf-8"
+            )
+            if cert_content_encoded == cert_content.decode("utf-8"):
+                logger.debug(
+                    "Certificate file -> '%s' is base64 encoded", certificate_file
                 )
                 cert_file_encoded = True
             else:
                 cert_file_encoded = False
         except TypeError:
-            logger.info(
-                "Certificate file -> %s is not base64 encoded", certificate_file
+            logger.debug(
+                "Certificate file -> '%s' is not base64 encoded", certificate_file
             )
             cert_file_encoded = False
 
         if cert_file_encoded:
             certificate_file = "/tmp/" + os.path.basename(certificate_file)
-            logger.info("Writing decoded certificate file -> %s...", certificate_file)
+            logger.debug("Writing decoded certificate file -> %s...", certificate_file)
             try:
                 # PSE files need to be binary - so we need to open with "wb":
-                with open(certificate_file, "wb") as certFile:
-                    certFile.write(base64.b64decode(certContent))
+                with open(certificate_file, "wb") as cert_file:
+                    cert_file.write(base64.b64decode(cert_content))
             except IOError as exception:
                 logger.error(
-                    "Failed writing to file -> %s; error -> %s",
+                    "Failed writing to file -> '%s'; error -> %s",
                     certificate_file,
                     exception.strerror,
                 )
                 return None
 
-        authHandlerPostData = {
+        auth_handler_post_data = {
             "file1_property": "com.opentext.otds.as.drivers.sapssoext.certificate1"
         }
 
         # It is important to send the file pointer and not the actual file content
         # otherwise the file is send base64 encoded which we don't want:
-        authHandlerPostFiles = {
+        auth_handler_post_files = {
             "file1": (
                 os.path.basename(certificate_file),
                 open(certificate_file, "rb"),
@@ -3289,8 +3306,8 @@ class OTDS:
 
         request_url = self.auth_handler_url() + "/" + name + "/files"
 
-        logger.info(
-            "Uploading certificate file -> %s for SAP auth handler -> %s (%s); calling -> %s",
+        logger.debug(
+            "Uploading certificate file -> '%s' for SAP auth handler -> '%s' ('%s'); calling -> %s",
             certificate_file,
             name,
             description,
@@ -3302,14 +3319,14 @@ class OTDS:
         # then requests will send a multipart/form-data POST automatically:
         response = requests.post(
             url=request_url,
-            data=authHandlerPostData,
-            files=authHandlerPostFiles,
+            data=auth_handler_post_data,
+            files=auth_handler_post_files,
             cookies=self.cookie(),
             timeout=None,
         )
         if not response.ok:
             logger.error(
-                "Failed to upload certificate file -> %s for SAP auth handler -> %s; error -> %s (%s)",
+                "Failed to upload certificate file -> '%s' for SAP auth handler -> '%s'; error -> %s (%s)",
                 certificate_file,
                 name,
                 response.text,
@@ -3366,7 +3383,7 @@ class OTDS:
             auth_principal_attributes = ["oTExtraAttr0"]
 
         # 1. Prepare the body for the AuthHandler REST call:
-        authHandlerPostBodyJson = {
+        auth_handler_post_body_json = {
             "_name": name,
             "_description": description,
             "_class": "com.opentext.otds.as.drivers.http.OAuth2Handler",
@@ -3705,37 +3722,20 @@ class OTDS:
 
         request_url = self.auth_handler_url()
 
-        logger.info(
-            "Adding OAuth auth handler -> %s (%s); calling -> %s",
+        logger.debug(
+            "Adding OAuth auth handler -> '%s' ('%s'); calling -> %s",
             name,
             description,
             request_url,
         )
 
-        retries = 0
-        while True:
-            response = requests.post(
-                url=request_url,
-                json=authHandlerPostBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to add OAuth auth handler -> %s; error -> %s (%s)",
-                    name,
-                    response.text,
-                    response.status_code,
-                )
-                return None
+        return self.do_request(
+            url=request_url,
+            method="POST",
+            json_data=auth_handler_post_body_json,
+            timeout=None,
+            failure_message="Failed to add OAuth auth handler -> '{}'".format(name),
+        )
 
         # end method definition
 
@@ -3750,7 +3750,9 @@ class OTDS:
 
         resource = self.get_resource(resource_name)
         if not resource:
-            logger.error("Resource -> %s not found - cannot consolidate", resource_name)
+            logger.error(
+                "Resource -> '%s' not found - cannot consolidate", resource_name
+            )
             return False
 
         resource_dn = resource["resourceDN"]
@@ -3758,7 +3760,7 @@ class OTDS:
             logger.error("Resource DN is empty - cannot consolidate")
             return False
 
-        consolidationPostBodyJson = {
+        consolidation_post_body_json = {
             "cleanupUsersInResource": False,
             "cleanupGroupsInResource": False,
             "resourceList": [resource_dn],
@@ -3767,33 +3769,28 @@ class OTDS:
 
         request_url = "{}".format(self.consolidation_url())
 
-        logger.info(
-            "Consolidation of resource -> %s; calling -> %s", resource_dn, request_url
+        logger.debug(
+            "Consolidation of resource -> %s (%s); calling -> %s",
+            resource_name,
+            resource_dn,
+            request_url,
         )
 
-        retries = 0
-        while True:
-            response = requests.post(
-                url=request_url,
-                json=consolidationPostBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return True
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to consolidate; error -> %s (%s)",
-                    response.text,
-                    response.status_code,
-                )
-                return False
+        response = self.do_request(
+            url=request_url,
+            method="POST",
+            json_data=consolidation_post_body_json,
+            timeout=None,
+            failure_message="Failed to consolidate resource -> '{}'".format(
+                resource_name
+            ),
+            parse_request_response=False,
+        )
+
+        if response and response.ok:
+            return True
+
+        return False
 
     # end method definition
 
@@ -3818,42 +3815,34 @@ class OTDS:
         if impersonation_list is None:
             impersonation_list = []
 
-        impersonationPutBodyJson = {
+        impersonation_put_body_json = {
             "allowImpersonation": allow_impersonation,
             "impersonateList": impersonation_list,
         }
 
         request_url = "{}/{}/impersonation".format(self.resource_url(), resource_name)
 
-        logger.info(
-            "Impersonation settings for resource -> %s; calling -> %s",
+        logger.debug(
+            "Impersonation settings for resource -> '%s'; calling -> %s",
             resource_name,
             request_url,
         )
 
-        retries = 0
-        while True:
-            response = requests.put(
-                url=request_url,
-                json=impersonationPutBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return True
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to set impersonation for resource -> %s; error -> %s",
-                    resource_name,
-                    response.text,
-                )
-                return False
+        response = self.do_request(
+            url=request_url,
+            method="PUT",
+            json_data=impersonation_put_body_json,
+            timeout=None,
+            failure_message="Failed to set impersonation for resource -> '{}'".format(
+                resource_name
+            ),
+            parse_request_response=False,
+        )
+
+        if response and response.ok:
+            return True
+
+        return False
 
     # end method definition
 
@@ -3877,43 +3866,34 @@ class OTDS:
         if impersonation_list is None:
             impersonation_list = []
 
-        impersonationPutBodyJson = {
+        impersonation_put_body_json = {
             "allowImpersonation": allow_impersonation,
             "impersonateList": impersonation_list,
         }
 
         request_url = "{}/{}/impersonation".format(self.oauth_client_url(), client_id)
 
-        logger.info(
-            "Impersonation settings for OAuth Client -> %s; calling -> %s",
+        logger.debug(
+            "Impersonation settings for OAuth Client -> '%s'; calling -> %s",
             client_id,
             request_url,
         )
 
-        retries = 0
-        while True:
-            response = requests.put(
-                url=request_url,
-                json=impersonationPutBodyJson,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return True
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to set impersonation for OAuth Client -> %s; error -> %s (%s)",
-                    client_id,
-                    response.text,
-                    response.status_code,
-                )
-                return False
+        response = self.do_request(
+            url=request_url,
+            method="PUT",
+            json_data=impersonation_put_body_json,
+            timeout=None,
+            failure_message="Failed to set impersonation for OAuth Client -> '{}'".format(
+                client_id
+            ),
+            parse_request_response=False,
+        )
+
+        if response and response.ok:
+            return True
+
+        return False
 
     # end method definition
 
@@ -3948,30 +3928,14 @@ class OTDS:
 
         request_url = "{}/passwordpolicy".format(self.config()["systemConfigUrl"])
 
-        logger.info("Getting password policy; calling -> %s", request_url)
+        logger.debug("Getting password policy; calling -> %s", request_url)
 
-        retries = 0
-        while True:
-            response = requests.get(
-                url=request_url,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return self.parse_request_response(response)
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to get password policy; error -> %s (%s)",
-                    response.text,
-                    response.status_code,
-                )
-                return None
+        return self.do_request(
+            url=request_url,
+            method="GET",
+            timeout=None,
+            failure_message="Failed to get password policy",
+        )
 
     # end method definition
 
@@ -4009,35 +3973,26 @@ class OTDS:
 
         request_url = "{}/passwordpolicy".format(self.config()["systemConfigUrl"])
 
-        logger.info(
+        logger.debug(
             "Update password policy with these new values -> %s; calling -> %s",
-            update_values,
+            str(update_values),
             request_url,
         )
 
-        retries = 0
-        while True:
-            response = requests.put(
-                url=request_url,
-                json=update_values,
-                headers=REQUEST_HEADERS,
-                cookies=self.cookie(),
-                timeout=None,
-            )
-            if response.ok:
-                return True
-            # Check if Session has expired - then re-authenticate and try once more
-            elif response.status_code == 401 and retries == 0:
-                logger.warning("Session has expired - try to re-authenticate...")
-                self.authenticate(revalidate=True)
-                retries += 1
-            else:
-                logger.error(
-                    "Failed to update password policy with values -> %s; error -> %s (%s)",
-                    update_values,
-                    response.text,
-                    response.status_code,
-                )
-                return False
+        response = self.do_request(
+            url=request_url,
+            method="PUT",
+            json_data=update_values,
+            timeout=None,
+            failure_message="Failed to update password policy with values -> {}".format(
+                update_values
+            ),
+            parse_request_response=False,
+        )
+
+        if response and response.ok:
+            return True
+
+        return False
 
     # end method definition