pyxecm 2.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

pyxecm/customizer/payload.py

@@ -91,6 +91,16 @@ except ModuleNotFoundError:
     )
     pandas_installed = False
 
+try:
+    import psycopg
+
+    psycopg_installed = True
+except ModuleNotFoundError:
+    default_logger.warning(
+        "Module psycopg is not installed. Customizer will not support database command execution.",
+    )
+    psycopg_installed = False
+
 THREAD_NUMBER = 3
 BULK_THREAD_NUMBER = int(os.environ.get("BULK_THREAD_NUMBER", "1"))
 BULK_DOCUMENT_PATH = os.path.join(tempfile.gettempdir(), "bulkDocuments")
@@ -297,6 +307,17 @@ class Payload:
     _partitions = []
     _synchronized_partitions = []
 
+    """
+    _licenses: Lists of OTDS Licenses to be added to a resource.
+    Each element is a dict with these keys:
+    - enabled (bool, optional, default = True)
+    - path (str, mandatory)
+    - product_name (str, mandatory)
+    - resource (str, mandatory)
+    - description (str, optional)
+    """
+    _licenses = []
+
     """
     _oauth_clients: List of OTDS OAuth Clients. Each element
     is a dict with these keys:
@@ -419,7 +440,7 @@ class Payload:
     _admin_settings_post = []
 
     """
-    exec_pod_commands: list of commands to be executed in the pods
+    _exec_pod_commands: List of commands to be executed in the pods.
     list elements need to be dicts with pod name, command, etc.
     - enabled (bool, optional, default = True)
     - command (str, mandatory)
@@ -430,14 +451,30 @@ class Payload:
     _exec_pod_commands = []
 
     """
-    exec_pod_commands: list of commands to be executed
-    list elements need to be dicts with pod name, command, etc.
+    _exec_commands: List of commands to be executed in the customizer pod (as local process).
+    Each list element need to be a dict with these keys:
     - enabled (bool, optional, default = True)
     - command (str, mandatory)
     - description (str, optional)
     """
     _exec_commands = []
 
+    """
+    _exec_database_commands: list of database command sets to be executed.
+    Each list is a dict with these keys:
+    - enabled (bool, optional, default = True)
+    - db_connection (dict, mandatory) - supported dictionary keys:
+        - db_name (str, mandatory) - name of the database
+        - db_hostname (str, mandatory) - hostname of the database server
+        - db_port (int, optional) - port to communicate to the database server; default is 5432
+        - db_username (str, mandatory) - username
+        - db_password (str, mandatory) - password
+    - db_commands (list, mandatory) - each list item is a dictionary with these keys:
+        - command (str, mandatory) - needs to have %s paceholder for each parameter
+        - params (list, optional) - parameter values to be inserted into the %s postions in the command
+    """
+    _exec_database_commands = []
+
     """
     external_systems (list): List of external systems.
     Each element is a dict with these keys:
@@ -706,20 +743,35 @@ class Payload:
     automated via the web user interface. Each element is a dict with these keys:
     - enabled (bool, optional, default = True)
     - name (str, mandatory)
+    - description (str, optional)
     - base_url (str, mandatory)
     - user_name (str, optional)
     - password (str, optional)
-    - automations (list, mandatory)
-      * type (str, optional, default = "")
-      * page (str, optional, default = "")
-      * elem (str, optional, default = "")
-      * find (str, optional, default = "id")
-      * value (str, optional, default = "")
-    - wait-time (float, optional, default = 15.0) - wati time in seconds
+    - wait_time (float, optional, default = 15.0) - wait time in seconds
+    - wait_until (str, optional) - the page load / navigation `wait until` strategy. Possible values: `load`, `networkidle`, `domcontentloaded`
     - debug (bool, optional, default = False) - if True take screenshots and save to container
+    - automations (list, mandatory)
+      * type (str, optional, default = "") - possible types: `login`, `get_page`, `click_elem`, `set_elem`, `check_elem`
+      * page (str, optional, default = "") - the page-specific part of the URL. Will be concatenated with the `base_url`
+      * selector (str, optional, default = "")
+      * selector_type (str, optional, default = "id") - the find strategy - either `id`, `name`, `css`, `xpath`, `role`, `text`
+      * role_type (str, optional, default = "") - the ARIA role of an element. Only relevant for selector_type = `role`.
+      * value (str, optional, default = "") - the new value of element. Relevant for type = `set_elem`.
+      * user_field (str, optional, default = "") - the name of the HTML field holding the user name - only for type `login`.
+      * password_field (str, optional, default = "") - the name of the HTML field holding the password - only for type `login`.
+      * wait_until (str, optional, default = "") - an automation-step specific value for `wait_until` (see above)
+      * volume (int, optional, default = 141 (Enterprise Volume)) - the OTCS volume ID. Only relevant for type = `get_page`.
+      * path (list), optional, default = []) - a top-down list of folder / workspace names. Only relevant for type = `get_page`.
+      * navigation (bool, optional, default = False) - whether or not the click issues a nvigation event. Relevant only for type = `click_elem`.
+      * checkbox_state (bool, optional, default = None) - defines the required state of a checkbox element (True = checked, False = unchecked)
+      * attribute (str, optional, default = "") - the attribute name of an HTML element. Relevant only for type = `check_elem`.
+      * substring (bool, optional, default = False) - with or not a string comparison should consider substrings. Relevant only for type = `check_elem`.
+      * min_count (int, optional, default = 1) - defines how many elements should be found at a minimum by type = `check_elem`.
+      * want_exist (bool, optional, default = True) - defines for type = `check_elem` if the existence or non-existence should be checked.
     """
     _browser_automations = []
     _browser_automations_post = []
+    _test_automations = []
 
     """
     _security_clearances: List of Security Clearances. Each element is a dict with these keys:
@@ -1149,11 +1201,11 @@ class Payload:
 
     _transport_extractions: list = []
     _transport_replacements: list = []
-    _otawpsection = []
+    _appworks_configurations = []
 
     _avts_repositories: list = []
 
-    _feme: list = []
+    _embeddings: list = []
 
     # Disable Status files
     upload_status_files: bool = True
@@ -1175,6 +1227,7 @@ class Payload:
         browser_automation_object: BrowserAutomation | None,
         placeholder_values: dict,
         log_header_callback: Callable,
+        browser_headless: bool = True,
         stop_on_error: bool = False,
         aviator_enabled: bool = False,
         upload_status_files: bool = True,
@@ -1219,6 +1272,8 @@ class Payload:
                 A dictionary of placeholder values to be replaced in admin settings.
             log_header_callback:
                 Method to print a section break / header line into the log.
+            browser_headless (bool):
+                If true, the Browser for the Automation will be started in Headless mode (default)
             stop_on_error (bool):
                 This flag controls if transport deployment should stop
                 if a transport deployment in OTCS fails.
@@ -1263,6 +1318,7 @@ class Payload:
         self._nhc = None  # National Hurricane Center
         self._avts = avts_object
         self._browser_automation = browser_automation_object
+        self._browser_headless = browser_headless
         self._custom_settings_dir = custom_settings_dir
         self._placeholder_values = placeholder_values
         self._otcs_restart_callback = otcs_restart_callback
@@ -1372,6 +1428,7 @@ class Payload:
         self._webhooks_post = self.get_payload_section("webHooksPost")
         self._resources = self.get_payload_section("resources")
         self._partitions = self.get_payload_section("partitions")
+        self._licenses = self.get_payload_section("licenses")
         self._synchronized_partitions = self.get_payload_section(
             "synchronizedPartitions",
         )
@@ -1390,6 +1447,8 @@ class Payload:
         self._admin_settings_post = self.get_payload_section("adminSettingsPost")
         self._exec_pod_commands = self.get_payload_section("execPodCommands")
         self._exec_commands = self.get_payload_section("execCommands")
+        self._kubernetes = self.get_payload_section("kubernetes")
+        self._exec_database_commands = self.get_payload_section("execDatabaseCommands")
         self._external_systems = self.get_payload_section("externalSystems")
         self._transport_packages = self.get_payload_section("transportPackages")
         self._content_transport_packages = self.get_payload_section(
@@ -1440,9 +1499,11 @@ class Payload:
         self._browser_automations_post = self.get_payload_section(
             "browserAutomationsPost",
         )
-        self._otawpsection = self.get_payload_section("platformCustomConfig")
+        self._test_automations = self.get_payload_section("testAutomations")
+        self._appworks_configurations = self.get_payload_section("appworks")
         self._avts_repositories = self.get_payload_section("avtsRepositories")
-        self._feme = self.get_payload_section("feme")
+        self._avts_questions = self.get_payload_section("avtsQuestions")
+        self._embeddings = self.get_payload_section("embeddings")
 
         return self._payload
 
@@ -1526,319 +1587,695 @@ class Payload:
 
     # end method definition
 
-    def ot_awp_create_project(self) -> bool:
-        """Initiate the configuration of AppWorks projects.
+    def process_appworks_configurations(self, section_name: str = "appworks") -> bool:
+        """Process the configurations for AppWorks projects.
 
         This method is responsible for setting up the necessary configurations for AppWorks projects.
-        If the payload contains a `platformCustomConfig` section, it will execute the corresponding actions
+        If the payload contains a `appworks` section, it will execute the corresponding actions
         to process and apply the custom configuration.
 
+        Args:
+            section_name (str, optional):
+                The name of the payload section. It can be overridden
+                for cases where multiple sections of same type
+                are used (e.g. the "Post" sections).
+                This name is also used for the "success" status
+                files written to the Admin Personal Workspace.
+
         Returns:
-            bool: `True` on success, `False` on failure.
+            bool:
+                True, if payload has been processed without errors, False otherwise.
 
         """
 
-        for value in self._otawpsection.values():
-            if value.get("resourceConfig"):
-                resource_name = value["organization"]
-                access_role_name = "Access to " + resource_name
-                awp_resource = self._otds.get_resource(resource_name)
+        if not self._appworks_configurations:
+            self.logger.info(
+                "Payload section -> '%s' is empty. Skipping...",
+                section_name,
+            )
+            return True
 
-                if not awp_resource:
-                    self.logger.info(
-                        "OTDS resource -> '%s' for AppWorks Platform does not yet exist. Creating...",
-                        resource_name,
-                    )
-                    awp_resource = self._otds.add_resource(
-                        name=resource_name,
-                        description="AppWorks Platform",
-                        display_name="AppWorks Platform",
-                        additional_payload=self.appworks_resource_payload(
-                            resource_name,
-                            self._otawp.username(),
-                            self._otawp.password(),
-                        ),
-                    )
-                else:
-                    self.logger.info(
-                        "OTDS resource -> '%s' for AppWorks Platform does already exist.",
-                        resource_name,
-                    )
+        # If this payload section has been processed successfully before we
+        # can return True and skip processing it once more:
+        if self.check_status_file(payload_section_name=section_name):
+            return True
 
-                awp_resource_id = awp_resource["resourceID"]
+        success: bool = True
 
-                # Loop to wait for OTCS to create its OTDS user partition:
-                otcs_partition = self._otds.get_partition(
-                    self._otawp.otcs_partition_name(),
-                    show_error=False,
+        #
+        # 1: Loop to create the required OTDS resources for the AppWorks organization:
+        #
+        for appworks_configuration in self._appworks_configurations:
+            organization = appworks_configuration.get("organization", None)
+            if not organization:
+                self.logger.error("AppWorks configuration is missing the organization name! Skipping...")
+                success = False
+                continue
+
+            self._log_header_callback(
+                text="Process AppWorks resource configuration for '{}'".format(organization), char="-"
+            )
+
+            # Check if user has been explicitly disabled in payload
+            # (enabled = false). In this case we skip the element:
+            if not appworks_configuration.get("enabled", True):
+                self.logger.info(
+                    "Payload for AppWorks configuration -> '%s' is disabled. Skipping...",
+                    organization,
                 )
-                while otcs_partition is None:
-                    self.logger.warning(
-                        "OTDS user partition for Content Server with name -> '%s' does not exist yet. Waiting...",
-                        self._otawp.otcs_partition_name(),
-                    )
+                continue
 
-                    time.sleep(30)
-                    otcs_partition = self._otds.get_partition(
-                        self._otawp.otcs_partition_name(),
-                        show_error=False,
-                    )
+            if not appworks_configuration.get("resource_config", False):
+                self.logger.info("AppWorks resource configuration is disabled for -> '%s'. Skipping...", organization)
+                continue
 
-                # Add the OTDS user partition for OTCS to the AppWorks Platform Access Role in OTDS.
-                # This will effectvely sync all OTCS users with AppWorks Platform:
-                self._otds.add_partition_to_access_role(
-                    access_role_name,
-                    self._otawp.otcs_partition_name(),
+            access_role_name = "Access to " + organization
+
+            # make sure code is idempotent and only try to add ressource if it doesn't exist already:
+            awp_resource = self._otds.get_resource(organization)
+            if not awp_resource:
+                self.logger.info(
+                    "OTDS resource -> '%s' for AppWorks Platform does not yet exist. Creating...",
+                    organization,
+                )
+                awp_resource = self._otds.add_resource(
+                    name=organization,
+                    description="AppWorks Platform - {}".format(organization),
+                    display_name="AppWorks Platform - {}".format(organization),
+                    additional_payload=OTAWP.resource_payload(
+                        org_name=organization,
+                        username=self._otawp.username(),
+                        password=self._otawp.password(),
+                    ),
+                )
+            else:
+                self.logger.info(
+                    "OTDS resource -> '%s' for AppWorks Platform does already exist.",
+                    organization,
                 )
 
-                # Add the OTDS admin partition to the AppWorks Platform Access Role in OTDS.
-                self._otds.add_partition_to_access_role(
-                    access_role_name,
-                    self._otawp.otds_admin_partition_mame(),
+            awp_resource_id = awp_resource["resourceID"]
+
+            self.logger.info(
+                "AppWorks Platform organization -> '%s' got OTDS resource ID -> %s",
+                organization,
+                awp_resource_id,
+            )
+
+            # Loop to wait for OTCS to create its OTDS user partition:
+            otcs_partition = self._otds.get_partition(
+                self._otcs.partition_name(),
+                show_error=False,
+            )
+            while otcs_partition is None:
+                self.logger.warning(
+                    "OTDS user partition -> '%s' for Content Server does not exist yet. Waiting...",
+                    self._otcs.partition_name(),
                 )
 
-                # Set Group inclusion for Access Role for OTAWP to "True":
-                self._otds.update_access_role_attributes(
-                    access_role_name,
-                    [{"name": "pushAllGroups", "values": ["True"]}],
+                time.sleep(30)
+                otcs_partition = self._otds.get_partition(
+                    self._otcs.partition_name(),
+                    show_error=False,
                 )
 
-                # Add ResourceID User to OTDSAdmin to allow push
-                self._otds.add_user_to_group(
-                    user=str(awp_resource_id) + "@otds.admin",
-                    group="otdsadmins@otds.admin",
+            # Add the OTDS user partition for OTCS to the AppWorks Platform Access Role in OTDS.
+            # This will effectvely sync all OTCS users with AppWorks Platform:
+            self._otds.add_partition_to_access_role(
+                access_role=access_role_name,
+                partition=self._otcs.partition_name(),
+            )
+
+            # Add the OTDS admin partition to the AppWorks Platform Access Role in OTDS.
+            self._otds.add_partition_to_access_role(
+                access_role=access_role_name,
+                partition=self._otds.admin_partition_name(),
+            )
+
+            # Set Group inclusion for Access Role for OTAWP to "True":
+            self._otds.update_access_role_attributes(
+                name=access_role_name,
+                attribute_list=[{"name": "pushAllGroups", "values": ["True"]}],
+            )
+
+            # Add ResourceID User to 'otdsadmins' group to allow push
+            self._otds.add_user_to_group(
+                user=str(awp_resource_id) + "@otds.admin",
+                group="otdsadmins@otds.admin",
+            )
+
+            # Allow impersonation for all users:
+            self._otds.impersonate_resource(organization)
+
+            # Editing configmap
+            config_map = self._k8s.get_config_map(config_map_name=self._otawp.config_map_name())
+            if not config_map:
+                self.logger.error(
+                    "Failed to retrieve AppWorks Kubernetes config map -> '%s'",
+                    self._otawp.config_map_name(),
+                )
+                success = False
+            else:
+                self.logger.info(
+                    "Update Kubernetes config map for AppWorks organization -> '%s' with OTDS resource IDs...",
+                    organization,
+                )
+                solution = yaml.safe_load(
+                    config_map.data[organization + ".yaml"],
                 )
 
-                # Allow impersonation for all users:
-                self._otds.impersonate_resource(resource_name)
+                solution["platform"]["organizations"][organization]["otds"]["resourceId"] = awp_resource_id
+                solution["platform"]["organizations"][organization]["database"]["connections"]["sysConnection"][
+                    "connectionString"
+                ] = "jdbc:postgresql://${DATABASE_HOST}:${DATABASE_PORT}/${DATABASE_NAME}"
 
-                # Editing configmap
-                config_map = self._k8s.get_config_map(config_map_name=self._otawp.config_map_name())
-                if not config_map:
-                    self.logger.error(
-                        "Failed to retrieve AppWorks Kubernetes Config Map -> %s",
-                        self._otawp.config_map_name(),
+                solution["platform"]["organizations"][organization]["database"]["connections"]["sysConnection"][
+                    "database"
+                ] = "${DATABASE_NAME}"
+
+                solution["platform"]["organizations"][organization]["database"]["connections"]["sysConnection"][
+                    "password"
+                ] = "${DATABASE_PASSWORD}"
+
+                solution["platform"]["organizations"][organization]["content"]["ContentServer"]["contentServerUrl"] = (
+                    self._otcs.cs_url()
+                )
+                solution["platform"]["organizations"][organization]["content"]["ContentServer"][
+                    "contentServerSupportDirectoryUrl"
+                ] = self._otcs.cs_support_url()
+                solution["platform"]["organizations"][organization]["content"]["ContentServer"]["otdsResourceId"] = (
+                    self._otcs.resource_id()
+                )
+                solution["platform"]["organizations"][organization]["authenticators"]["OTDSAuth"]["publicLoginUrl"] = (
+                    self._otds.base_url() + "/otdsws/login"
+                )
+
+                config_map.data[organization + ".yaml"] = yaml.dump(solution)
+                result = self._k8s.replace_config_map(
+                    config_map_name=self._otawp.config_map_name(),
+                    config_map_data=config_map.data,
+                )
+                if result:
+                    self.logger.info(
+                        "Successfully updated AppWorks solution YAML for organization -> '%s'.",
+                        organization,
                     )
                 else:
-                    self.logger.info(
-                        "Update '%s' Kubernetes Config Map with OTDS resource IDs...",
-                        resource_name,
-                    )
-                    solution = yaml.safe_load(
-                        config_map.data[resource_name + ".yaml"],
-                    )
-
-                    solution["platform"]["organizations"][resource_name]["otds"]["resourceId"] = awp_resource_id
-
-                    solution["platform"]["organizations"][resource_name]["database"]["connections"]["sysConnection"][
-                        "connectionString"
-                    ] = "jdbc:postgresql://${DATABASE_HOST}:${DATABASE_PORT}/${DATABASE_NAME}"
-
-                    solution["platform"]["organizations"][resource_name]["database"]["connections"]["sysConnection"][
-                        "database"
-                    ] = "${DATABASE_NAME}"
-
-                    solution["platform"]["organizations"][resource_name]["database"]["connections"]["sysConnection"][
-                        "password"
-                    ] = "${DATABASE_PASSWORD}"
-
-                    solution["platform"]["organizations"][resource_name]["content"]["ContentServer"][
-                        "contentServerUrl"
-                    ] = f"{self._otawp.otcs_url()!s}{self._otawp.otcs_base_path()}"
-                    solution["platform"]["organizations"][resource_name]["content"]["ContentServer"][
-                        "contentServerSupportDirectoryUrl"
-                    ] = f"{self._otawp.otcs_url()!s}/cssupport"
-                    solution["platform"]["organizations"][resource_name]["content"]["ContentServer"][
-                        "otdsResourceId"
-                    ] = self._otawp.otcs_resource_id()
-                    solution["platform"]["organizations"][resource_name]["authenticators"]["OTDSAuth"][
-                        "publicLoginUrl"
-                    ] = f"{self._otawp.otds_url()!s}" + "/otdsws/login"
-
-                    config_map.data[resource_name + ".yaml"] = yaml.dump(solution)
-                    result = self._k8s.replace_config_map(
-                        config_map_name=self._otawp.config_map_name(),
-                        config_map_data=config_map.data,
-                    )
-                    if result:
-                        self.logger.info(
-                            "Successfully updated '%s' Solution YAML.",
-                            resource_name,
-                        )
-                    else:
-                        self.logger.error(
-                            "Failed to update '%s' Solution YAML.",
-                            resource_name,
-                        )
-                    self.logger.debug(
-                        "Solution YAML for '%s' -> %s",
-                        resource_name,
-                        solution,
-                    )
-                # Add SPS license for OTAWP
-                license_name = self._otawp.product_name()
-                product_name = self._otawp.product_name() + "_" + resource_name.upper()
-                product_description = self._otawp.product_name() + resource_name
-                if os.path.isfile(self._otawp.license_file()):
-                    self.logger.info(
-                        "Found OTAWP license file -> '%s', assiging it to ressource -> '%s'...",
-                        self._otawp.license_file(),
-                        resource_name,
+                    self.logger.error(
+                        "Failed to update AppWorks solution YAML for organization -> '%s'!",
+                        organization,
                     )
+                self.logger.debug(
+                    "Solution YAML for Appworks organization -> '%s': %s",
+                    organization,
+                    solution,
+                )
+            # Add SPS license for OTAWP
+            license_name = self._otawp.product_name()
+            product_name = self._otawp.product_name() + "_" + organization.upper()
+            product_description = self._otawp.product_name() + organization
+            if os.path.isfile(self._otawp.license_file()):
+                self.logger.info(
+                    "Found OTAWP license file -> '%s', assiging it to OTDS resource -> '%s'...",
+                    self._otawp.license_file(),
+                    organization,
+                )
 
-                    otawp_license = self._otds.add_license_to_resource(
+                otawp_license = self._otds.add_license_to_resource(
+                    path_to_license_file=self._otawp.license_file(),
+                    product_name=product_name,
+                    product_description=product_description,
+                    resource_id=awp_resource["resourceID"],
+                )
+                if not otawp_license:
+                    self.logger.error(
+                        "Couldn't apply license -> '%s' for product -> '%s' to OTDS resource -> '%s'",
                         self._otawp.license_file(),
                         product_name,
-                        product_description,
                         awp_resource["resourceID"],
                     )
-                    if not otawp_license:
-                        self.logger.error(
-                            "Couldn't apply license -> '%s' for product -> '%s' to OTDS resource -> '%s'",
-                            self._otawp.license_file(),
-                            product_name,
-                            awp_resource["resourceID"],
-                        )
-                    else:
+                else:
+                    self.logger.info(
+                        "Successfully applied license -> '%s' for product -> '%s' to OTDS resource -> '%s'",
+                        self._otawp.license_file(),
+                        product_name,
+                        awp_resource["resourceID"],
+                    )
+
+                # Assign AppWorks license to Content Server Members Partiton and otds.admin:
+                for partition_name in ["otds.admin", self._otcs.partition_name()]:
+                    if self._otds.is_partition_licensed(
+                        partition_name=partition_name,
+                        resource_id=awp_resource["resourceID"],
+                        license_feature="USERS",
+                        license_name=license_name,
+                    ):
                         self.logger.info(
-                            "Successfully applied license -> '%s' for product -> '%s' to OTDS resource -> '%s'",
-                            self._otawp.license_file(),
+                            "Partition -> '%s' is already licensed for -> '%s' (%s)",
+                            partition_name,
                             product_name,
-                            awp_resource["resourceID"],
+                            "USERS",
                         )
-
-                    # Assign AppWorks license to Content Server Members Partiton and otds.admin:
-                    for partition_name in ["otds.admin", self._otawp.otcs_partition_name()]:
-                        if self._otds.is_partition_licensed(
+                    else:
+                        assigned_license = self._otds.assign_partition_to_license(
                             partition_name=partition_name,
                             resource_id=awp_resource["resourceID"],
                             license_feature="USERS",
                             license_name=license_name,
-                        ):
-                            self.logger.info(
-                                "Partition -> '%s' is already licensed for -> '%s' (%s)",
+                        )
+                        if not assigned_license:
+                            self.logger.error(
+                                "Partition -> '%s' could not be assigned to license -> '%s' (%s)",
                                 partition_name,
                                 product_name,
                                 "USERS",
                             )
+                            success = False
                         else:
-                            assigned_license = self._otds.assign_partition_to_license(
+                            self.logger.info(
+                                "Partition -> '%s' successfully assigned to license -> '%s' (%s)",
                                 partition_name,
-                                awp_resource["resourceID"],
+                                product_name,
                                 "USERS",
-                                license_name,
                             )
-                            if not assigned_license:
-                                self.logger.error(
-                                    "Partition -> '%s' could not be assigned to license -> '%s' (%s)",
-                                    partition_name,
-                                    product_name,
-                                    "USERS",
-                                )
-                            else:
-                                self.logger.info(
-                                    "Partition -> '%s' successfully assigned to license -> '%s' (%s)",
-                                    partition_name,
-                                    product_name,
-                                    "USERS",
-                                )
+                # end for partition_name in ["otds.admin", self._otcs.partition_name()]:
+            # end if os.path.isfile(self._otawp.license_file()):
+
+            self.logger.info("Restart AppWorks Kubernetes stateful set -> '%s'", self._otawp.hostname())
+
+            self._k8s.restart_stateful_set(sts_name=self._otawp.hostname(), force=True, wait=True)
+
+            self._otawp.set_organization(organization)
+            otawp_cookie = self._otawp.authenticate(revalidate=True)
+            if not otawp_cookie:
+                self.logger.error(
+                    "Authentication at AppWorks failed. Cannot proceed with processing of AppWorks configuration -> '%s'",
+                    organization,
+                )
+                success = False
+                continue
+            self._otawp.create_cws_config(
+                partition=self._otcs.partition_name(), resource_name=organization, otcs_url=self._otcs.cs_url()
+            )
+            self._otawp.assign_role_to_user(
+                organization=organization, user_name=self._otawp.username(), role_name="Developer"
+            )
+        # end for appworks_configuration in self._appworks_configurations:
+
+        #
+        # 2: Loop to create the AppWorks workspaces, projects, and entities:
+        #
+        for appworks_configuration in self._appworks_configurations:
+            organization = appworks_configuration.get("organization", None)
+            if not organization:
+                self.logger.error("AppWorks configuration is missing the organization name! Skipping...")
+                success = False
+                continue
 
-                self.logger.info("Scale AppWorks Kubernetes Stateful Set to 0...")
-                self._k8s.scale_stateful_set(
-                    sts_name=self._otawp.hostname(),
-                    scale=0,
+            # Check if user has been explicitly disabled in payload
+            # (enabled = false). In this case we skip the element:
+            if not appworks_configuration.get("enabled", True):
+                self.logger.info(
+                    "Payload for AppWorks configuration -> '%s' is disabled. Skipping...",
+                    organization,
                 )
+                continue
 
-                is_pod_deleted = self._k8s.verify_pod_deleted(pod_name="appworks-0")
-                if is_pod_deleted is False:
-                    return False
+            self._log_header_callback(
+                text="Process AppWorks workspaces, project, entities for '{}'".format(organization), char="-"
+            )
 
-                self.logger.info("Scale AppWorks Kubernetes Stateful Set to 1...")
-                self._k8s.scale_stateful_set(
-                    sts_name=self._otawp.hostname(),
-                    scale=1,
+            self._otawp.set_organization(organization)
+            otawp_cookie = self._otawp.authenticate(revalidate=True)
+            if not otawp_cookie:
+                self.logger.error(
+                    "Authentication at AppWorks failed. Cannot proceed with processing of AppWorks configutation -> '%s'!",
+                    organization,
                 )
+                success = False
+                continue
 
-                ispod_running = self._k8s.verify_pod_status(pod_name="appworks-0")
-                if ispod_running is False:
-                    return False
+            if "workspaces" not in appworks_configuration:
+                self.logger.warning(
+                    "Missing workspace information in AppWorks configuration -> '%s'. Skipping...", organization
+                )
+                continue
 
-                self._otawp.authenticate(revalidate=False)
-                self._otawp.set_organization(resource_name)
-                self._otawp.create_cws_config(self._otawp.otcs_partition_name(), resource_name, self._otawp.otcs_url())
-                self._otawp.assign_developer_role_to_user(resource_name, self._otawp.username(), "Developer")
-
-        for value in self._otawpsection.values():
-            if "cws" in value and "workspaces" in value["cws"]:
-                for workspace in value["cws"]["workspaces"]:
-                    workspace_gui_id = workspace["workspaceGuiID"]
-                    workspace_name = workspace["name"]
-                    workspace_path = workspace["path"]
-                    organization = value["organization"]
-                    self._otawp.set_organization(organization)
-                    if workspace_gui_id and workspace_name and workspace_path:
-                        ispod_running = self._k8s.verify_pod_status(
-                            pod_name="appworks-0",
-                        )
-                        if ispod_running is False:
-                            return False
-                        self._otawp.authenticate(revalidate=False)
-                        respose = self._otawp.create_workspace_with_retry(
-                            workspace_name=workspace_name,
-                            workspace_gui_id=workspace_gui_id,
-                        )
-                        if not self._otawp.validate_workspace_response(
-                            respose,
-                            workspace_name,
-                        ):
-                            return False
-                        if not self._otawp.is_workspace_already_exists(
-                            respose,
-                            workspace_name,
-                        ):
-                            self._otawp.sync_workspace(
+            for workspace in appworks_configuration["workspaces"]:
+                workspace_id = workspace.get("workspace_id", None)
+                workspace_name = workspace.get("name", None)
+                workspace_path = workspace.get("path", None)
+                if not workspace_id or not workspace_name or not workspace_path:
+                    self.logger.error(
+                        "AppWorks workspace configuration for -> '%s'%s requires 'workspace_id', 'name', and 'path' settings. Skipping...",
+                        organization,
+                        " (workspace name -> {})".format(workspace_name) if workspace_name else "",
+                    )
+                    success = False
+                    continue
+
+                response, created = self._otawp.create_workspace(
+                    workspace_name=workspace_name, workspace_id=workspace_id
+                )
+                if not response:
+                    self.logger.info("Failed to create workspace -> '%s' (%s)", workspace_name, workspace_id)
+                    success = False
+                    continue
+
+                if created:
+                    self.logger.info("Setup new workspace -> '%s' (%s)...", workspace_name, workspace_id)
+                    response = self._otawp.sync_workspace(
+                        workspace_name=workspace_name,
+                        workspace_id=workspace_id,
+                    )
+                    if not response:
+                        self.logger.error("Failed to synchronize workspace -> '%s' (%s)", workspace_name, workspace_id)
+                        success = False
+                        continue
+                    self.logger.info(
+                        "Copy projects artifacts to workspace -> '%s' (%s) in AppWorks pod -> '%s'...",
+                        workspace_name,
+                        workspace_id,
+                        "appworks-0",
+                    )
+                    self._k8s.exec_pod_command(
+                        pod_name="appworks-0",
+                        command=[
+                            "/bin/sh",
+                            "-c",
+                            f'cp -r "{workspace_path}/"* "/opt/appworks/cluster/shared/cws/sync/{organization}/{workspace_name}"',
+                        ],
+                        timeout=600,
+                    )
+                    self.logger.info(
+                        "Copying of projects artifacts to workspace -> '%s' (%s) completed.",
+                        workspace_name,
+                        workspace_id,
+                    )
+                self.logger.info("Re-sync existing workspace -> '%s' (%s)...", workspace_name, workspace_id)
+                response = self._otawp.sync_workspace(
+                    workspace_name=workspace_name,
+                    workspace_id=workspace_id,
+                )
+                if not response:
+                    self.logger.error("Failed to synchronize workspace -> '%s' (%s)", workspace_name, workspace_id)
+                    success = False
+                    continue
+
+                if "projects" in workspace:
+                    for project in workspace["projects"]:
+                        if project.get("name") and project.get("documentId"):
+                            if not self._otawp.publish_project(
                                 workspace_name=workspace_name,
-                                workspace_id=workspace_gui_id,
-                            )
-                            self.logger.info(
-                                "Start copying of projects to workspace...",
+                                workspace_id=workspace_id,
+                                project_name=project.get("name"),
+                                project_id=project.get("documentId"),
+                            ):
+                                success = False
+                                continue
+                        else:
+                            self.logger.error(
+                                "Skipping project -> '%s' due to missing required project fields 'name' or 'documentId'.",
+                                project.get("name"),
                             )
-                            self._k8s.exec_pod_command(
-                                pod_name="appworks-0",
-                                command=[
-                                    "/bin/sh",
-                                    "-c",
-                                    f'cp -r "{workspace_path}/"* "/opt/appworks/cluster/shared/cws/sync/system/{workspace_name}"',
-                                ],
+                            success = False
+                            continue
+                    # end for project in workspace["projects"]:
+                # end if "projects" in workspace
+            # end for workspace in value["cws"]["workspaces"]
+
+            # Process the entities in the payload:
+            entities = appworks_configuration.get("entities", [])
+            if entities:
+                self._log_header_callback(
+                    text="Process AppWorks entities for organization -> '{}'".format(organization), char="-"
+                )
+                for entity in entities:
+                    if not self.process_appworks_entity(entity=entity):
+                        success = False
+                self.logger.info("Entity processing completed for organization -> '%s'.", organization)
+        # end for appworks_configuration in self._appworks_configurations:
+
+        self.write_status_file(
+            success=success,
+            payload_section_name=section_name,
+            payload_section=self._appworks_configurations,
+        )
+
+        return success
+
+    # end method definition
+
+    def process_appworks_entity(self, entity: dict) -> bool:
+        """Process a single AppWorks entity payload.
+
+        Args:
+            entity (dict):
+                Entity payload.
+                Should have a selection of the following keys:
+                * type
+                * name
+                * description
+                * status
+                * prefix
+                * category
+                * priority
+                * customer
+                * case_type
+                * ...
+
+        Returns:
+            bool: True = success, False = failure.
+
+        """
+
+        entity_type = entity.get("type")
+        if not entity_type:
+            return False
+
+        match entity_type:
+            case "category":
+                cat = self._otawp.get_category_by_name(name=entity.get("name"))
+                if cat:
+                    cat_id = self._otawp.get_entity_value(entity=cat, key="id")
+                    self.logger.info(
+                        "Category -> '%s' (%s) does already exist. Skipping...", entity.get("name"), str(cat_id)
+                    )
+                    self.logger.debug("Category -> %s", str(cat))
+                else:
+                    response = self._otawp.create_category(
+                        case_prefix=entity.get("prefix"),
+                        name=entity.get("name"),
+                        description=entity.get("description", ""),
+                        status=entity.get("status", 1),
+                    )
+                    if not response or "Identity" not in response:
+                        self.logger.error("Failed to create category -> '%s'!", entity.get("name"))
+                        return False
+                    cat_id = response["Identity"].get("Id")
+                    self.logger.info(
+                        "Successfully created category -> '%s' (%s).",
+                        entity.get("name"),
+                        cat_id,
+                    )
+                    self.logger.debug("Response -> %s", str(response))
+                if "sub_entities" in entity:
+                    for sub_entity in entity["sub_entities"]:
+                        if sub_entity["type"] != "subCategory":
+                            self.logger.warning(
+                                "Found a category sub-entities with wrong type -> '%s'", sub_entity["type"]
                             )
-                            self.logger.info("Copying of projects to workspace completed.")
-                        self._otawp.sync_workspace(
-                            workspace_name=workspace_name,
-                            workspace_id=workspace_gui_id,
+                            continue
+                        response = self._otawp.create_sub_category(
+                            parent_id=cat_id,
+                            name=sub_entity.get("name"),
+                            description=sub_entity.get("description", ""),
+                            status=sub_entity.get("status", 1),
+                        )
+                        if not response or "Identity" not in response:
+                            self.logger.error("Failed to create sub-category -> '%s'!", sub_entity.get("name"))
+                            return False
+                        self.logger.info(
+                            "Successfully created sub-category -> '%s' (%s) in parent category -> '%s' (%s).",
+                            sub_entity.get("name"),
+                            response["Identity"].get("Id"),
+                            entity.get("name"),
+                            cat_id,
+                        )
+                        self.logger.debug("Response -> %s", str(response))
+                return True
+            case "priority":
+                priority = self._otawp.get_priority_by_name(name=entity.get("name"))
+                if priority:
+                    priority_id = self._otawp.get_entity_value(entity=priority, key="id")
+                    (
+                        self.logger.info(
+                            "Priority -> '%s' (%s) does already exist. Skipping...",
+                            entity.get("name"),
+                            str(priority_id),
                         )
+                    )
+                    return True
+                response = self._otawp.create_priority(
+                    name=entity.get("name"),
+                    description=entity.get("description", ""),
+                    status=entity.get("status", 1),
+                )
+                if not response or "Identity" not in response:
+                    self.logger.error("Failed to create priority -> '%s'!", entity.get("name"))
+                    return False
+                self.logger.info(
+                    "Successfully created priority -> '%s' (%s).", entity.get("name"), response["Identity"].get("Id")
+                )
+                self.logger.debug("Response -> %s", str(response))
+                return True
+            case "caseType":
+                case_type = self._otawp.get_case_type_by_name(name=entity.get("name"))
+                if case_type:
+                    case_type_id = self._otawp.get_entity_value(entity=case_type, key="id")
+                    self.logger.info(
+                        "Case type -> '%s' (%s) does already exist. Skipping...", entity.get("name"), str(case_type_id)
+                    )
+                    return True
+                response = self._otawp.create_case_type(
+                    name=entity.get("name"),
+                    description=entity.get("description", ""),
+                    status=entity.get("status", 1),
+                )
+                if not response or "Identity" not in response:
+                    self.logger.error("Failed to case type -> '%s'!", entity.get("name"))
+                    return False
+                self.logger.info(
+                    "Successfully created case type -> '%s' (%s).", entity.get("name"), response["Identity"].get("Id")
+                )
+                self.logger.debug("Response -> %s", str(response))
+                return True
+            case "customer":
+                customer = self._otawp.get_customer_by_name(name=entity.get("name"))
+                if customer:
+                    customer_id = self._otawp.get_entity_value(entity=case_type, key="id")
+                    self.logger.info(
+                        "Customer -> '%s' (%s) does already exist. Skipping...", entity.get("name"), str(customer_id)
+                    )
+                    return True
+                response = self._otawp.create_customer(
+                    customer_name=entity.get("name"),
+                    legal_business_name=entity.get("legal_business_name", ""),
+                    trading_name=entity.get("trading_name", ""),
+                )
+                if not response or "Identity" not in response:
+                    self.logger.error("Failed to create customer -> '%s'!", entity.get("name"))
+                    return False
+                self.logger.info(
+                    "Successfully created customer -> '%s' (%s).", entity.get("name"), response["Identity"].get("Id")
+                )
+                self.logger.debug("Response -> %s", str(response))
+                return True
+            case "case":
+                if "subject" not in entity:
+                    self.logger.error("Cannot create a case without a subject!")
+                    return False
 
-                        if "projects" in workspace:
-                            for project in workspace["projects"]:
-                                if project.get("name") and project.get("documentId"):
-                                    if not self._otawp.publish_project(
-                                        workspace_name=workspace_name,
-                                        project_name=project.get("name"),
-                                        workspace_id=workspace_gui_id,
-                                        project_id=project.get("documentId"),
-                                    ):
-                                        return False
-                                else:
-                                    self.logger.error(
-                                        "Skipping project -> '%s' due to missing required fields.",
-                                        project.get("name"),
-                                    )
+                category_name = entity.get("category")
+                if category_name:
+                    category = self._otawp.get_category_by_name(name=category_name)
+                    category_id = self._otawp.get_entity_value(entity=category, key="id")
+                    if not category_id:
+                        self.logger.error(
+                            "Cannot find case category -> '%s' to create case -> '%s'",
+                            category_name,
+                            entity["subject"],
+                        )
+                        return False
+                else:
+                    self.logger.warning(
+                        "Case entity -> '%s' does not have a category specified in its payload!", entity["subject"]
+                    )
+                    category_id = None
 
-                    else:
-                        self.logger.error("Skipping workspace -> '%s' due to missing required fields.", workspace_name)
+                sub_category_name = entity.get("sub_category")
+                if category_id and sub_category_name:
+                    sub_category_id = self._otawp.get_sub_category_id(name=sub_category_name, parent_id=category_id)
+                else:
+                    sub_category_id = None
 
-                self._otawp.create_loanruntime_from_config_file(platform=value)
+                priority_name = entity.get("priority")
+                if priority_name:
+                    priority = self._otawp.get_priority_by_name(name=priority_name)
+                    priority_id = self._otawp.get_entity_value(entity=priority, key="id")
+                    if not priority_id:
+                        self.logger.error(
+                            "Cannot find case priority -> '%s' to create case -> '%s'",
+                            priority_name,
+                            entity["subject"],
+                        )
+                        return False
+                else:
+                    self.logger.warning(
+                        "Case entity -> '%s' does not have a priority specified in its payload!", entity["subject"]
+                    )
+                    priority_id = None
 
-        return True
+                case_type_name = entity.get("case_type")
+                if case_type_name:
+                    case_type = self._otawp.get_case_type_by_name(name=case_type_name)
+                    case_type_id = self._otawp.get_entity_value(entity=case_type, key="id")
+                    if not case_type_id:
+                        self.logger.error(
+                            "Cannot find case type -> '%s' to create case -> '%s'!",
+                            case_type_name,
+                            entity["subject"],
+                        )
+                        return False
+                else:
+                    self.logger.warning(
+                        "Case entity -> '%s' does not have a case type specified in its payload!", entity["subject"]
+                    )
+                    case_type_id = None
+
+                customer_name = entity.get("customer")
+                if customer_name:
+                    customer = self._otawp.get_customer_by_name(name=customer_name)
+                    customer_id = self._otawp.get_entity_value(entity=customer, key="id")
+                    if not customer_id:
+                        self.logger.error(
+                            "Cannot find customer -> '%s' to create case -> '%s'!",
+                            customer_name,
+                            entity["subject"],
+                        )
+                        return False
+                else:
+                    self.logger.warning(
+                        "Case entity -> '%s' does not have a customer specified in its payload!", entity["subject"]
+                    )
+                    customer_id = None
+
+                response = self._otawp.create_case(
+                    subject=entity.get("subject"),
+                    description=entity.get("description", ""),
+                    loan_amount=entity.get("loan_amount", 1),
+                    loan_duration_in_months=entity.get("loan_duration_in_month", 2),
+                    category_id=category_id,
+                    sub_category_id=sub_category_id,
+                    priority_id=priority_id,
+                    case_type_id=case_type_id,
+                    customer_id=customer_id,
+                )
+                if not response:
+                    self.logger.error("Failed to create case with subject -> '%s'!", entity.get("subject"))
+                    return False
+                self.logger.info(
+                    "Successfully created case with subject -> '%s'%s.",
+                    entity.get("subject"),
+                    " for customer with ID -> '{}'".format(customer_id) if customer_id else "",
+                )
+                self.logger.debug("Response -> %s", str(response))
+                return True
+            case _:
+                self.logger.error("Illegal entity type -> '%s'!", entity_type)
+                return False
+
+        return False
 
     # end method definition
 
@@ -2627,6 +3064,9 @@ class Payload:
         )
         workspace_id = self._otcs.get_result_value(response=response, key="id")
         if workspace_id:
+            if not isinstance(workspace_id, int):
+                self.logger.warning("Converting workspace ID -> %s to integer...", str(workspace_id))
+                workspace_id = int(workspace_id)
             # Write nodeID back into the payload
             workspace["nodeId"] = workspace_id
             return workspace_id
@@ -2769,19 +3209,24 @@ class Payload:
                 continue
 
             match payload_section["name"]:
-                case "feme":
+                case "embeddings" | "feme":
                     self._log_header_callback(
-                        text="Process Feme for Content Aviator Metadata embedding",
+                        text="Process additional Embeddings for Content Aviator",
                     )
-                    self.process_feme()
+                    self.process_embeddings()
                 case "avtsRepositories":
                     self._log_header_callback(
                         text="Process Aviator Search repositories",
                     )
                     self.process_avts_repositories()
-                case "platformCustomConfig":
-                    self._log_header_callback(text="Process Create AppWorks workspaces")
-                    self.ot_awp_create_project()
+                case "avtsQuestions":
+                    self._log_header_callback(
+                        text="Process Aviator Search Sample Questions",
+                    )
+                    self.process_avts_questions()
+                case "appworks":
+                    self._log_header_callback(text="Process AppWorks Configurations")
+                    self.process_appworks_configurations()
                 case "webHooks":
                     self._log_header_callback(text="Process Web Hooks")
                     self.process_web_hooks(webhooks=self._webhooks)
@@ -2797,11 +3242,9 @@ class Payload:
                 case "partitions":
                     self._log_header_callback(text="Process OTDS Partitions")
                     self.process_partitions()
-                    self._log_header_callback(
-                        text="Assign OTCS Licenses to Partitions",
-                        char="-",
-                    )
-                    self.process_partition_licenses()
+                case "licenses":
+                    self._log_header_callback(text="Process OTDS Licenses")
+                    self.process_licenses()
                 case "synchronizedPartitions":
                     self._log_header_callback(
                         text="Process OTDS Synchronized Partitions",
@@ -2835,12 +3278,12 @@ class Payload:
                     # if the customizer pod is restarted / run multiple times:
                     self.process_group_placeholders()
                     if self._core_share and isinstance(self._core_share, CoreShare):
-                        self._log_header_callback(text="Process Core Share Groups")
+                        self._log_header_callback(text="Process Core Share Groups", char="-")
                         self.process_groups_core_share()
                     if self._m365 and isinstance(self._m365, M365):
-                        self._log_header_callback(text="Cleanup existing M365 Teams")
+                        self._log_header_callback(text="Cleanup existing M365 Teams", char="-")
                         self.cleanup_all_teams_m365()
-                        self._log_header_callback(text="Process M365 Groups")
+                        self._log_header_callback(text="Process M365 Groups", char="-")
                         self.process_groups_m365()
                 case "users":
                     self._log_header_callback(text="Process Users")
@@ -2860,46 +3303,25 @@ class Payload:
                     self.process_user_licenses(
                         resource_name=self._otcs.config()["resource"],
                         license_feature=self._otcs.config()["license"],
-                        license_name="EXTENDED_ECM",
                         user_specific_payload_field="licenses",
                     )
-                    self._log_header_callback(
-                        text="Assign OTIV licenses to users",
-                        char="-",
-                    )
-
-                    if (
-                        isinstance(self._otiv, OTIV)  # can be None in 24.1 or newer
-                        and self._otiv.config()
-                        and self._otiv.config()["resource"]
-                        and self._otiv.config()["license"]
-                    ):
-                        self.process_user_licenses(
-                            resource_name=self._otiv.config()["resource"],
-                            license_feature=self._otiv.config()["license"],
-                            license_name="INTELLIGENT_VIEWING",
-                            user_specific_payload_field="",
-                            section_name="userLicensesViewing",  # we need a specific name here for OTIV
-                        )
-                    else:
-                        self.logger.info("Processing of OTIV licenses is disabled.")
                     self._log_header_callback(
                         text="Process OTDS user settings",
                         char="-",
                     )
                     self.process_user_settings()
                     if self._core_share and isinstance(self._core_share, CoreShare):
-                        self._log_header_callback(text="Process Core Share users")
+                        self._log_header_callback(text="Process Core Share users", char="-")
                         self.process_users_core_share()
                     if self._m365 and isinstance(self._m365, M365):
-                        self._log_header_callback(text="Process M365 users")
+                        self._log_header_callback(text="Process M365 users", char="-")
                         self.process_users_m365()
                         # We need to do the MS Teams creation after the creation of
                         # the M365 users as we require Group Owners to create teams.
                         # Note: this is just for the teams of the top-level OTCS groups
                         # (departments), not the MS Teams for the Workspaces. These
                         # are created via the scheduled bots!
-                        self._log_header_callback(text="Process M365 Teams for departmental groups")
+                        self._log_header_callback(text="Process M365 Teams for departmental groups", char="-")
                         self.process_teams_m365()
                 case "adminSettings":
                     self._log_header_callback(
@@ -2937,9 +3359,15 @@ class Payload:
                 case "execPodCommands":
                     self._log_header_callback(text="Process Pod Commands")
                     self.process_exec_pod_commands()
+                case "kubernetes":
+                    self._log_header_callback(text="Process Kubernetes Commands")
+                    self.process_kubernetes()
                 case "execCommands":
-                    self._log_header_callback(text="Process execCommands")
+                    self._log_header_callback(text="Process Commands in Customizer Pod")
                     self.process_exec_commands()
+                case "execDatabaseCommands":
+                    self._log_header_callback(text="Process Database Commands")
+                    self.process_exec_database_commands()
                 case "csApplications":
                     self._log_header_callback(text="Process CS Apps (backend)")
                     self.process_cs_applications(
@@ -3209,6 +3637,11 @@ class Payload:
                         browser_automations=self._browser_automations_post,
                         section_name="browserAutomationsPost",
                     )
+                case "testAutomations":
+                    self._log_header_callback(text="Process Test Automations")
+                    self.process_browser_automations(
+                        browser_automations=self._test_automations, section_name="testAutomations"
+                    )
                 case "workspaceTypes":
                     if not self._workspace_types:
                         self._log_header_callback(text="Process Workspace Types")
@@ -3250,7 +3683,7 @@ class Payload:
             if self._salesforce and isinstance(self._salesforce, Salesforce):
                 self._log_header_callback("Process Salesforce User Profile Photos")
                 self.process_user_photos_salesforce()
-            if self._salesforce and isinstance(self._core_share, CoreShare):
+            if self._core_share and isinstance(self._core_share, CoreShare):
                 self._log_header_callback("Process Core Share User Profile Photos")
                 self.process_user_photos_core_share()
             self._log_header_callback("Process User Favorites and Profiles")
@@ -3526,34 +3959,33 @@ class Payload:
             response = self._otds.get_partition(name=partition_name, show_error=False)
             if response:
                 self.logger.info(
-                    "Synchronized partition -> '%s' does already exist. Skipping...",
+                    "Synchronized partition -> '%s' does already exist.",
                     partition_name,
                 )
-                continue
-
-            # Only continue if synchronized Partition does not exist already
-            self.logger.info(
-                "Synchronized partition -> '%s' does not yet exist. Creating...",
-                partition_name,
-            )
-
-            response = self._otds.add_synchronized_partition(
-                name=partition_name,
-                description=partition_description,
-                data=partition["spec"],
-            )
-            if response:
+            else:
+                # Only continue if synchronized Partition does not exist already
                 self.logger.info(
-                    "Added synchronized partition -> '%s' to OTDS.",
+                    "Synchronized partition -> '%s' does not yet exist. Creating...",
                     partition_name,
                 )
-            else:
-                self.logger.error(
-                    "Failed to add synchronized partition -> '%s' to OTDS!",
-                    partition_name,
+
+                response = self._otds.add_synchronized_partition(
+                    name=partition_name,
+                    description=partition_description,
+                    data=partition["spec"],
                 )
-                success = False
-                continue
+                if response:
+                    self.logger.info(
+                        "Added synchronized partition -> '%s' to OTDS.",
+                        partition_name,
+                    )
+                else:
+                    self.logger.error(
+                        "Failed to add synchronized partition -> '%s' to OTDS!",
+                        partition_name,
+                    )
+                    success = False
+                    continue
 
             result = self._otds.import_synchronized_partition_members(
                 name=partition_name,
@@ -3569,7 +4001,6 @@ class Payload:
                     partition_name,
                 )
                 success = False
-                continue
 
             access_role = partition.get("access_role")
             if access_role:
@@ -3590,7 +4021,6 @@ class Payload:
                         access_role,
                     )
                     success = False
-                    continue
             # end if access_role
 
             # Partions may have an optional list of licenses in
@@ -3608,11 +4038,54 @@ class Payload:
                     success = False
                     continue
                 otcs_resource_id = otcs_resource["resourceID"]
-                license_name = "EXTENDED_ECM"
-                for license_feature in partition_specific_licenses:
+                otcs_license_name = "EXTENDED_ECM"
+                for license_item in partition_specific_licenses:
+                    if isinstance(license_item, dict):
+                        license_feature = license_item.get("feature")
+                        license_name = license_item.get("name", "EXTENDED_ECM")
+                        if "enabled" in license_item and not license_item["enabled"]:
+                            self.logger.info(
+                                "Payload for License '%s' -> '%s' is disabled. Skipping...",
+                                license_name,
+                                license_feature,
+                            )
+                            continue
+                        if "resource" in license_item:
+                            try:
+                                resource_id = self._otds.get_resource(name=license_item["resource"])["resourceID"]
+                            except Exception:
+                                self.logger.error(
+                                    "Error getting resourceID from resource -> %s", license_item["resource"]
+                                )
+                        else:
+                            resource_id = otcs_resource_id
+
+                    elif isinstance(license_item, str):
+                        license_feature = license_item
+                        resource_id = otcs_resource_id
+                        license_name = otcs_license_name
+                    else:
+                        self.logger.error("Invalid License feature specified -> %s", license_item)
+                        success = False
+                        continue
+
+                    if self._otds.is_partition_licensed(
+                        partition_name=partition_name,
+                        resource_id=resource_id,
+                        license_feature=license_feature,
+                        license_name=license_name,
+                    ):
+                        self.logger.info(
+                            "Partition -> '%s' is already licensed for -> '%s' (%s)",
+                            partition_name,
+                            license_name,
+                            license_feature,
+                        )
+                        continue
+
                     assigned_license = self._otds.assign_partition_to_license(
                         partition_name=partition_name,
-                        resource_id=otcs_resource_id,
+                        resource_id=resource_id,
                         license_feature=license_feature,
                         license_name=license_name,
                     )
@@ -3701,34 +4174,33 @@ class Payload:
             response = self._otds.get_partition(name=partition_name, show_error=False)
             if response:
                 self.logger.info(
-                    "Partition -> '%s' does already exist. Skipping...",
+                    "Partition -> '%s' does already exist.",
                     partition_name,
                 )
-                continue
-
-            # Only continue if Partition does not exist already
-            self.logger.info(
-                "Partition -> '%s' does not yet exist. Creating...",
-                partition_name,
-            )
-
-            response = self._otds.add_partition(
-                name=partition_name,
-                description=partition_description,
-            )
-            if response:
+            else:
+                # Only continue if Partition does not exist already
                 self.logger.info(
-                    "Added OTDS partition -> '%s'%s.",
+                    "Partition -> '%s' does not yet exist. Creating...",
                     partition_name,
-                    " ({})".format(partition_description) if partition_description else "",
                 )
-            else:
-                self.logger.error(
-                    "Failed to add OTDS partition -> '%s'!",
-                    partition_name,
+
+                response = self._otds.add_partition(
+                    name=partition_name,
+                    description=partition_description,
                 )
-                success = False
-                continue
+                if response:
+                    self.logger.info(
+                        "Added OTDS partition -> '%s'%s.",
+                        partition_name,
+                        " ({})".format(partition_description) if partition_description else "",
+                    )
+                else:
+                    self.logger.error(
+                        "Failed to add OTDS partition -> '%s'!",
+                        partition_name,
+                    )
+                    success = False
+                    continue
 
             access_role = partition.get("access_role")
             if access_role:
@@ -3749,7 +4221,6 @@ class Payload:
                         access_role,
                     )
                     success = False
-                    continue
             # end if access_role
 
             # Partions may have an optional list of licenses in
@@ -3767,11 +4238,55 @@ class Payload:
                     success = False
                     continue
                 otcs_resource_id = otcs_resource["resourceID"]
-                license_name = "EXTENDED_ECM"
-                for license_feature in partition_specific_licenses:
+                otcs_license_name = "EXTENDED_ECM"
+                for license_item in partition_specific_licenses:
+                    if isinstance(license_item, dict):
+                        license_feature = license_item.get("feature")
+                        license_name = license_item.get("name", "EXTENDED_ECM")
+                        if "enabled" in license_item and not license_item["enabled"]:
+                            self.logger.info(
+                                "Payload for License '%s' -> '%s' is disabled. Skipping...",
+                                license_name,
+                                license_feature,
+                            )
+                            continue
+
+                        if "resource" in license_item:
+                            try:
+                                resource_id = self._otds.get_resource(name=license_item["resource"])["resourceID"]
+                            except Exception:
+                                self.logger.error(
+                                    "Error getting resourceID from resource -> %s", license_item["resource"]
+                                )
+                        else:
+                            resource_id = otcs_resource_id
+
+                    elif isinstance(license_item, str):
+                        license_feature = license_item
+                        resource_id = otcs_resource_id
+                        license_name = otcs_license_name
+                    else:
+                        self.logger.error("Invalid License feature specified -> %s", license_item)
+                        success = False
+                        continue
+
+                    if self._otds.is_partition_licensed(
+                        partition_name=partition_name,
+                        resource_id=resource_id,
+                        license_feature=license_feature,
+                        license_name=license_name,
+                    ):
+                        self.logger.info(
+                            "Partition -> '%s' is already licensed for -> '%s' (%s)",
+                            partition_name,
+                            license_name,
+                            license_feature,
+                        )
+                        continue
+
                     assigned_license = self._otds.assign_partition_to_license(
                         partition_name=partition_name,
-                        resource_id=otcs_resource_id,
+                        resource_id=resource_id,
                         license_feature=license_feature,
                         license_name=license_name,
                     )
@@ -3804,13 +4319,8 @@ class Payload:
 
     # end method definition
 
-    def process_partition_licenses(
-        self,
-        section_name: str = "partitionLicenses",
-    ) -> bool:
-        """Process the licenses that should be assigned to OTDS partitions.
-
-        (this includes existing partitions)
+    def process_licenses(self, section_name: str = "licenses") -> bool:
+        """Process OTDS licenses in payload and create them in OTDS.
 
         Args:
             section_name (str, optional):
@@ -3822,11 +4332,11 @@ class Payload:
 
         Returns:
             bool:
-                True, if payload has been processed without errors, False otherwise.
+                True if payload has been processed without errors, False otherwise
 
         """
 
-        if not self._partitions:
+        if not self._licenses:
             self.logger.info(
                 "Payload section -> '%s' is empty. Skipping...",
                 section_name,
@@ -3840,83 +4350,52 @@ class Payload:
 
         success: bool = True
 
-        for partition in self._partitions:
-            partition_name = partition.get("name")
-            if not partition_name:
-                self.logger.error("Partition does not have a name. Skipping...")
-                success = False
-                continue
-
-            # Check if partition has been explicitly disabled in payload
-            # (enabled = false). In this case we skip the element:
-            if not partition.get("enabled", True):
+        for lic in self._licenses:
+            self.logger.debug("Start processing License -> '%s'", lic)
+            if not lic.get("enabled", True):
                 self.logger.info(
-                    "Payload for Partition -> '%s' is disabled. Skipping...",
-                    partition_name,
+                    "Payload for License -> '%s' is disabled. Skipping...",
+                    lic,
                 )
                 continue
 
-            response = self._otds.get_partition(name=partition_name, show_error=True)
-            if not response:
-                self.logger.error(
-                    "Partition -> '%s' does not exist. Skipping...",
-                    partition_name,
-                )
+            path = lic.get("path")
+            if not path:
+                self.logger.error("Required attribute path not specified (%s). Skipping ...", lic)
                 success = False
                 continue
 
-            # Partions may have an optional list of licenses in
-            # the payload. Assign the partition to all these licenses:
-            partition_specific_licenses = partition.get("licenses")
-            if partition_specific_licenses:
-                # We assume these licenses are Extended ECM licenses!
-                otcs_resource_name = self._otcs.config()["resource"]
-                otcs_resource = self._otds.get_resource(name=otcs_resource_name)
-                if not otcs_resource:
-                    self.logger.error(
-                        "Cannot find OTCS resource -> '%s'",
-                        otcs_resource_name,
-                    )
+            product_name = lic.get("product_name")
+            if not product_name:
+                self.logger.error("Required attribute product_name not specified (%s). Skipping ...", lic)
+                success = False
+                continue
+
+            if "resource" in lic:
+                try:
+                    resource_id = self._otds.get_resource(name=lic["resource"])["resourceID"]
+                except Exception:
+                    self.logger.error("Error getting resourceID from resource -> %s", lic["resource"])
                     success = False
                     continue
-                otcs_resource_id = otcs_resource["resourceID"]
-                license_name = "EXTENDED_ECM"
-                for license_feature in partition_specific_licenses:
-                    if self._otds.is_partition_licensed(
-                        partition_name=partition_name,
-                        resource_id=otcs_resource_id,
-                        license_feature=license_feature,
-                        license_name=license_name,
-                    ):
-                        self.logger.info(
-                            "Partition -> '%s' is already licensed for -> '%s' ('%s')",
-                            partition_name,
-                            license_name,
-                            license_feature,
-                        )
-                        continue
-                    assigned_license = self._otds.assign_partition_to_license(
-                        partition_name=partition_name,
-                        resource_id=otcs_resource_id,
-                        license_feature=license_feature,
-                        license_name=license_name,
-                    )
+            else:
+                self.logger.error("Required attribute resource not specified (%s). Skipping ...", lic)
+                success = False
+                continue
 
-                    if not assigned_license:
-                        self.logger.error(
-                            "Failed to assign partition -> '%s' to license feature -> '%s' of license -> '%s'!",
-                            partition_name,
-                            license_feature,
-                            license_name,
-                        )
-                        success = False
-                    else:
-                        self.logger.info(
-                            "Successfully assigned partition -> '%s' to license feature -> '%s' of license -> '%s'",
-                            partition_name,
-                            license_feature,
-                            license_name,
-                        )
+            self.logger.info("Adding License %s for %s to resource '%s'", path, product_name, resource_id)
+
+            add_license = self._otds.add_license_to_resource(
+                path_to_license_file=path,
+                product_name=product_name,
+                product_description=lic.get("description", ""),
+                resource_id=resource_id,
+                update=lic.get("update", True),
+            )
+
+            if not add_license:
+                success = False
+                continue
 
         self.write_status_file(
             success=success,
@@ -6477,7 +6956,8 @@ class Payload:
             user_last_name = user.get("lastname", "")  # Default is important here
             user_first_name = user.get("firstname", "")
             user_name = " ".join(filter(None, [user_first_name, user_last_name]))
-            if not user_name:
+            user_enabled = user.get("enabled", True) and user.get("enable_core_share", False)
+            if not user_name and user_enabled:  # Avoid a warning if not enbaled
                 self.logger.error(
                     "User is missing last name and first name. Skipping to next user...",
                 )
@@ -7318,23 +7798,23 @@ class Payload:
                             parent_group_name,
                             parent_group_id,
                         )
-                        continue
-
-                    self.logger.info(
-                        "Add Microsoft 365 user -> '%s' (%s) to Microsoft 365 group -> '%s' (%s)",
-                        user["name"],
-                        m365_user_id,
-                        parent_group_name,
-                        parent_group_id,
-                    )
-                    self._m365.add_group_member(
-                        group_id=parent_group_id,
-                        member_id=m365_user_id,
-                    )
+                    else:
+                        self.logger.info(
+                            "Add Microsoft 365 user -> '%s' (%s) to Microsoft 365 group -> '%s' (%s)...",
+                            user["name"],
+                            m365_user_id,
+                            parent_group_name,
+                            parent_group_id,
+                        )
+                        self._m365.add_group_member(
+                            group_id=parent_group_id,
+                            member_id=m365_user_id,
+                        )
                 # end for parent_group_name
 
-                # Make this user follow the SharePoint site of his/her department:
-                if group_name == user_department:
+                # Make this user follow the SharePoint site of his/her department.
+                # We only do this for users that have a valid M365 license (SKU):
+                if group_name == user_department and user["m365_skus"]:
                     group = self._m365.get_group(group_name=group_name)
                     group_id = self._m365.get_result_value(response=group, key="id")
                     if group_id:
@@ -7342,19 +7822,48 @@ class Payload:
                         group_site_id = self._m365.get_result_value(response=group_site, key="id")
                         if group_site_id:
                             group_site_name = self._m365.get_result_value(response=group_site, key="name")
-                            response = self._m365.follow_sharepoint_site(site_id=group_site_id, user_id=m365_user_id)
-                            if response:
-                                self.logger.info(
-                                    "Make user -> '%s' follow SharePoint site -> '%s'",
-                                    user["name"],
-                                    group_site_name,
+                            # Make sure the user's mysite (drive) has been provisioned.
+                            # This is a prerequisite for a user being able to follow a
+                            # SharePoint site. For this to work we need "Files.ReadWrite"
+                            # as a delegated permission in the Azure AppRegistration!
+                            self.logger.info(
+                                "Make sure user -> '%s' has a drive (mySite) provisioned...",
+                                user["email"],
+                            )
+                            # We need to have 'delegated' permissions for this so we authenticate
+                            # as the user... The scope is important here - the user's drive can only
+                            # be provisioned if "Files.ReadWrite" scope is provided:
+                            response = self._m365.authenticate_user(
+                                username=user["email"], password=user["password"], scope="Files.ReadWrite"
+                            )
+                            if not response:
+                                self.logger.error(
+                                    "Couldn't authenticate as M365 user -> '%s' to provision user's drive!",
+                                    username=user["email"],
                                 )
-                            else:
+                                success = False
+                                continue
+                            # Retrieve the drive endpoint to trigger the drive provisioning. It is important
+                            # to use the 'me=True' to make sure the request is done with the user credentials,
+                            # not the app credentials (using purely client_id / client_secret):
+                            response = self._m365.get_user_drive(user_id=user["email"], me=True)
+                            if not response:
+                                self.logger.error("Couldn't get M365 drive of user -> '%s'!", user["email"])
+                                success = False
+                                continue
+                            self.logger.info(
+                                "Make user -> '%s' follow departmental SharePoint site -> '%s'...",
+                                user["email"],
+                                group_site_name,
+                            )
+                            response = self._m365.follow_sharepoint_site(site_id=group_site_id, user_id=m365_user_id)
+                            if not response:
                                 self.logger.warning(
                                     "User -> '%s' cannot follow SharePoint site -> '%s'. ",
-                                    user["name"],
+                                    user["email"],
                                     group_site_name,
                                 )
+                                success = False
             # end for group name
         # end for user
         self.write_status_file(
@@ -10082,12 +10591,18 @@ class Payload:
             self._workspace_types = self.get_status_file(
                 payload_section_name=section_name,
             )
-            self.logger.info(
-                "Found -> %s workspace types.",
-                str(len(self._workspace_types)),
-            )
-            self.logger.debug("Workspace types -> %s", str(self._workspace_types))
-            return self._workspace_types
+            if self._workspace_types:
+                self.logger.info(
+                    "Found -> %s workspace types.",
+                    str(len(self._workspace_types)),
+                )
+                self.logger.debug("Workspace types -> %s", str(self._workspace_types))
+                return self._workspace_types
+            else:
+                self.logger.error(
+                    "Couldn't read workspace types from status file -> '%s'. Regenerate list...",
+                    self.get_status_file_name(payload_section_name=section_name),
+                )
 
         # Read payload_section "workspaceTypes" if available
         payload_section = {}
@@ -11087,17 +11602,18 @@ class Payload:
             search_value=search_value,
             result_fields=["Id"],
         )
+        bo_id = self._salesforce.get_result_value(response=response, key="Id")
         num_of_bos = int(response.get("totalSize", 0)) if (response is not None and "totalSize" in response) else 0
         if num_of_bos > 1:
             self.logger.warning(
-                "Salesforce lookup delivered %s business objects for business object type -> '%s'! We will pick the first one.",
+                "Salesforce lookup delivered %s business objects for business object type -> '%s'! We will pick the first one -> %s.",
                 str(num_of_bos),
                 str(object_type),
+                bo_id,
             )
-        bo_id = self._salesforce.get_result_value(response=response, key="Id")
         if not bo_id:
             self.logger.warning(
-                "Business object of type -> '%s' and %s = %s does not exist in Salesforce!",
+                "Business object of type -> '%s' with '%s' = '%s' does not exist in Salesforce!",
                 object_type,
                 search_field,
                 search_value,
@@ -12483,7 +12999,7 @@ class Payload:
         )
 
         # now determine the actual node IDs of the workspaces (has been created before):
-        workspace_node_id: int = self.determine_workspace_id(workspace=workspace)
+        workspace_node_id = int(self.determine_workspace_id(workspace=workspace))
         if not workspace_node_id:
             self.logger.warning(
                 "Workspace -> '%s' (type -> '%s') has no node ID and cannot have a relationship (workspace creation may have failed or final name is different from payload). Skipping to next workspace...",
@@ -12501,39 +13017,62 @@ class Payload:
         success: bool = True
 
         for related_workspace_id in workspace["relationships"]:
-            # Find the workspace type with the name given in the payload:
+            # Initialize variable to determine if we found a related workspace:
+            related_workspace_node_id = None
+
+            #
+            # 1. Option: Find the related workspace with the logical ID given in the payload:
+            #
             related_workspace = next(
                 (item for item in self._workspaces if item["id"] == related_workspace_id),
                 None,
             )
-            if related_workspace is None:
-                self.logger.error(
-                    "Related Workspace with logical ID -> %s not found.",
+            if related_workspace:
+                if not related_workspace.get("enabled", True):
+                    self.logger.info(
+                        "Payload for Related Workspace -> '%s' is disabled. Skipping...",
+                        related_workspace["name"],
+                    )
+                    continue
+
+                related_workspace_node_id = self.determine_workspace_id(
+                    workspace=related_workspace,
+                )
+                if not related_workspace_node_id:
+                    self.logger.warning(
+                        "Related Workspace -> '%s' (type -> '%s') has no node ID (workspaces creation may have failed or name is different from payload). Skipping to next workspace...",
+                        related_workspace["name"],
+                        related_workspace["type_name"],
+                    )
+                    continue
+                self.logger.debug(
+                    "Related Workspace with logical ID -> %s has node ID -> %s",
                     related_workspace_id,
+                    related_workspace_node_id,
                 )
-                success = False
-                continue
+            # end if related_workspace is not None
 
-            if not related_workspace.get("enabled", True):
-                self.logger.info(
-                    "Payload for Related Workspace -> '%s' is disabled. Skipping...",
-                    related_workspace["name"],
+            #
+            # 2. Option: Find the related workspace with nickname:
+            #
+            else:
+                # See if a nickname exists the the provided related_workspace_id:
+                response = self._otcs.get_node_from_nickname(nickname=related_workspace_id)
+                related_workspace_node_id = self._otcs.get_result_value(
+                    response=response,
+                    key="id",
                 )
-                continue
 
-            related_workspace_node_id = self.determine_workspace_id(
-                workspace=related_workspace,
-            )
-            if not related_workspace_node_id:
-                self.logger.warning(
-                    "Related Workspace -> '%s' (type -> '%s') has no node ID (workspaces creation may have failed or name is different from payload). Skipping to next workspace...",
-                    related_workspace["name"],
-                    related_workspace["type_name"],
+            if related_workspace_node_id is None:
+                self.logger.error(
+                    "Related Workspace with logical ID or nickname -> %s not found.",
+                    related_workspace_id,
                 )
+                success = False
                 continue
 
             self.logger.debug(
-                "Related Workspace with logical ID -> %s has node ID -> %s",
+                "Related Workspace with logical ID or nickname -> %s has node ID -> %s",
                 related_workspace_id,
                 related_workspace_node_id,
             )
@@ -13327,6 +13866,15 @@ class Payload:
                 )
                 success = False
                 continue
+            # Also embed the workspace metadata:
+            if not self._otcs.aviator_embed_metadata(
+                node_id=workspace_id,
+                workspace_metadata=True,
+                wait_for_completion=False,
+            ):
+                success = False
+                continue
+        # end for workspace in self._workspaces
 
         self.write_status_file(
             success=success,
@@ -13867,6 +14415,7 @@ class Payload:
                     )
                     if not favorite_item:
                         self.logger.error("Cannot find path -> %s for favorite item!", str(favorite))
+                        success = False
                         continue
                     favorite_id = self._otcs.get_result_value(
                         response=favorite_item,
@@ -14998,6 +15547,23 @@ class Payload:
             items (list):
                 List of items to create (need this as parameter as we
                 have multiple lists).
+                Each list item in the payload is a dict with this structure:
+                {
+                    enabled = "..."
+                    name = "..."
+                    description = "..."
+                    nickname = "..."
+                    parent_nickname = "..."
+                    parent_path = [...]
+                    parent_volume = ...
+                    original_nickname = "..."
+                    original_path = []
+                    type = ...
+                    url = "..."
+                    details = {
+                        "scheduledbotdetails" : ...
+                    } # additional parameters
+                }
             section_name (str, optional):
                 The name of the payload section. It can be overridden
                 for cases where multiple sections of same type
@@ -15042,6 +15608,7 @@ class Payload:
                 continue
 
             item_description = item.get("description", "")
+            item_nickname = item.get("nickname", None)
             parent_nickname = item.get("parent_nickname", None)
             parent_path = item.get("parent_path", None)
 
@@ -15124,7 +15691,7 @@ class Payload:
             item_type = int(item.get("type", self._otcs.ITEM_TYPE_FOLDER))
             item_url = item.get("url", "")
             item_details = item.get("details", {})
-
+            create_item_details = item.get("create_details", {})
             # check that we have the required information
             # for the given item type:
             match item_type:
@@ -15164,6 +15731,8 @@ class Payload:
                         success = False
                         continue
 
+                    create_item_details["xecmpfJobType"] = item_details["xecmpfJobType"]
+
             # Check if an item with the same name does already exist.
             # This can also be the case if the python container runs a 2nd time.
             # For this reason we are also not issuing an error but just an info (False):
@@ -15186,7 +15755,7 @@ class Payload:
                 item_description=item_description,
                 url=item_url,
                 original_id=int(original_id),
-                **item_details,
+                **create_item_details,
             )
             node_id = self._otcs.get_result_value(response=response, key="id")
             if not node_id:
@@ -15195,26 +15764,80 @@ class Payload:
                 continue
 
             self.logger.info(
-                "Item -> '%s' with ID -> %s has been created successfully.",
+                "Successfully created item -> '%s' with ID -> %s.",
                 item_name,
                 node_id,
             )
 
             # Special handling for scheduled bot items:
             if item_type == self._otcs.ITEM_TYPE_SCHEDULED_BOT:
+                scheduled_bot_details = item_details.get("scheduledbotdetails", {})
+                if not scheduled_bot_details:
+                    self.logger.error("Failed to get details of scheduled bot item -> '%s'.", item_name)
+                    success = False
+                    continue
+                start_mode = scheduled_bot_details.get("startmodus")
+                if not start_mode:
+                    self.logger.error("Failed to get start mode of scheduled bot item -> '%s'.", item_name)
+                    success = False
+                    continue
+                start_mode = start_mode.get("startMode")
+                if not start_mode:
+                    self.logger.error("Failed to get start mode of scheduled bot item -> '%s'.", item_name)
+                    success = False
+                    continue
+                old_schedule_data = scheduled_bot_details.get("oldscheduleData")
+                # Check if this bot should start after another bot:
+                if start_mode == "AfterJob":
+                    after_job_nickname = scheduled_bot_details["startmodus"].get("afterJob")
+                    if not after_job_nickname:
+                        after_job_nickname = item_details.get("xecmpfAfterJobDataId")
+                    self.logger.info(
+                        "Scheduled bot item -> '%s' starts after another scheduled bot with nickname -> '%s'. Resolving nickname...",
+                        item_name,
+                        after_job_nickname,
+                    )
+                    # Get the Scheduled Bot node that this bot depends on:
+                    response = self._otcs.get_node_from_nickname(nickname=after_job_nickname)
+                    after_job_id = self._otcs.get_result_value(
+                        response=response,
+                        key="id",
+                    )
+                    # Update the bot details - changing the name coming from the
+                    # payload to the actual node ID (both in details and in 'old' details):
+                    scheduled_bot_details["startmodus"]["afterJob"] = after_job_id
+                    old_schedule_data["afterJob"] = after_job_id
+
+                    item_details["xecmpfAfterJobDataId"] = after_job_id
+                # Check if this bot should start based on a schedule.
+                # Then we need to configure the agent to run it:
+                elif str(start_mode) == "7558":  # 7558 is NOT a object ID but an internal agent type ID!
+                    self.logger.info(
+                        "Scheduled bot item -> '%s' starts based on a schedule. Setting the agent ID to '7558'...",
+                        item_name,
+                    )
+                    # Make sure the agent ID is configured:
+                    item_details["xecmpfAgentId"] = 7558
+                self.logger.debug("Scheduled bot details -> %s", str(scheduled_bot_details))
+
+                # The REST API requires to have the scheduled bot details wrapped into a JSON structure:
                 item_details["scheduledbotdetails"] = json.dumps(item_details.get("scheduledbotdetails", {}))
 
                 response = self._otcs.update_item(node_id=node_id, body=False, **item_details)
                 if not response:
-                    self.logger.error("Failed to update scheduld bot item -> '%s'.", item_name)
+                    self.logger.error("Failed to update scheduled bot item -> '%s'.", item_name)
                     success = False
                     continue
 
-                response = self._otcs.update_item(node_id=node_id, body=False, actionName="Runnow")
-                if not response:
-                    self.logger.error("Failed to run scheduld bot item -> '%s'.", item_name)
-                    success = False
-                    continue
+                # If the Job has start mode manual we start it now:
+                if start_mode == "manual":
+                    self.logger.info("Run scheduled bot -> '%s' now...", item_name)
+                    response = self._otcs.update_item(node_id=node_id, body=False, actionName="Runnow")
+                    if not response:
+                        self.logger.error("Failed to run scheduled bot item -> '%s'.", item_name)
+                        success = False
+                        continue
+            # end if item_type == self._otcs.ITEM_TYPE_SCHEDULED_BOT:
 
             # Special handling for collection items:
             elif item_type == self._otcs.ITEM_TYPE_COLLECTION:
@@ -15269,6 +15892,11 @@ class Payload:
                         node_ids=item_node_ids,
                     )
             # end if item_type == self._otcs.ITEM_TYPE_COLLECTION
+
+            # Do we have a nickname for the item in the payload? Then assign it:
+            if item_nickname:
+                self.logger.info("Assign nickname -> '%s' to item -> '%s' (%s)", item_nickname, item_name, node_id)
+                self._otcs.set_node_nickname(node_id=node_id, nickname=item_nickname)
         # end for item in items:
 
         self.write_status_file(
@@ -16081,7 +16709,7 @@ class Payload:
         self,
         resource_name: str,
         license_feature: str,
-        license_name: str,
+        license_name: str = "EXTENDED_ECM",
         user_specific_payload_field: str = "licenses",
         section_name: str = "userLicenses",
     ) -> bool:
@@ -16168,9 +16796,42 @@ class Payload:
                 user_license_features = [license_feature]
 
             for user_license_feature in user_license_features:
+                if isinstance(user_license_feature, dict):
+                    user_license_feature_dict = user_license_feature
+                    user_license_feature = user_license_feature_dict.get("feature", license_feature)
+                    license_name = user_license_feature_dict.get("name", license_name)
+                    if "enabled" in user_license_feature_dict and not user_license_feature_dict["enabled"]:
+                        self.logger.info(
+                            "Payload for License '%s' -> '%s' is disabled. Skipping...",
+                            license_name,
+                            license_feature,
+                        )
+                        continue
+
+                    if "resource" in user_license_feature_dict:
+                        try:
+                            resource_id = self._otds.get_resource(name=user_license_feature_dict["resource"])[
+                                "resourceID"
+                            ]
+                        except Exception:
+                            self.logger.error(
+                                "Error retrieving resourceID for -> %s", user_license_feature_dict["resource"]
+                            )
+                            continue
+                            success = False
+                    else:
+                        resource_id = otds_resource["resourceID"]
+
+                elif isinstance(user_license_feature, str):
+                    resource_id = otds_resource["resourceID"]
+
+                else:
+                    self.logger.error("Invalid License feature specified -> %s", user_license_feature)
+                    continue
+
                 if self._otds.is_user_licensed(
                     user_name=user_name,
-                    resource_id=otds_resource["resourceID"],
+                    resource_id=resource_id,
                     license_feature=user_license_feature,
                     license_name=license_name,
                 ):
@@ -16184,7 +16845,7 @@ class Payload:
                 assigned_license = self._otds.assign_user_to_license(
                     partition=user_partition,
                     user_id=user_name,  # we want the plain login name here
-                    resource_id=otds_resource["resourceID"],
+                    resource_id=resource_id,
                     license_feature=user_license_feature,
                     license_name=license_name,
                 )
@@ -16330,6 +16991,8 @@ class Payload:
 
         """
 
+        self.logger.warning("execPodCommand is deprecated - use kubernetes section with action 'execPodCommands'")
+
         if not isinstance(self._k8s, K8s):
             self.logger.error(
                 "K8s not setup properly -> Skipping payload section -> '%s'...",
@@ -16370,6 +17033,7 @@ class Payload:
                 continue
 
             container = exec_pod_command.get("container", None)
+            timeout = int(exec_pod_command.get("timeout", 60))
 
             # Check if exec pod command has been explicitly disabled in payload
             # (enabled = false). In this case we skip the element:
@@ -16398,17 +17062,9 @@ class Payload:
 
             if "interactive" not in exec_pod_command or exec_pod_command["interactive"] is False:
                 result = self._k8s.exec_pod_command(
-                    pod_name=pod_name,
-                    command=command,
-                    container=container,
-                )
-            elif "timeout" not in exec_pod_command:
-                result = self._k8s.exec_pod_command_interactive(
-                    pod_name=pod_name,
-                    commands=command,
+                    pod_name=pod_name, command=command, container=container, timeout=timeout
                 )
             else:
-                timeout = exec_pod_command["timeout"]
                 result = self._k8s.exec_pod_command_interactive(
                     pod_name=pod_name,
                     commands=command,
@@ -16421,31 +17077,349 @@ class Payload:
             # 3. result is a non-empty string - this is OK - print it to log
             if result is None:
                 self.logger.error(
-                    "Execution of command -> %s in pod -> '%s' failed",
-                    command,
-                    pod_name,
+                    "Execution of command -> %s in pod -> '%s' failed",
+                    command,
+                    pod_name,
+                )
+                success = False
+            elif result != "":
+                self.logger.info(
+                    "Execution of command -> %s in pod -> '%s' returned result -> %s",
+                    command,
+                    pod_name,
+                    result,
+                )
+            else:
+                # It is not an error if no result is returned. It depends on the nature of the command
+                # if a result is written to stdout or stderr.
+                self.logger.info(
+                    "Execution of command -> %s in pod -> '%s' did not return a result",
+                    command,
+                    pod_name,
+                )
+
+        self.write_status_file(
+            success=success,
+            payload_section_name=section_name,
+            payload_section=self._exec_pod_commands,
+        )
+
+        return success
+
+    # end method definition
+
+    def process_kubernetes(self, section_name: str = "kubernetes") -> bool:
+        """Process actions that should be executed in the Kubernetess.
+
+        Args:
+            section_name (str, optional):
+                The name of the payload section. It can be overridden
+                for cases where multiple sections of same type
+                are used (e.g. the "Post" sections).
+                This name is also used for the "success" status
+                files written to the Admin Personal Workspace.
+
+        Returns:
+            bool:
+                True if payload has been processed without errors, False otherwise.
+
+        """
+
+        if not isinstance(self._k8s, K8s):
+            self.logger.error(
+                "K8s not setup properly -> Skipping payload section -> '%s'...",
+                section_name,
+            )
+            return False
+
+        if not self._kubernetes:
+            self.logger.info(
+                "Payload section -> '%s' is empty. Skipping...",
+                section_name,
+            )
+            return True
+
+        # If this payload section has been processed successfully before we
+        # can return True and skip processing it once more:
+        if self.check_status_file(payload_section_name=section_name):
+            return True
+
+        success: bool = True
+
+        for item in self._kubernetes:
+            # Check if element has been disabled in payload (enabled = false).
+            # In this case we skip the element:
+            if isinstance(item, dict) and not item.get("enabled", True):
+                self.logger.info("Skipping disabled item -> %s", item)
+                continue
+
+            match item.get("action"):
+                case "execPodCommand":
+                    pod_name = item.get("pod_name")
+
+                    if not pod_name:
+                        self.logger.error(
+                            "To execute a command in a pod the pod name needs to be specified in the payload! Skipping to next kubernetes item...",
+                        )
+                        success = False
+                        continue
+
+                    command = item.get("command", [])
+                    if not command:
+                        self.logger.error(
+                            "Command is not specified for pod -> %s! It needs to be a non-empty list! Skipping to next kubernetes item...",
+                            pod_name,
+                        )
+                        success = False
+                        continue
+
+                    container = item.get("container", None)
+                    timeout = int(item.get("timeout", 60))
+
+                    # Check if exec pod command has been explicitly disabled in payload
+                    # (enabled = false). In this case we skip the element:
+                    if not item.get("enabled", True):
+                        self.logger.info(
+                            "Payload for exec pod command in pod -> '%s' is disabled. Skipping...",
+                            pod_name,
+                        )
+                        continue
+
+                    if "description" not in item:
+                        self.logger.info(
+                            "Executing command -> %s in pod -> '%s'",
+                            command,
+                            pod_name,
+                        )
+
+                    else:
+                        description = item["description"]
+                        self.logger.info(
+                            "Executing command -> %s in pod -> '%s' (%s)",
+                            command,
+                            pod_name,
+                            description,
+                        )
+
+                    if "interactive" not in item or item["interactive"] is False:
+                        result = self._k8s.exec_pod_command(
+                            pod_name=pod_name, command=command, container=container, timeout=timeout
+                        )
+                    else:
+                        result = self._k8s.exec_pod_command_interactive(
+                            pod_name=pod_name,
+                            commands=command,
+                            timeout=timeout,
+                        )
+
+                    # we need to differentiate 3 cases here:
+                    # 1. result = None is returned - this is an error (exception)
+                    # 2. result is empty string - this is OK
+                    # 3. result is a non-empty string - this is OK - print it to log
+                    if result is None:
+                        self.logger.error(
+                            "Execution of command -> %s in pod -> '%s' failed",
+                            command,
+                            pod_name,
+                        )
+                        success = False
+                    elif result != "":
+                        self.logger.info(
+                            "Execution of command -> %s in pod -> '%s' returned result -> %s",
+                            command,
+                            pod_name,
+                            result,
+                        )
+                    else:
+                        # It is not an error if no result is returned. It depends on the nature of the command
+                        # if a result is written to stdout or stderr.
+                        self.logger.info(
+                            "Execution of command -> %s in pod -> '%s' did not return a result",
+                            command,
+                            pod_name,
+                        )
+
+                case "restart":
+                    k8s_type = item.get("type")
+                    name = item.get("name")
+                    message = item.get("message")
+
+                    if not name:
+                        self.logger.error("Name not specified for kubernetes item -> %s", item)
+                    if not k8s_type:
+                        self.logger.error("Type not specified for kubernetes item -> %s", item)
+
+                    if message:
+                        self.logger.info("%s", message)
+
+                    if k8s_type.lower() == "statefulset":
+                        self.logger.info("Restarting statefulset -> %s", name)
+                        restart_result = self._k8s.restart_stateful_set(sts_name=name)
+
+                    elif k8s_type.lower() == "deployment":
+                        self.logger.info("Restarting deployment -> %s", name)
+                        restart_result = self._k8s.restart_deployment(deployment_name=name)
+
+                    elif k8s_type.lower() == "pod":
+                        self.logger.info("Deleting pod -> %s", name)
+                        restart_result = self._k8s.delete_pod(pod_name=name)
+
+                    if not restart_result:
+                        success = False
+
+                case _:
+                    self.logger.error("Action not defined for work item -> %s", item)
+                    continue
+
+        self.write_status_file(
+            success=success,
+            payload_section_name=section_name,
+            payload_section=self._kubernetes,
+        )
+
+        return success
+
+    # end method definition
+
+    def process_exec_database_commands(self, section_name: str = "execDatabaseCommands") -> bool:
+        """Process commands that should be executed in the PostgreSQL database.
+
+        Args:
+            section_name (str, optional):
+                The name of the payload section. It can be overridden
+                for cases where multiple sections of same type
+                are used (e.g. the "Post" sections).
+                This name is also used for the "success" status
+                files written to the Admin Personal Workspace.
+
+        Returns:
+            bool:
+                True if payload has been processed without errors, False otherwise.
+
+        """
+
+        if not self._exec_database_commands:
+            self.logger.info(
+                "Payload section -> '%s' is empty. Skipping...",
+                section_name,
+            )
+            return True
+
+        if not psycopg_installed:
+            self.logger.warning("Python module 'psycopg' not installed. Cannot execute database commands. Skipping...")
+            return False
+
+        # If this payload section has been processed successfully before we
+        # can return True and skip processing it once more:
+        if self.check_status_file(payload_section_name=section_name):
+            return True
+
+        success: bool = True
+
+        for database_command_set in self._exec_database_commands:
+            # Check if exec pod command has been explicitly disabled in payload
+            # (enabled = false). In this case we skip the element:
+            if not database_command_set.get("enabled", True):
+                self.logger.info(
+                    "Payload for database command set is disabled. Skipping...",
+                )
+                continue
+
+            db_connection = database_command_set.get("db_connection")
+            if not db_connection:
+                self.logger.error(
+                    "To execute a command in a database the connection information needs to be specified in the payload! Skipping to next database command set...",
+                )
+                success = False
+                continue
+
+            db_name = db_connection.get("db_name", None)
+            if not db_name:
+                self.logger.error(
+                    "Database connection information is missing the database name! Skipping to next database command set...",
+                )
+                success = False
+                continue
+            db_hostname = db_connection.get("db_hostname", None)
+            if not db_hostname:
+                self.logger.error(
+                    "Database connection information is missing the database hostname! Skipping to next database command set...",
                 )
                 success = False
-            elif result != "":
-                self.logger.info(
-                    "Execution of command -> %s in pod -> '%s' returned result -> %s",
-                    command,
-                    pod_name,
-                    result,
+                continue
+            db_port = int(db_connection.get("db_port", 5432))
+            db_username = db_connection.get("db_username", None)
+            if not db_username:
+                self.logger.error(
+                    "Database connection information is missing the database username! Skipping to next database command set...",
                 )
-            else:
-                # It is not an error if no result is returned. It depends on the nature of the command
-                # if a result is written to stdout or stderr.
-                self.logger.info(
-                    "Execution of command -> %s in pod -> '%s' did not return a result",
-                    command,
-                    pod_name,
+                success = False
+                continue
+            db_password = db_connection.get("db_password", None)
+            if not db_password:
+                self.logger.error(
+                    "Database connection information is missing the database password! Skipping to next database command set...",
                 )
+                success = False
+                continue
+
+            connect_string = "dbname={} user={} password={} host={} port={}".format(
+                db_name, db_username, db_password, db_hostname, db_port
+            )
+
+            db_commands = database_command_set.get("db_commands", [])
+
+            # TODO: Add support for sql file
+
+            db_connection = None  # Predefine for safe access in except
+            allowed_verbs = {"SELECT", "INSERT", "UPDATE", "CREATE"}
+
+            try:
+                # Using a context managers (with ...) for automatic resource management:
+                with psycopg.connect(connect_string) as db_connection:
+                    self.logger.info(
+                        "Connected to database -> '%s' (%s) with user -> '%s'", db_name, db_hostname, db_username
+                    )
+                    with db_connection.cursor() as cursor:
+                        for db_command in db_commands:
+                            cmd = db_command.get("command", None)
+                            if not cmd:
+                                self.logger.warning(
+                                    "Cannot execute database command without SQL statement. Skipping..."
+                                )
+                                continue
+                            params = db_command.get("params", None)
+                            if params is not None and isinstance(params, (list, tuple)):
+                                self.logger.error(
+                                    "Database parameters -> %s must be given as a list or tuple!", str(params)
+                                )
+                                continue
+                            # Get the command verb (like "SELECT", "CREATE")
+                            verb = cmd.strip().split()[0].upper()
+                            if verb not in allowed_verbs:
+                                self.logger.error("Database command -> '%s' is not allowed!", verb)
+                                continue
+                            if params:
+                                self.logger.info(
+                                    "Execute database command -> '%s' with parameters -> %s...", cmd, str(params)
+                                )
+                            else:
+                                self.logger.info("Execute database command -> '%s' without parameters...", cmd)
+                            cursor.execute(cmd, params)
+                            if verb == "SELECT":
+                                response = cursor.fetchall()
+                                self.logger.debug("Database response -> '%s'", response)
+                    db_connection.commit()
+            except psycopg.Error as e:
+                success = False
+                self.logger.error("Database error -> %s", e)
+                if db_connection is not None:
+                    db_connection.rollback()
 
         self.write_status_file(
             success=success,
             payload_section_name=section_name,
-            payload_section=self._exec_pod_commands,
+            payload_section=self._exec_database_commands,
         )
 
         return success
@@ -16467,7 +17441,7 @@ class Payload:
                 files written to the Admin Personal Workspace.
 
         Returns:
-            bool:
+            bool:,
                 True if payload has been processed without errors, False otherwise.
 
         """
@@ -16659,7 +17633,7 @@ class Payload:
                     authenticated_user = exec_as_user
                 else:
                     self.logger.error(
-                        "Cannot find user with login name -> '%s' for executing. Executing as admin...",
+                        "Cannot find user with login name -> '%s' for executing document generator. Executing as admin...",
                         exec_as_user,
                     )
                     admin_context = True
@@ -17250,7 +18224,7 @@ class Payload:
         section_name: str = "browserAutomations",
         check_status: bool = True,
     ) -> bool:
-        """Process Selenium-based browser automations.
+        """Process Playwright-based browser automations and tests.
 
         Args:
             browser_automations (list):
@@ -17288,51 +18262,60 @@ class Payload:
 
         success: bool = True
 
+        automation_type = "Browser" if "browser" in section_name else "Test"
+
         for browser_automation in browser_automations:
             name = browser_automation.get("name")
             if not name:
-                self.logger.error(
-                    "Browser automation is missing a unique name. Skipping...",
-                )
+                self.logger.error("%s automation is missing a unique name. Skipping...", automation_type)
                 success = False
                 continue
 
+            self._log_header_callback(
+                text="Process {} Automation -> '{}'".format(automation_type, name),
+                char="-",
+            )
+
             description = browser_automation.get("description", "")
+            if description:
+                self.logger.info(
+                    "%s Automation description -> '%s'",
+                    automation_type,
+                    description,
+                )
 
             # Check if browser automation has been explicitly disabled in payload
             # (enabled = false). In this case we skip this payload element:
             if not browser_automation.get("enabled", True):
                 self.logger.info(
-                    "Payload for browser automation -> '%s'%s is disabled. Skipping...",
+                    "Payload for %s automation -> '%s'%s is disabled. Skipping...",
+                    automation_type.lower(),
                     name,
                     " ({})".format(description) if description else "",
                 )
                 continue
 
-            self.logger.info(
-                "Processing Browser Automation -> '%s'%s...",
-                name,
-                " ({})".format(description) if description else "",
-            )
-
             base_url = browser_automation.get("base_url")
             if not base_url:
-                self.logger.error("Browser automation -> '%s' is missing base_url. Skipping...", name)
+                self.logger.error(
+                    "%s automation -> '%s' is missing 'base_url' parameter. Skipping...", automation_type, name
+                )
                 success = False
                 continue
 
             user_name = browser_automation.get("user_name", "")
             if not user_name:
-                self.logger.info("Browser automation -> '%s' is not having user name.", name)
+                self.logger.info("%s automation -> '%s' is not having user name.", automation_type, name)
 
             password = browser_automation.get("password", "")
             if not password:
-                self.logger.info("Browser automation -> '%s' is not having password.", name)
+                self.logger.info("%s automation -> '%s' is not having password.", automation_type, name)
 
-            automations = browser_automation.get("automations", [])
-            if not automations:
+            automation_steps = browser_automation.get("automations", [])
+            if not automation_steps:
                 self.logger.error(
-                    "Browser automation -> '%s' is missing list of automations. Skipping...",
+                    "%s automation -> '%s' is missing list of automations. Skipping...",
+                    automation_type,
                     name,
                 )
                 success = False
@@ -17341,162 +18324,335 @@ class Payload:
             debug_automation: bool = browser_automation.get("debug", False)
 
             # Create Selenium Browser Automation:
-            self.logger.info("Browser Automation base URL -> %s", base_url)
-            self.logger.info("Browser Automation user -> %s", user_name)
-            self.logger.debug("Browser Automation password -> %s", password)
+            self.logger.info("%s Automation base URL -> %s", automation_type, base_url)
+            self.logger.info("%s Automation user -> '%s'", automation_type, user_name)
+            wait_until = browser_automation.get("wait_until")  # it is OK to be None
+            if "wait_until" in browser_automation:
+                # Only log the "wait until" value if it is specified in the payload:
+                self.logger.info(
+                    "%s Automation page navigation strategy is to wait until -> '%s'.",
+                    automation_type,
+                    wait_until,
+                )
             browser_automation_object = BrowserAutomation(
                 base_url=base_url,
                 user_name=user_name,
                 user_password=password,
                 automation_name=name,
                 take_screenshots=debug_automation,
+                headless=self._browser_headless,
                 logger=self.logger,
+                wait_until=wait_until,
             )
-            # Implicit Wait is a global setting (for whole brwoser session)
+            # Wait time is a global setting (for whole brwoser session)
             # This makes sure a page is fully loaded and elements are present
             # before accessing them. We set 15.0 seconds as default if not
             # otherwise specified by "wait_time" in the payload.
-            # See https://www.selenium.dev/documentation/webdriver/waits/
             wait_time = browser_automation.get("wait_time", 15.0)
-            browser_automation_object.implicit_wait(wait_time)
+            browser_automation_object.set_timeout(wait_time=wait_time)
             if "wait_time" in browser_automation:
                 self.logger.info(
-                    "Browser Automation Implicit Wait time -> '%s' configured",
+                    "%s Automation wait time -> '%s' configured.",
+                    automation_type,
                     wait_time,
                 )
 
-            for automation in automations:
-                if "type" not in automation:
-                    self.logger.error(
-                        "Browser automation step is missing type. Skipping...",
-                    )
+            # Initialize overall result status:
+            result = True
+            first_step = True
+
+            for automation_step in automation_steps:
+                if "type" not in automation_step:
+                    self.logger.error("%s automation step is missing type. Skipping...", automation_type)
                     success = False
                     break
-                automation_type = automation.get("type", "")
+                automation_step_type = automation_step.get("type", "")
+                dependent = automation_step.get("dependent", True)
+                if not dependent and not result:
+                    self.logger.warning(
+                        "Ignore result of previous step as current step -> '%s' is NOT dependent on it.",
+                        automation_step_type,
+                    )
+                    result = True
+                elif not result:
+                    # In this case a proceeding automation step has failed
+                    # and this step is marked as dependent. Then it does not make sense
+                    # to continue with this automation step after the proceeding step failed.
+                    self.logger.warning(
+                        "Step -> '%s' is dependent on a proceeding step that failed. Skipping this step...",
+                        automation_step_type,
+                    )
+                    continue
+                elif not first_step:
+                    self.logger.info(
+                        "Current step -> '%s' is %s on proceeding step.",
+                        automation_step_type,
+                        "dependent" if dependent else "not dependent",
+                    )
 
-                match automation_type:
+                match automation_step_type:
                     case "login":
-                        page = automation.get("page", "")
+                        page = automation_step.get("page", "")
+                        user_field = automation_step.get("user_field", "otds_username")
+                        password_field = automation_step.get(
+                            "password_field",
+                            "otds_password",
+                        )
+                        login_button = automation_step.get("login_button", "loginbutton")
+                        # Do we have a step-specific wait mechanism? If not, we pass None
+                        # then the browser automation will take the default configured for
+                        # the whole browser automation (see BrowserAutomation() constructor above):
+                        wait_until = automation_step.get("wait_until", None)
                         self.logger.info(
-                            "Login to -> %s as user -> %s",
+                            "Login to -> %s as user -> '%s' (%s page navigation strategy is to wait until -> '%s')",
                             base_url + page,
                             user_name,
+                            "specific" if wait_until is not None else "default",
+                            wait_until if wait_until is not None else browser_automation_object.wait_until,
                         )
-                        user_field = automation.get("user_field", "otds_username")
-                        password_field = automation.get(
-                            "password_field",
-                            "otds_password",
-                        )
-                        login_button = automation.get("login_button", "loginbutton")
-                        if not browser_automation_object.run_login(
+                        result = browser_automation_object.run_login(
                             page=page,
                             user_field=user_field,
                             password_field=password_field,
                             login_button=login_button,
-                        ):
+                            wait_until=wait_until,
+                        )
+                        if not result:
                             self.logger.error(
-                                "Cannot log into -> %s. Stopping automation.",
+                                "Cannot log into -> %s. Skipping to next automation step...",
                                 base_url + page,
                             )
                             success = False
-                            break
+                            continue
                         self.logger.info(
-                            "Successfully logged into page -> %s.",
+                            "Successfully logged into page -> %s. Page title -> '%s'.",
                             base_url + page,
+                            browser_automation_object.get_title(),
                         )
                     case "get_page":
-                        page = automation.get("page", "")
+                        page = automation_step.get("page", "")
                         if not page:
                             self.logger.error(
-                                "Automation type -> '%s' requires page parameter. Stopping automation.",
-                                automation_type,
+                                "Automation step type -> '%s' requires 'page' parameter. Stopping automation.",
+                                automation_step_type,
                             )
                             success = False
                             break
-                        self.logger.info("Get page -> %s", base_url + page)
-                        if not browser_automation_object.get_page(url=page):
+                        volume = automation_step.get("volume", OTCS.VOLUME_TYPE_ENTERPRISE_WORKSPACE)
+                        path = automation_step.get("path", [])
+                        if path and volume:
+                            page_node = self._otcs.get_node_by_volume_and_path(
+                                volume_type=volume,
+                                path=path,
+                                create_path=False,
+                            )
+                            page_id = self._otcs.get_result_value(response=page_node, key="id")
+                            if not page_id:
+                                # if not parent_node:
+                                self.logger.error(
+                                    "%s automation -> '%s' has a page path that does not exist. Skipping...",
+                                    automation_type,
+                                    name,
+                                )
+                                success = False
+                                continue
+                            self.logger.info(
+                                "Resolved volume -> %d and page path -> %s to node ID -> %d", volume, path, page_id
+                            )
+                        else:
+                            page_id = None
+                        if "{}" in page and page_id:
+                            page = page.format(page_id)
+                        # Do we have a step-specific wait mechanism? If not, we pass None
+                        # then the browser automation will take the default configured for
+                        # the whole browser automation (see BrowserAutomation() constructor called above):
+                        wait_until = automation_step.get("wait_until", None)
+                        self.logger.info(
+                            "Load page -> %s (%s page navigation strategy is to wait until -> '%s')",
+                            base_url + page,
+                            "specific" if wait_until is not None else "default",
+                            wait_until if wait_until is not None else browser_automation_object.wait_until,
+                        )
+                        result = browser_automation_object.get_page(url=page, wait_until=wait_until)
+                        if not result:
                             self.logger.error(
-                                "Cannot get page -> %s. Stopping automation.",
+                                "Cannot load page -> %s. Skipping this step...",
                                 page,
                             )
                             success = False
-                            break
+                            continue
                         self.logger.info(
-                            "Successfully loaded page -> %s",
+                            "Successfully loaded page -> %s. Page title -> '%s'.",
                             base_url + page,
+                            browser_automation_object.get_title(),
                         )
                     case "click_elem":
-                        elem = automation.get("elem", "")
-                        if not elem:
+                        # We keep the deprecated "elem" syntax supported (for now)
+                        selector = automation_step.get("selector", automation_step.get("elem", ""))
+                        if not selector:
                             self.logger.error(
-                                "Automation type -> '%s' requires elem parameter. Stopping automation.",
-                                automation_type,
+                                "Automation step type -> '%s' requires 'selector' parameter. Stopping automation.",
+                                automation_step_type,
                             )
                             success = False
                             break
-                        find = automation.get("find", "id")
-                        show_error = automation.get("show_error", True)
-                        if not browser_automation_object.find_elem_and_click(
-                            find_elem=elem,
-                            find_method=find,
+                        # We keep the deprecated "find" syntax supported (for now)
+                        selector_type = automation_step.get("selector_type", automation_step.get("find", "id"))
+                        show_error = automation_step.get("show_error", True)
+                        navigation = automation_step.get("navigation", False)
+                        checkbox_state = automation_step.get("checkbox_state", None)
+                        # Do we have a step-specific wait mechanism? If not, we pass None
+                        # then the browser automation will take the default configured for
+                        # the whole browser automation (see BrowserAutomation() constructor called above):
+                        wait_until = automation_step.get("wait_until", None)
+                        role_type = automation_step.get("role_type", None)
+                        result = browser_automation_object.find_elem_and_click(
+                            selector=selector,
+                            selector_type=selector_type,
+                            role_type=role_type,
+                            desired_checkbox_state=checkbox_state,
+                            is_navigation_trigger=navigation,
+                            wait_until=wait_until,
                             show_error=show_error,
-                        ):
-                            self.logger.error(
-                                "Cannot find clickable element -> '%s' on current page. Stopping automation.",
-                                elem,
+                        )
+                        if not result:
+                            message = "Cannot find clickable element with selector -> '{}' ({}) on current page. Skipping this step...".format(
+                                selector, selector_type
                             )
-                            success = False
-                            break
+                            if show_error:
+                                self.logger.error(message)
+                                success = False
+                            else:
+                                self.logger.warning(message)
+                            continue
                         self.logger.info(
-                            "Successfully clicked element -> '%s'",
-                            elem,
+                            "Successfully clicked %s element selected by -> '%s' (%s)",
+                            "navigational" if navigation else "non-navigational",
+                            selector,
+                            selector_type,
                         )
                     case "set_elem":
-                        elem = automation.get("elem", "")
-                        if not elem:
+                        # We keep the deprecated "elem" syntax supported (for now)
+                        selector = automation_step.get("selector", automation_step.get("elem", ""))
+                        if not selector:
                             self.logger.error(
-                                "Automation type -> '%s' requires elem parameter",
-                                automation_type,
+                                "Automation step type -> '%s' requires 'selector' parameter. Stopping automation.",
+                                automation_step_type,
                             )
                             success = False
                             break
-                        find = automation.get("find", "id")
-                        value = automation.get("value", "")
+                        # We keep the deprecated "find" syntax supported (for now)
+                        selector_type = automation_step.get("selector_type", automation_step.get("find", "id"))
+                        role_type = automation_step.get("role_type", None)
+                        value = automation_step.get("value", "")
                         if not value:
                             self.logger.error(
-                                "Automation of type -> '%s' for element -> '%s' requires value parameter. Stopping automation.",
-                                automation_type,
-                                elem,
+                                "Automation step type -> '%s' for element selected by -> '%s' (%s) requires 'value' parameter. Stopping automation.",
+                                automation_step_type,
+                                selector,
+                                selector_type,
                             )
                             success = False
                             break
                         # we also support replacing placeholders that are
                         # enclosed in double % characters like %%OTCS_RESOURCE_ID%%:
                         value = self.replace_placeholders(value)
-                        if not browser_automation_object.find_elem_and_set(
-                            find_elem=elem,
-                            elem_value=value,
-                            find_method=find,
-                        ):
+                        show_error = automation_step.get("show_error", True)
+                        result = browser_automation_object.find_elem_and_set(
+                            selector=selector,
+                            selector_type=selector_type,
+                            role_type=role_type,
+                            value=value,
+                            show_error=show_error,
+                        )
+                        if not result:
+                            message = "Cannot set element selected by -> '{}' ({}) to value -> '{}'. Skipping this step...".format(
+                                selector, selector_type, value
+                            )
+                            if show_error:
+                                self.logger.error(message)
+                                success = False
+                            else:
+                                self.logger.warning(message)
+                            continue
+                        self.logger.info(
+                            "Successfully set element selected by -> '%s' (%s) to value -> '%s'.",
+                            selector,
+                            selector_type,
+                            value,
+                        )
+                    case "check_elem":
+                        # We keep the deprecated "elem" syntax supported (for now)
+                        selector = automation_step.get("selector", automation_step.get("elem", ""))
+                        if not selector:
                             self.logger.error(
-                                "Cannot find element -> '%s' on current page to set value -> '%s'. Stopping automation.",
-                                elem,
-                                value,
+                                "Automation step type -> '%s' requires 'selector' parameter. Stopping automation.",
+                                automation_step_type,
                             )
                             success = False
                             break
+                        # We keep the deprecated "find" syntax supported (for now)
+                        selector_type = automation_step.get("selector_type", automation_step.get("find", "id"))
+                        role_type = automation_step.get("role_type", None)
+                        value = automation_step.get("value", None)
+                        attribute = automation_step.get("attribute", "")
+                        substring = automation_step.get("substring", False)
+                        min_count = automation_step.get("min_count", 1)
+                        want_exist = automation_step.get("want_exist", True)
+                        wait_time = automation_step.get("wait_time", 0.0)
+                        if value:
+                            # we also support replacing placeholders that are
+                            # enclosed in double % characters like %%OTCS_RESOURCE_ID%%:
+                            value = self.replace_placeholders(value)
+                        (result, count) = browser_automation_object.check_elems_exist(
+                            selector=selector,
+                            selector_type=selector_type,
+                            role_type=role_type,
+                            value=value,
+                            attribute=attribute,
+                            substring=substring,
+                            min_count=min_count,
+                            wait_time=wait_time,  # time to wait before the check is actually done
+                        )
+                        # Check if we didn't get what we want:
+                        if (not result and want_exist) or (result and not want_exist):
+                            self.logger.error(
+                                "%s %s%s%s on current page. Test failed.%s",
+                                "Cannot find" if not result else "Found",
+                                "{} elements with selector -> '{}' ({})".format(min_count, selector, selector_type)
+                                if min_count > 1
+                                else "an element with selector -> '{}' ({})".format(selector, selector_type),
+                                " with {}value -> '{}'".format("substring-" if substring else "", value)
+                                if value
+                                else "",
+                                " in attribute -> '{}'".format(attribute) if attribute else "",
+                                " Found {}{} occurences.".format(count, " undesirable" if not want_exist else ""),
+                            )
+                            success = False
+                            continue
+                            # Don't break here! We want to do all existance tests!
                         self.logger.info(
-                            "Successfully set element -> '%s' to value -> '%s'.",
-                            elem,
-                            value,
+                            "Successfully passed %sexistence test for %s%s%s on current page.",
+                            "non-" if not want_exist else "",
+                            "{} elements with selector -> '{}' ({})".format(min_count, selector, selector_type)
+                            if min_count > 1
+                            else "an element with selector -> '{}' ({})".format(selector, selector_type),
+                            " with {}value -> '{}'".format("substring-" if substring else "", value) if value else "",
+                            " in attribute -> '{}'".format(attribute) if attribute else "",
                         )
                     case _:
                         self.logger.error(
-                            "Illegal automation step type -> '%s' in browser automation!",
-                            automation_type,
+                            "Illegal automation step type -> '%s' in %s automation!",
+                            automation_step_type,
+                            automation_type.lower(),
                         )
                         success = False
                         break
+                # end match automation_step_type:
+                first_step = False
+            # end for automation_step in automation_steps:
+            browser_automation_object.end_session()
+        # end for browser_automation in browser_automations:
 
         if check_status:
             self.write_status_file(
@@ -18097,6 +19253,13 @@ class Payload:
             "otcs_root_node_ids",
             data_source.get("otcs_root_node_id"),
         )
+
+        if not otcs_root_node_ids:
+            self.logger.error(
+                "Content Server root node ID(s) for traversal are missing in payload of bulk data source. Cannot load data!",
+            )
+            return None
+
         # Filter workspace by depth under the given root (only consider items as workspace if they have the right depth in the hierarchy):
         otcs_filter_workspace_depth = data_source.get("otcs_filter_workspace_depth", 0)
         # Filter workspace by subtype (only consider items as workspace if they have the right technical subtype):
@@ -18134,16 +19297,18 @@ class Payload:
         # List of node IDs to exclude in traversing the folders in the OTCS data source:
         otcs_exclude_node_ids = data_source.get("otcs_exclude_node_ids")
 
-        if not otcs_root_node_ids:
-            self.logger.error(
-                "Content Server root node IDs for traversal are missing in payload of bulk data source. Cannot load data!",
-            )
-            return None
-
         # Document handling parameters:
         otcs_download_documents = data_source.get("otcs_download_documents", True)
         otcs_skip_existing_downloads = data_source.get("otcs_skip_existing_downloads", True)
         otcs_extract_zip = data_source.get("extract_zip", False)
+        # The following parameter controls how column names are constructed. If it is true, then
+        # attribute columns for workspaces and items will use the category ID in the column name.
+        # Wokspace attributes always start with "workspace_cat_". Item attributes start with item_cat_".
+        # If the value of 'otcs_use_numeric_category_identifier' is False then the category name
+        # is converted to lower-case and spaces and non-alphanumeric characters are replaced with "_".
+        # Example with otcs_use_numeric_category_identifier = True: workspace_cat_47110815_10
+        # Example with otcs_use_numeric_category_identifier = False: workspace_cat_customer_use_case_10
+        otcs_use_numeric_category_identifier = data_source.get("otcs_use_numeric_category_identifier", True)
 
         # Ensure Root_node_id is a list of integers
         if not isinstance(otcs_root_node_ids, list):
@@ -18160,6 +19325,7 @@ class Payload:
             password=otcs_password,
             thread_number=otcs_thread_number,
             download_dir=otcs_download_dir,
+            use_numeric_category_identifier=otcs_use_numeric_category_identifier,
             logger=self.logger,
         )
 
@@ -19907,8 +21073,16 @@ class Payload:
             is_list_in_string = False
 
             # The data source loader may have written a real python list into the value
-            # In this case the value includes square brackets [...]
-            if value.startswith("[") and value.endswith("]"):
+            # In this case the string value includes square brackets [...]
+            # We only do  this if the actual type of the value is string and the
+            # proposed value (value_type) is not string:
+            if (
+                isinstance(value, str)  # it is a string
+                and value.startswith("[")  # it starts with a list indicator character
+                and value.endswith("]")  # it ends with a list indicator character
+                and category_item.get("value_type", "")
+                != "string"  # it is NOT explicitly stated it should remain a string
+            ):
                 # Remove the square brackets and declare it is a list!
                 try:
                     value = literal_eval(value)
@@ -20995,7 +22169,7 @@ class Payload:
                         workspace_id,
                     )
 
-                    self._otcs_frontend.feme_embedd_metadata(
+                    self._otcs_frontend.aviator_embed_metadata(
                         node_id=workspace_id,
                         wait_for_completion=False,
                     )
@@ -21137,7 +22311,7 @@ class Payload:
                         workspace_id,
                     )
 
-                    self._otcs_frontend.feme_embedd_metadata(
+                    self._otcs_frontend.aviator_embed_metadata(
                         node_id=workspace_id,
                         wait_for_completion=False,
                     )
@@ -23032,7 +24206,7 @@ class Payload:
             operations = bulk_document.get("operations", ["create"])
 
             self.logger.info(
-                "Bulk create documents (name field -> %s. Operations -> %s.)",
+                "Bulk create documents (name field -> '%s', operations -> %s)",
                 name_field,
                 str(operations),
             )
@@ -24860,7 +26034,7 @@ class Payload:
                             document_id,
                         )
 
-                        self._otcs_frontend.feme_embedd_metadata(
+                        self._otcs_frontend.aviator_embed_metadata(
                             node_id=document_id,
                             workspace_metadata=False,
                             document_metadata=aviator_metadata,
@@ -25001,7 +26175,7 @@ class Payload:
                             document_id,
                         )
 
-                        self._otcs_frontend.feme_embedd_metadata(
+                        self._otcs_frontend.aviator_embed_metadata(
                             node_id=document_id,
                             workspace_metadata=False,
                             document_metadata=aviator_metadata,
@@ -26441,7 +27615,7 @@ class Payload:
 
     # end method definition
 
-    def process_feme(self, section_name: str = "feme") -> bool:
+    def process_avts_questions(self, section_name: str = "avtsQuestions") -> bool:
         """Process Aviator Search repositories.
 
         Args:
@@ -26458,7 +27632,69 @@ class Payload:
 
         """
 
-        if not self._feme:
+        if not self._avts_questions:
+            self.logger.info(
+                "Payload section -> '%s' is empty. Skipping...",
+                section_name,
+            )
+            return True
+
+        # If this payload section has been processed successfully before we
+        # can return True and skip processing it once more:
+        if self.check_status_file(payload_section_name=section_name):
+            return True
+
+        success: bool = True
+
+        self._avts.authenticate()
+
+        if not self._avts_questions.get("enabled", True):
+            self.logger.info(
+                "Payload section -> '%s' is not enabled. Skipping...",
+                section_name,
+            )
+            return True
+
+        questions = self._avts_questions.get("questions", [])
+        self.logger.info("Sample questions -> %s", questions)
+
+        response = self._avts.set_questions(questions=questions)
+
+        if response is None:
+            self.logger.error("Aviator Search setting questions failed")
+            success = False
+        else:
+            self.logger.info("Aviator Search questions set succesfully")
+            self.logger.debug("%s", response)
+
+        self.write_status_file(
+            success=success,
+            payload_section_name=section_name,
+            payload_section=self._avts_questions,
+        )
+
+        return success
+
+    # end method definition
+
+    def process_embeddings(self, section_name: str = "embeddings") -> bool:
+        """Process additional Aviator embeddings.
+
+        Args:
+            section_name (str, optional):
+                The name of the payload section. It can be overridden
+                for cases where multiple sections of same type
+                are used (e.g. the "Post" sections).
+                This name is also used for the "success" status
+                files written to the Admin Personal Workspace.
+
+        Returns:
+            bool:
+                True, if payload has been processed without errors, False otherwise.
+
+        """
+
+        if not self._embeddings:
             self.logger.info(
                 "Payload section -> '%s' is empty. Skipping...",
                 section_name,
@@ -26472,40 +27708,95 @@ class Payload:
 
         success: bool = True
 
-        for item in self._feme:
+        for embedding in self._embeddings:
             # Check if item has been explicitly disabled in payload
             # (enabled = false). In this case we skip the element:
-            if not item.get("enabled", True):
+            if not embedding.get("enabled", True):
                 self.logger.info(
-                    "Payload for item -> '%s' is disabled for FEME. Skipping...",
-                    item,
+                    "Payload for embedding -> '%s' is disabled for FEME. Skipping...",
+                    str(embedding),
                 )
                 continue
 
-            if item.get("id", None) is None:
+            # Backwards-compatibility for old syntax "documents":
+            if "document_metadata" not in embedding:
+                document_metadata = bool(embedding.get("documents", False))
+            else:
+                document_metadata = bool(embedding.get("document_metadata", False))
+
+            # Backwards-compatibility for old syntax "workspaces":
+            if "workspace_metadata" not in embedding:
+                workspace_metadata = bool(embedding.get("workspaces", False))
+            else:
+                workspace_metadata = bool(embedding.get("workspace_metadata", False))
+
+            wait_for_completion = bool(embedding.get("wait_for_completion", True))
+            crawl = bool(embedding.get("crawl", False))
+            images = bool(embedding.get("images", False))
+
+            # We support 3 ways to determine the node ID(s):
+            # 1. Node ID is specified directly in the payload using 'id = "..."'
+            # 2. Node is is specified via a nickname of the node using 'nickname = "..."'
+            # 3. Nodes are specified via the name of a workspace type. In this
+            #    case all nodes of workspace instances are considered.
+
+            node_id = None
+
+            if embedding.get("id", None) is None and "nickname" in embedding:
                 response = self._otcs.get_node_from_nickname(
-                    nickname=item.get("nickname"),
+                    nickname=embedding.get("nickname"),
                 )
                 node_id = self._otcs.get_result_value(response, "id")
 
             else:
-                node_id = item.get("id")
+                node_id = embedding.get("id", None)
                 response = None
 
-            self._otcs.feme_embedd_metadata(
-                node_id=node_id,
-                node=response,
-                wait_for_completion=bool(item.get("wait_for_completion")),
-                crawl=bool(item.get("crawl")),
-                document_metadata=bool(item.get("documents")),
-                workspace_metadata=bool(item.get("workspaces")),
-                images=bool(item.get("images")),
-            )
+            if node_id:
+                result = self._otcs.aviator_embed_metadata(
+                    node_id=node_id,
+                    node=response,
+                    wait_for_completion=wait_for_completion,
+                    crawl=crawl,
+                    document_metadata=document_metadata,
+                    workspace_metadata=workspace_metadata,
+                    images=images,
+                )
+                if not result:
+                    success = False
+            elif "workspace_types" in embedding:
+                workspace_types = embedding["workspace_types"]
+                # Handle the case of a single workspace type name:
+                if isinstance(workspace_types, str):
+                    workspace_types = [workspace_types]
+                for workspace_type_name in workspace_types:
+                    self.logger.info(
+                        "Embedding metadata of workspace instances with type -> '%s'...", workspace_type_name
+                    )
+                    workspace_instances = self._otcs.get_workspace_instances_iterator(type_name=workspace_type_name)
+                    for workspace in workspace_instances:
+                        properties = workspace.get("data").get("properties")
+                        self.logger.info(
+                            "Embedding metadata of workspace instance -> '%s' (%s)",
+                            properties["name"],
+                            properties["id"],
+                        )
+                        result = self._otcs.aviator_embed_metadata(
+                            node_id=None,
+                            node=workspace,
+                            wait_for_completion=wait_for_completion,
+                            crawl=crawl,
+                            document_metadata=document_metadata,
+                            workspace_metadata=workspace_metadata,
+                            images=images,
+                        )
+                        if not result:
+                            success = False
 
         self.write_status_file(
             success=success,
             payload_section_name=section_name,
-            payload_section=self._feme,
+            payload_section=self._embeddings,
         )
 
         return success
@@ -28108,239 +29399,6 @@ class Payload:
 
     # end method definition
 
-    def appworks_resource_payload(
-        self,
-        org_name: str,
-        username: str,
-        password: str,
-    ) -> dict:
-        """Create a Python dict with the special payload we need for AppWorks.
-
-        Args:
-            org_name (str):
-                The name of the organization.
-            username (str):
-                The user name.
-            password (str):
-                The password.
-
-        Returns:
-            dict:
-                AppWorks specific payload.
-
-        """
-
-        additional_payload = {}
-        additional_payload["connectorid"] = "rest"
-        additional_payload["resourceType"] = "rest"
-        user_attribute_mapping = [
-            {
-                "sourceAttr": ["oTExternalID1"],
-                "destAttr": "__NAME__",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["displayname"],
-                "destAttr": "DisplayName",
-                "mappingFormat": "%s",
-            },
-            {"sourceAttr": ["mail"], "destAttr": "Email", "mappingFormat": "%s"},
-            {
-                "sourceAttr": ["oTTelephoneNumber"],
-                "destAttr": "Telephone",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["oTMobile"],
-                "destAttr": "Mobile",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["oTFacsimileTelephoneNumber"],
-                "destAttr": "Fax",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["oTStreetAddress,l,st,postalCode,c"],
-                "destAttr": "Address",
-                "mappingFormat": "%s%n%s %s %s%n%s",
-            },
-            {
-                "sourceAttr": ["oTCompany"],
-                "destAttr": "Company",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["ds-pwp-account-disabled"],
-                "destAttr": "AccountDisabled",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["oTExtraAttr9"],
-                "destAttr": "IsServiceAccount",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["custom:proxyConfiguration"],
-                "destAttr": "ProxyConfiguration",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["c"],
-                "destAttr": "Identity-CountryOrRegion",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["gender"],
-                "destAttr": "Identity-Gender",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["displayName"],
-                "destAttr": "Identity-DisplayName",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["oTStreetAddress"],
-                "destAttr": "Identity-Address",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["l"],
-                "destAttr": "Identity-City",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["mail"],
-                "destAttr": "Identity-Email",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["givenName"],
-                "destAttr": "Identity-FirstName",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["sn"],
-                "destAttr": "Identity-LastName",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["initials"],
-                "destAttr": "Identity-MiddleNames",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["oTMobile"],
-                "destAttr": "Identity-Mobile",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["postalCode"],
-                "destAttr": "Identity-PostalCode",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["st"],
-                "destAttr": "Identity-StateOrProvince",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["title"],
-                "destAttr": "Identity-title",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["physicalDeliveryOfficeName"],
-                "destAttr": "Identity-physicalDeliveryOfficeName",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["oTFacsimileTelephoneNumber"],
-                "destAttr": "Identity-oTFacsimileTelephoneNumber",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["notes"],
-                "destAttr": "Identity-notes",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["oTCompany"],
-                "destAttr": "Identity-oTCompany",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["oTDepartment"],
-                "destAttr": "Identity-oTDepartment",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["birthDate"],
-                "destAttr": "Identity-Birthday",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["cn"],
-                "destAttr": "Identity-UserName",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["Description"],
-                "destAttr": "Identity-UserDescription",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["oTTelephoneNumber"],
-                "destAttr": "Identity-Phone",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["displayName"],
-                "destAttr": "Identity-IdentityDisplayName",
-                "mappingFormat": "%s",
-            },
-        ]
-        additional_payload["userAttributeMapping"] = user_attribute_mapping
-        group_attribute_mapping = [
-            {
-                "sourceAttr": ["cn"],
-                "destAttr": "__NAME__",
-                "mappingFormat": '%js:function format(name) { return name.replace(/&/g,"-and-"); }',
-            },
-            {
-                "sourceAttr": ["description"],
-                "destAttr": "Description",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["description"],
-                "destAttr": "Identity-Description",
-                "mappingFormat": "%s",
-            },
-            {
-                "sourceAttr": ["displayName"],
-                "destAttr": "Identity-DisplayName",
-                "mappingFormat": "%s",
-            },
-        ]
-        additional_payload["groupAttributeMapping"] = group_attribute_mapping
-        additional_payload["connectorName"] = "REST (Generic)"
-        additional_payload["pcCreatePermissionAllowed"] = "true"
-        additional_payload["pcModifyPermissionAllowed"] = "true"
-        additional_payload["pcDeletePermissionAllowed"] = "false"
-        additional_payload["connectionParamInfo"] = [
-            {
-                "name": "fBaseURL",
-                "value": "http://appworks:8080/home/" + org_name + "/app/otdspush",
-            },
-            {"name": "fUsername", "value": username},
-            {"name": "fPassword", "value": password},
-        ]
-        return additional_payload
-
-    # end method definition
-
     def start_impersonation(self, username: str, otcs_object: OTCS | None = None) -> bool:
         """Impersonate to a defined user.