pyxecm 0.0.17__py3-none-any.whl → 0.0.19__py3-none-any.whl

pyxecm/payload.py

@@ -30,10 +30,18 @@ __init__ : class initializer
 replacePlaceholders: replace placeholder in admin config files
 initPayload: load and initialize the YAML payload
 getPayloadSection: delivers a section of the payload as a list of settings
+getAllGroupNames: construct a list of all group name
+checkStatusFile: check if the payload section has been processed before
+writeStatusFile: Write a status file into the Admin Personal Workspace in Extended ECM
+                 to indicate that the payload section has been deployed successfully
+determineGroupID: determine the id of a group - either from payload or from OTCS
+determineUserID: determine the id of a user - either from payload or from OTCS
+determineWorkspaceID: determine the nodeID of a workspace - either from payload or from OTCS
 
 processPayload: process payload (main method)
 processWebHooks: process list of web hooks
 processPartitions: process the OTDS partitions
+processPartitionLicenses: process the licenses that should be assigned to OTDS partitions (this includes existing partitions)
 processOAuthClients: process the OTDS OAuth clients
 processTrustedSites: process the OTDS trusted sites
 processSystemAttributes: process the OTDS system attributes
@@ -47,7 +55,6 @@ processTransportPackages: process Extended ECM transport packages
 processUserPhotos: process Extended ECM user photos (user profile)
 processUserPhotosM365: process user photos in payload and assign them to Microsoft 365 users.
 processWorkspaceTypes: process Extended ECM workspace types (needs to run after processTransportPackages)
-processWorkspaceTemplateRegistrations: register workspace templates as projects for Extended ECM for Engineering (deprecated)
 processWorkspaces: process Extended ECM workspace instances
 processWorkspaceRelationships: process Extended ECM workspace relationships
 processWorkspaceMembers: process Extended ECM workspace members (users and groups)
@@ -94,6 +101,8 @@ import logging
 import yaml
 import hcl2
 import re
+import time
+import json
 
 from urllib.parse import urlparse
 
@@ -101,6 +110,10 @@ from urllib.parse import urlparse
 import pyxecm.web as web
 import pyxecm.sap as sap
 
+from pyxecm.otcs import OTCS
+from pyxecm.otds import OTDS
+from pyxecm.otac import OTAC
+
 logger = logging.getLogger(os.path.basename(__file__))
 
 
@@ -109,12 +122,12 @@ class Payload(object):
 
     # _debug controls whether or not transport processing is
     # stopped if one transport fails:
-    _debug = False
-    _otcs = None
-    _otcs_backend = None
-    _otcs_frontend = None
-    _otac = None
-    _otds = None
+    _debug: bool = False
+    _otcs: OTCS = None
+    _otcs_backend: OTCS = None
+    _otcs_frontend: OTCS = None
+    _otac: OTAC = None
+    _otds: OTDS = None
     _otiv = None
     _k8s = None
     _web = None
@@ -197,15 +210,18 @@ class Payload(object):
 
     _placeholder_values = {}
 
+    _otcs_restart_callback = None
+
     def __init__(
         self,
         payload_source: str,
         custom_settings_dir: str,
         k8s_object: object,
-        otds_object: object,
-        otac_object: object,
-        otcs_backend_object: object,
-        otcs_frontend_object: object,
+        otds_object: OTDS,
+        otac_object: OTAC,
+        otcs_backend_object: OTCS,
+        otcs_frontend_object: OTCS,
+        otcs_restart_callback: callable,
         otiv_object: object,
         m365_object: object,
         placeholder_values: dict = {},
@@ -216,10 +232,11 @@ class Payload(object):
         Args:
             payload_source (string): path or URL to payload source file
             k8s_object (object): Kubernetes object
-            otds_object (object): OTDS object
-            otac_object (object): OTAC object
-            otcs_backend_object (object): OTCS backend object
-            otcs_frontend_object (object): OTCS frontend object
+            otds_object (OTDS): OTDS object
+            otac_object (OTAC): OTAC object
+            otcs_backend_object (OTCS): OTCS backend object
+            otcs_frontend_object (OTCS): OTCS frontend object
+            otcs_restart_callback (callable): function to call if OTCS service needs a restart
             otiv_object (object): OTIV object
             m365_object (object): M365 object to talk to Microsoft Graph API
             placeholder_values (dict): dictionary of placeholder values to be replaced in admin settings
@@ -238,6 +255,7 @@ class Payload(object):
         self._m365 = m365_object
         self._custom_settings_dir = custom_settings_dir
         self._placeholder_values = placeholder_values
+        self._otcs_restart_callback = otcs_restart_callback
 
         self._http_object = web.HTTP()
 
@@ -357,9 +375,6 @@ class Payload(object):
         self._permissions = self.getPayloadSection("permissions")
         self._permissions_post = self.getPayloadSection("permissionsPost")
         self._assignments = self.getPayloadSection("assignments")
-        self._workspace_template_registrations = self.getPayloadSection(
-            "workspaceTemplateRegistrations",
-        )
         self._security_clearances = self.getPayloadSection("securityClearances")
         self._supplemental_markings = self.getPayloadSection("supplementalMarkings")
         self._records_management_settings = self.getPayloadSection(
@@ -403,8 +418,269 @@ class Payload(object):
         # end method definition
 
     def getAllGroupNames(self) -> list:
+        """Construct a list of all group name
+
+        Returns:
+            list: list of all group names
+        """
         return [group.get("name") for group in self._groups]
 
+        # end method definition
+
+    def checkStatusFile(
+        self, payload_section_name: str, payload_specific: bool = True
+    ) -> bool:
+        """Check if the payload section has been processed before. This is
+           done by checking the existance of a text file in the Admin Personal
+           workspace in Extended ECM with the name of the payload section.
+
+        Args:
+            payload_section_name (str): name of the payload section. This
+                                        is used to construct the file name
+            payload_specific (bool): whether or not the success should be specific for
+                                     each payload file or if success is "global" - like for the deletion
+                                     of the existing M365 teams (which we don't want to execute per
+                                     payload file)
+        Returns:
+            bool: True if the payload has been processed successfully before, False otherwise
+        """
+
+        logger.info(
+            "Check if payload section -> {} has been processed successfully before...".format(
+                payload_section_name
+            )
+        )
+
+        response = self._otcs.getNodeByVolumeAndPath(
+            142
+        )  # write to Personal Workspace of Admin
+        target_folder_id = self._otcs.getResultValue(response, "id")
+        if not target_folder_id:
+            target_folder_id = 2004  # use Personal Workspace of Admin as fallback
+
+        # Some sections are actually not payload specific like teamsM365Cleanup
+        # we don't want external payload runs to re-apply this processing:
+        if payload_specific:
+            file_name = os.path.basename(self._payload_source)  # remove directories
+            file_name = os.path.splitext(file_name)[0]  # remove file suffix
+            file_name = "success_" + file_name + "_" + payload_section_name + ".txt"
+        else:
+            file_name = "success_" + payload_section_name + ".txt"
+
+        status_document = self._otcs.getNodeByParentAndName(
+            parent_id=target_folder_id, name=file_name, show_error=False
+        )
+        if status_document and status_document["results"]:
+            name = self._otcs.getResultValue(status_document, "name")
+            if name == file_name:
+                logger.info(
+                    "Payload section -> {} has been processed successfully before. Skipping...".format(
+                        payload_section_name
+                    )
+                )
+                return True
+        logger.info(
+            "Payload section -> {} has not been processed successfully before. Processing...".format(
+                payload_section_name
+            )
+        )
+        return False
+
+        # end method definition
+
+    def writeStatusFile(
+        self,
+        payload_section_name: str,
+        payload_section: list,
+        payload_specific: bool = True,
+    ) -> bool:
+        """Write a status file into the Admin Personal Workspace in Extended ECM
+           to indicate that the payload section has been deployed successfully.
+           This speeds up the customizing process in case the customizer pod
+           is restarted.
+
+        Args:
+            payload_section_name (str): name of the payload section
+            payload_section (list): payload section content - this is written as JSon into the file
+            payload_specific (bool): whether or not the success should be specific for
+                                     each payload file or if success is "global" - like for the deletion
+                                     of the existing M365 teams (which we don't want to execute per
+                                     payload file)
+        Returns:
+            bool: True if the status file as been upladed to Extended ECM successfully, False otherwise
+        """
+
+        response = self._otcs.getNodeByVolumeAndPath(
+            142
+        )  # write to Personal Workspace of Admin (with Volume Type ID = 142)
+        target_folder_id = self._otcs.getResultValue(response, "id")
+        if not target_folder_id:
+            target_folder_id = 2004  # use Personal Workspace of Admin as fallback
+
+        # Some sections are actually not payload specific like teamsM365Cleanup
+        # we don't want external payload runs to re-apply this processing:
+        if payload_specific:
+            file_name = os.path.basename(self._payload_source)  # remove directories
+            file_name = os.path.splitext(file_name)[0]  # remove file suffix
+            file_name = "success_" + file_name + "_" + payload_section_name + ".txt"
+        else:
+            file_name = "success_" + payload_section_name + ".txt"
+        full_path = "/tmp/" + file_name
+
+        with open(full_path, mode="w") as localfile:
+            localfile.write(json.dumps(payload_section, indent=2))
+
+        response = self._otcs.uploadFileToParent(
+            file_url=full_path,
+            file_name=file_name,
+            mime_type="text/plain",
+            parent_id=target_folder_id,
+        )
+
+        if response:
+            logger.info(
+                "Payload section -> {} has been completed successfully!".format(
+                    payload_section_name
+                )
+            )
+            return True
+
+        return False
+
+        # end method definition
+
+    def determineGroupID(self, group: dict) -> int:
+        """Determine the id of a group - either from payload or from OTCS.
+           If the group is found in OTCS write back the ID into the payload.
+
+        Args:
+            group (dict): group payload element
+
+        Returns:
+            int: group ID
+        Side Effects:
+            the group items are modified by adding an "id" dict element that
+            includes the technical ID of the group in Extended ECM
+        """
+
+        if "id" in group:
+            return group["id"]
+
+        if not "name" in group:
+            logger.error("Group needs a name to lookup the ID.")
+            return 0
+        group_name = group["name"]
+
+        existing_groups = self._otcs.getGroup(name=group_name)
+        if not existing_groups or not existing_groups["data"]:
+            logger.info(
+                "Cannot find an existing group with name -> {}".format(group_name)
+            )
+            return 0
+
+        # Get list of all matching groups:
+        existing_groups_list = existing_groups["data"]
+        # Find the group with the exact match of the name:
+        existing_group = next(
+            (item for item in existing_groups_list if item["name"] == group_name),
+            None,
+        )
+        # Have we found an exact match?
+        if existing_group:
+            group["id"] = existing_group["id"]
+            return group["id"]
+        else:
+            logger.info(
+                "Did not find an existing group with name -> {}".format(group_name)
+            )
+            return 0
+
+        # end method definition
+
+    def determineUserID(self, user: dict):
+        """Determine the id of a group - either from payload or from OTCS
+           If the user is found in OTCS write back the ID into the payload.
+
+        Args:
+            user (dict): user payload element
+
+        Returns:
+            int: user ID
+        Side Effects:
+            the user items are modified by adding an "id" dict element that
+            includes the technical ID of the user in Extended ECM
+        """
+
+        if "id" in user:
+            return user["id"]
+
+        if not "name" in user:
+            logger.error("User needs a login name to lookup the ID.")
+            return 0
+        user_name = user["name"]
+
+        existing_users = self._otcs.getUser(name=user_name)
+        if not existing_users or not existing_users["data"]:
+            logger.info(
+                "Cannot find an existing user with name -> {}".format(user_name)
+            )
+            return 0
+
+        # Get list of all matching users:
+        existing_users_list = existing_users["data"]
+        # Find the group with the exact match of the name:
+        existing_user = next(
+            (item for item in existing_users_list if item["name"] == user_name),
+            None,
+        )
+        # Have we found an exact match?
+        if existing_user:
+            user["id"] = existing_user["id"]
+            return user["id"]
+        else:
+            logger.info(
+                "Did not find an existing user with name -> {}".format(user_name)
+            )
+            return 0
+
+        # end method definition
+
+    def determineWorkspaceID(self, workspace: dict):
+        """Determine the nodeID of a workspace - either from payload or from OTCS"""
+
+        """Determine the id of a group - either from payload or from OTCS
+           If the user is found in OTCS write back the ID into the payload.
+
+        Args:
+            workspace (dict): workspace payload element
+
+        Returns:
+            int: workspace Node ID
+        Side Effects:
+            the workspace items are modified by adding an "nodeId" dict element that
+            includes the node ID of the workspace in Extended ECM
+        """
+
+        if "nodeId" in workspace:
+            return workspace["nodeId"]
+
+        response = self._otcs.getWorkspaceByTypeAndName(
+            workspace["type_name"], workspace["name"]
+        )
+        workspace_id = self._otcs.getResultValue(response, "id")
+        if workspace_id:
+            workspace["nodeId"] = workspace_id
+            return workspace_id
+        else:
+            logger.warning(
+                "Workspace of type -> {} and name -> {} does not exist.".format(
+                    workspace["type_name"], workspace["name"]
+                )
+            )
+            return 0
+
+        # end method definition
+
     def processPayload(self):
         """Main method to process a payload file.
 
@@ -430,12 +706,16 @@ class Payload(object):
                     logger.info(
                         "========== Process Web Hooks (post) ===================="
                     )
-                    self.processWebHooks(self._webhooks_post)
+                    self.processWebHooks(self._webhooks_post, "webHooksPost")
                 case "partitions":
                     logger.info(
                         "========== Process OTDS Partitions ====================="
                     )
                     self.processPartitions()
+                    logger.info(
+                        "========== Assign OTCS Licenses to Partitions =========="
+                    )
+                    self.processPartitionLicenses()
                 case "oauthClients":
                     logger.info(
                         "========== Process OTDS OAuth Clients =================="
@@ -456,6 +736,11 @@ class Payload(object):
                         "========== Process OTCS Groups ========================="
                     )
                     self.processGroups()
+                    # Add all groups with ID the a lookup dict for placeholder replacements
+                    # in adminSetting. This also updates the payload with group IDs from OTCS
+                    # if the group already exists in Extended ECM. This is important especially
+                    # if the customizer pod is restarted / run multiple times:
+                    self.processGroupPlaceholders()
                     if self._m365:
                         logger.info(
                             "========== Cleanup existing MS Teams ==================="
@@ -470,6 +755,11 @@ class Payload(object):
                         "========== Process OTCS Users =========================="
                     )
                     self.processUsers()
+                    # Add all users with ID the a lookup dict for placeholder replacements
+                    # in adminSetting. This also updates the payload with user IDs from OTCS
+                    # if the user already exists in Extended ECM. This is important especially
+                    # if the cutomizer pod is restarted / run multiple times:
+                    self.processUserPlaceholders()
                     logger.info(
                         "========== Assign OTCS Licenses to Users ==============="
                     )
@@ -505,14 +795,16 @@ class Payload(object):
                         self.processTeamsM365()
                 case "adminSettings":
                     logger.info(
-                        "========== Process OTCS LLConfig Settings (1) =========="
+                        "========== Process Administration Settings (1) ========="
                     )
                     self.processAdminSettings(self._admin_settings)
                 case "adminSettingsPost":
                     logger.info(
-                        "========== Process OTCS LLConfig Settings (2) =========="
+                        "========== Process Administration Settings (2) ========="
+                    )
+                    self.processAdminSettings(
+                        self._admin_settings_post, "adminSettingsPost"
                     )
-                    self.processAdminSettings(self._admin_settings_post)
                 case "execPodCommands":
                     logger.info(
                         "========== Process Pod Commands ========================"
@@ -522,11 +814,15 @@ class Payload(object):
                     logger.info(
                         "========== Process CS Apps (backend) ==================="
                     )
-                    self.processCSApplications()
+                    self.processCSApplications(
+                        self._otcs_backend, section_name="csApplicationsBackend"
+                    )
                     logger.info(
                         "========== Process CS Apps (frontend) =================="
                     )
-                    self.processCSApplications(self._otcs_frontend)
+                    self.processCSApplications(
+                        self._otcs_frontend, section_name="csApplicationsFrontend"
+                    )
                 case "externalSystems":
                     logger.info(
                         "========== Process External System Connections ========="
@@ -547,7 +843,9 @@ class Payload(object):
                     logger.info(
                         "========== Process Content Transport Packages =========="
                     )
-                    self.processTransportPackages(self._content_transport_packages)
+                    self.processTransportPackages(
+                        self._content_transport_packages, "contentTransportPackages"
+                    )
                 case "transportPackagesPost":
                     # if self._m365:
                     #     logger.info(
@@ -557,12 +855,9 @@ class Payload(object):
                     logger.info(
                         "========== Process Transport Packages (post) ==========="
                     )
-                    self.processTransportPackages(self._transport_packages_post)
-                case "workspaceTemplateRegistrations":
-                    logger.info(
-                        "========== Register Workspace Templates ================"
+                    self.processTransportPackages(
+                        self._transport_packages_post, "transportPackagesPost"
                     )
-                    self.processWorkspaceTemplateRegistrations()
                 case "workspaces":
                     logger.info(
                         "========== Process Workspaces =========================="
@@ -586,7 +881,8 @@ class Payload(object):
                             (
                                 item
                                 for item in self._external_systems
-                                if item["external_system_type"] == "SAP"
+                                if item.get("external_system_type")
+                                and item["external_system_type"] == "SAP"
                             ),
                             None,
                         )
@@ -615,7 +911,7 @@ class Payload(object):
                     logger.info(
                         "========== Process Web Reports (post) =================="
                     )
-                    self.processWebReports(self._web_reports_post)
+                    self.processWebReports(self._web_reports_post, "webReportsPost")
                 case "additionalGroupMemberships":
                     logger.info(
                         "========== Process additional group members for OTDS ==="
@@ -640,7 +936,7 @@ class Payload(object):
                     logger.info(
                         "========== Process Items (post) ========================"
                     )
-                    self.processItems(self._items_post)
+                    self.processItems(self._items_post, "itemsPost")
                 case "permissions":
                     logger.info(
                         "========== Process Permissions ========================="
@@ -687,6 +983,23 @@ class Payload(object):
                             payload_section["name"]
                         )
                     )
+            payload_section_restart = payload_section.get("restart", False)
+            if payload_section_restart:
+                logger.info(
+                    "Payload section -> {} requests a restart of OTCS services...".format(
+                        payload_section["name"]
+                    )
+                )
+                # Restart OTCS frontend and backend pods:
+                self._otcs_restart_callback(self._otcs_backend, self._k8s)
+                # give some additional time to make sure service is responsive
+                time.sleep(30)
+            else:
+                logger.info(
+                    "Payload section -> {} does not require a restart of OTCS services".format(
+                        payload_section["name"]
+                    )
+                )
 
         if self._users:
             logger.info("========== Process User Profile Photos =================")
@@ -701,22 +1014,35 @@ class Payload(object):
 
         # end method definition
 
-    def processWebHooks(self, webhooks: list):
+    def processWebHooks(self, webhooks: list, section_name: str = "webHooks") -> bool:
         """Process Web Hooks in payload and do HTTP requests.
 
         Args:
             None
         Returns:
-            None
+            bool: True if payload has been processed without errors, False otherwise
         """
 
         if not webhooks:
-            return None
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+
+        # WE LET THIS RUN EACH TIME!
+        #        if self.checkStatusFile(section_name):
+        #            return True
+
+        success: bool = True
 
         for webhook in webhooks:
             url = webhook.get("url")
             if not url:
                 logger.info("Web Hook does not have a url - skipping...")
+                success = False
                 continue
 
             # Check if element has been disabled in payload (enabled = false).
@@ -744,21 +1070,40 @@ class Payload(object):
 
             self._http_object.httpRequest(url, method, payload, headers)
 
+        #        if success:
+        #            self.writeStatusFile(section_name, webhooks)
+
+        return success
+
         # end method definition
 
-    def processPartitions(self):
+    def processPartitions(self, section_name: str = "partitions") -> bool:
         """Process OTDS partitions in payload and create them in OTDS.
 
         Args:
             None
         Returns:
-            None
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._partitions:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for partition in self._partitions:
             partition_name = partition.get("name")
             if not partition_name:
                 logger.error("Partition does not have a name - skipping...")
+                success = False
                 continue
 
             # Check if element has been disabled in payload (enabled = false).
@@ -800,6 +1145,7 @@ class Payload(object):
                 logger.error(
                     "Failed to add OTDS partition -> {}".format(partition_name)
                 )
+                success = False
                 continue
 
             access_role = partition.get("access_role")
@@ -819,6 +1165,7 @@ class Payload(object):
                             partition_name, access_role
                         )
                     )
+                    success = False
                     continue
 
             # Partions may have an optional list of licenses in
@@ -832,9 +1179,10 @@ class Payload(object):
                     logger.error(
                         "Cannot find OTCS resource -> {}".format(otcs_resource_name)
                     )
+                    success = False
                     continue
                 otcs_resource_id = otcs_resource["resourceID"]
-                license_name = "Extended ECM"
+                license_name = "EXTENDED_ECM"
                 for license_feature in partition_specific_licenses:
                     assigned_license = self._otds.assignPartitionToLicense(
                         partition_name,
@@ -849,6 +1197,7 @@ class Payload(object):
                                 partition_name, license_feature, license_name
                             )
                         )
+                        success = False
                     else:
                         logger.info(
                             "Successfully assigned partition -> {} to license feature -> {} of license -> {}".format(
@@ -856,21 +1205,144 @@ class Payload(object):
                             )
                         )
 
+        if success:
+            self.writeStatusFile(section_name, self._partitions)
+
+        return success
+
         # end method definition
 
-    def processOAuthClients(self):
-        """Process OTDS OAuth clients in payload and create them in OTDS.
+    def processPartitionLicenses(self, section_name: str = "partitionLicenses") -> bool:
+        """Process the licenses that should be assigned to OTDS partitions
+           (this includes existing partitions).
 
         Args:
             None
         Returns:
+            bool: True if payload has been processed without errors, False otherwise
+        """
+
+        if not self._partitions:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
+        for partition in self._partitions:
+            partition_name = partition.get("name")
+            if not partition_name:
+                logger.error("Partition does not have a name - skipping...")
+                success = False
+                continue
+
+            # Check if element has been disabled in payload (enabled = false).
+            # In this case we skip the element:
+            if "enabled" in partition and not partition["enabled"]:
+                logger.info(
+                    "Payload for Partition -> {} is disabled. Skipping...".format(
+                        partition_name
+                    )
+                )
+                continue
+
+            response = self._otds.getPartition(partition_name, show_error=True)
+            if not response:
+                logger.error(
+                    "Partition -> {} does not exist. Skipping...".format(partition_name)
+                )
+                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.getResource(otcs_resource_name)
+                if not otcs_resource:
+                    logger.error(
+                        "Cannot find OTCS resource -> {}".format(otcs_resource_name)
+                    )
+                    success = False
+                    continue
+                otcs_resource_id = otcs_resource["resourceID"]
+                license_name = "EXTENDED_ECM"
+                for license_feature in partition_specific_licenses:
+                    if self._otds.isPartitionLicensed(
+                        partition_name=partition_name,
+                        resource_id=otcs_resource_id,
+                        license_feature=license_feature,
+                        license_name=license_name,
+                    ):
+                        logger.info(
+                            "Partition -> {} is already licensed for -> {} ({})".format(
+                                partition_name, license_name, license_feature
+                            )
+                        )
+                        continue
+                    assigned_license = self._otds.assignPartitionToLicense(
+                        partition_name,
+                        otcs_resource_id,
+                        license_feature,
+                        license_name,
+                    )
+
+                    if not assigned_license:
+                        logger.error(
+                            "Failed to assign partition -> {} to license feature -> {} of license -> {}!".format(
+                                partition_name, license_feature, license_name
+                            )
+                        )
+                        success = False
+                    else:
+                        logger.info(
+                            "Successfully assigned partition -> {} to license feature -> {} of license -> {}".format(
+                                partition_name, license_feature, license_name
+                            )
+                        )
+
+        if success:
+            self.writeStatusFile(section_name, self._partitions)
+
+        return success
+
+        # end method definition
+
+    def processOAuthClients(self, section_name: str = "oauthClients") -> bool:
+        """Process OTDS OAuth clients in payload and create them in OTDS.
+
+        Args:
             None
+        Returns:
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._oauth_clients:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for oauth_client in self._oauth_clients:
             client_name = oauth_client.get("name")
             if not client_name:
                 logger.error("OAuth client does not have a name - skipping...")
+                success = False
                 continue
 
             # Check if element has been disabled in payload (enabled = false).
@@ -929,6 +1401,7 @@ class Payload(object):
                 logger.error(
                     "Failed to add OTDS OAuth client -> {}".format(client_name)
                 )
+                success = False
                 continue
 
             client_secret = response.get("secret")
@@ -943,83 +1416,241 @@ class Payload(object):
                 client_name, {"description": client_description}
             )
 
+        if success:
+            self.writeStatusFile(section_name, self._oauth_clients)
+
+        return success
+
     #        self._otds.addOauthClientsToAccessRole()
 
     # end method definition
 
-    def processTrustedSites(self):
+    def processTrustedSites(self, section_name: str = "trustedSites") -> bool:
         """Process OTDS trusted sites in payload and create them in OTDS.
 
         Args:
             None
         Returns:
-            None
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._trusted_sites:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for trusted_site in self._trusted_sites:
-            self._otds.addTrustedSite(trusted_site)
-            logger.info("Added OTDS trusted site -> {}".format(trusted_site))
+            response = self._otds.addTrustedSite(trusted_site)
+            if response:
+                logger.info("Added OTDS trusted site -> {}".format(trusted_site))
+            else:
+                logger.error("Failed to add trusted site -> {}".format(trusted_site))
+                success = False
+
+        if success:
+            self.writeStatusFile(section_name, self._trusted_sites)
+
+        return success
 
         # end method definition
 
-    def processSystemAttributes(self):
+    def processSystemAttributes(self, section_name: str = "systemAttributes") -> bool:
         """Process OTDS system attributes in payload and create them in OTDS.
 
         Args:
             None
         Returns:
-            None
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._system_attributes:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for system_attribute in self._system_attributes:
             # Check if there's a matching formal parameter defined on the Web Report node:
             if not system_attribute.get("name"):
                 logger.error("OTDS System Attribute needs a name. Skipping...")
+                success = False
                 continue
             attribute_name = system_attribute["name"]
 
-            if "enabled" in system_attribute and not system_attribute["enabled"]:
+            if "enabled" in system_attribute and not system_attribute["enabled"]:
+                logger.info(
+                    "Payload for OTDS System Attribute -> {} is disabled. Skipping...".format(
+                        attribute_name
+                    )
+                )
+                continue
+
+            if not system_attribute.get("value"):
+                logger.error("OTDS System Attribute needs a value. Skipping...")
+                continue
+
+            attribute_value = system_attribute["value"]
+            attribute_description = system_attribute.get("description")
+            response = self._otds.addSystemAttribute(
+                attribute_name, attribute_value, attribute_description
+            )
+            if response:
+                logger.info(
+                    "Added OTDS system attribute -> {} with value -> {}".format(
+                        attribute_name, attribute_value
+                    )
+                )
+            else:
+                logger.error(
+                    "Failed to add OTDS system attribute -> {} with value -> {}".format(
+                        attribute_name, attribute_value
+                    )
+                )
+                success = False
+
+        if success:
+            self.writeStatusFile(section_name, self._system_attributes)
+
+        return success
+
+        # end method definition
+
+    def processGroupPlaceholders(self):
+        """For some adminSettings we may need to replace a placeholder (sourrounded by %%...%%)
+        with the actual ID of the Extended ECM group. For this we prepare a lookup dict.
+        The dict self._placeholder_values already includes lookups for the OTCS and OTAWP
+        OTDS resource IDs (see main.py)
+        """
+
+        for group in self._groups:
+            if not "name" in group:
+                logger.error(
+                    "Group needs a name for placeholder definition. Skipping..."
+                )
+                continue
+            group_name = group["name"]
+            # Check if group has been disabled in payload (enabled = false).
+            # In this case we skip the element:
+            if "enabled" in group and not group["enabled"]:
+                logger.info(
+                    "Payload for Group -> {} is disabled. Skipping...".format(
+                        group_name
+                    )
+                )
+                continue
+
+            # Now we determine the ID. Either it is in the payload section from
+            # the current customizer run or we try to look it up in the system.
+            # The latter case may happen if the custiomuer pod got restarted.
+            group_id = self.determineGroupID(group)
+            if not group_id:
+                logger.warning(
+                    "Group needs an ID for placeholder definition. Skipping..."
+                )
+                continue
+
+            # Add Group with its ID to the dict self._placeholder_values:
+            self._placeholder_values[
+                "OTCS_GROUP_ID_{}".format(
+                    group_name.upper().replace(" & ", "_").replace(" ", "_")
+                )
+            ] = str(group_id)
+
+        logger.debug(
+            "Placeholder values after group processing = {}".format(
+                self._placeholder_values
+            )
+        )
+
+    def processUserPlaceholders(self):
+        """For some adminSettings we may need to replace a placeholder (sourrounded by %%...%%)
+        with the actual ID of the Extended ECM user. For this we prepare a lookup dict.
+        The dict self._placeholder_values already includes lookups for the OTCS and OTAWP
+        OTDS resource IDs (see main.py)
+        """
+
+        for user in self._users:
+            if not "name" in user:
+                logger.error(
+                    "User needs a name for placeholder definition. Skipping..."
+                )
+                continue
+            user_name = user["name"]
+            # Check if group has been disabled in payload (enabled = false).
+            # In this case we skip the element:
+            if "enabled" in user and not user["enabled"]:
                 logger.info(
-                    "Payload for OTDS System Attribute -> {} is disabled. Skipping...".format(
-                        attribute_name
-                    )
+                    "Payload for User -> {} is disabled. Skipping...".format(user_name)
                 )
                 continue
 
-            if not system_attribute.get("value"):
-                logger.error("OTDS System Attribute needs a value. Skipping...")
+            # Now we determine the ID. Either it is in the payload section from
+            # the current customizer run or we try to look it up in the system.
+            # The latter case may happen if the custiomuer pod got restarted.
+            user_id = self.determineUserID(user)
+            if not user_id:
+                logger.warning(
+                    "User needs an ID for placeholder definition. Skipping..."
+                )
                 continue
 
-            attribute_value = system_attribute["value"]
-            attribute_description = system_attribute.get("description")
-            self._otds.addSystemAttribute(
-                attribute_name, attribute_value, attribute_description
-            )
-            logger.info(
-                "Added OTDS system attribute -> {} with value -> {}".format(
-                    attribute_name, attribute_value
-                )
+            # Add Group with its ID to the dict self._placeholder_values:
+            self._placeholder_values["OTCS_USER_ID_{}".format(user_name.upper())] = str(
+                user_id
             )
 
-        # end method definition
+        logger.debug(
+            "Placeholder values after user processing = {}".format(
+                self._placeholder_values
+            )
+        )
 
-    def processGroups(self):
+    def processGroups(self, section_name: str = "groups") -> bool:
         """Process groups in payload and create them in Extended ECM.
 
         Args:
             None
         Returns:
-            None
+            bool: True if payload has been processed without errors, False otherwise
         Side Effects:
             the group items are modified by adding an "id" dict element that
             includes the technical ID of the group in Extended ECM
         """
 
+        if not self._groups:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         # First run through groups: create all groups in payload
         # and store the IDs of the created groups:
         for group in self._groups:
             if not "name" in group:
                 logger.error("Group needs a name. Skipping...")
+                success = False
                 continue
             group_name = group["name"]
 
@@ -1035,70 +1666,35 @@ class Payload(object):
 
             # Check if the group does already exist (e.g. if job is restarted)
             # as this is a pattern search it could return multiple groups:
-            existing_groups = self._otcs.getGroup(group_name)
-            if existing_groups and existing_groups["data"]:
-                logger.debug(
-                    "Found existing groups -> {}".format(existing_groups["data"])
-                )
-                # Get list of all matching groups:
-                existing_groups_list = existing_groups["data"]
-                # Find the group with the exact match of the name:
-                existing_group = next(
-                    (
-                        item
-                        for item in existing_groups_list
-                        if item["name"] == group_name
-                    ),
-                    None,
-                )
-                # Have we found an exact match?
-                if existing_group is not None:
-                    logger.info(
-                        "Found existing group -> {} ({}) - skipping to next group...".format(
-                            existing_group["name"], existing_group["id"]
-                        )
+            group_id = self.determineGroupID(group)
+            if group_id:
+                logger.info(
+                    "Found existing group -> {} ({}) - skipping to next group...".format(
+                        group_name, group_id
                     )
-                    group["id"] = existing_group["id"]
+                )
+                continue
+
+            logger.info("Did not find an existing group - creating a new group...")
 
-                    # Add Group with its ID to the class dict _placeholder_values:
-                    self._placeholder_values[
-                        "OTCS_GROUP_ID_{}".format(
-                            group_name.upper().replace(" & ", "_").replace(" ", "_")
-                        )
-                    ] = str(group["id"])
-                    continue
-                else:
-                    logger.info(
-                        "Did not find an exact match for the group - creating a new group..."
-                    )
-            else:
-                logger.info("Did not find any matching group - creating a new group...")
             # Now we know it is a new group...
             new_group = self._otcs.addGroup(group_name)
             if new_group is not None:
                 logger.debug("New group -> {}".format(new_group))
                 group["id"] = new_group["id"]
-
-            # Add Group with its ID to the global dict with placeholder values:
-            self._placeholder_values[
-                "OTCS_GROUP_ID_{}".format(
-                    group_name.upper().replace(" & ", "_").replace(" ", "_")
-                )
-            ] = str(group["id"])
+            else:
+                logger.error("Failed to create group -> {}".format(new_group))
+                success = False
+                continue
 
         logger.debug("Groups = {}".format(self._groups))
 
-        logger.debug(
-            "Placeholder values after group processing = {}".format(
-                self._placeholder_values
-            )
-        )
-
         # Second run through groups: create all group memberships
         # (nested groups) based on the IDs created in first run:
         for group in self._groups:
             if not "id" in group:
                 logger.error("Group -> {} does not have an ID.".format(group["name"]))
+                success = False
                 continue
             parent_group_names = group["parent_groups"]
             for parent_group_name in parent_group_names:
@@ -1122,6 +1718,7 @@ class Payload(object):
                                 parent_group_name
                             )
                         )
+                        success = False
                         continue
                     parent_group = parent_group["data"][0]
                 elif not "id" in parent_group:
@@ -1130,6 +1727,7 @@ class Payload(object):
                             parent_group["name"]
                         )
                     )
+                    success = False
                     continue
 
                 # retrieve all members of the parent group (1 = get only groups)
@@ -1155,22 +1753,41 @@ class Payload(object):
                     )
                     self._otcs.addGroupMember(group["id"], parent_group["id"])
 
+        if success:
+            self.writeStatusFile(section_name, self._groups)
+
+        return success
+
         # end method definition
 
-    def processGroupsM365(self):
+    def processGroupsM365(self, section_name: str = "groupsM365") -> bool:
         """Process groups in payload and create them in Microsoft 365.
 
         Args:
             None
         Returns:
-            None
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._groups:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         # First run through groups: create all groups in payload
         # and store the IDs of the created groups:
         for group in self._groups:
             if not "name" in group:
                 logger.error("Group needs a name. Skipping...")
+                success = False
                 continue
             group_name = group["name"]
 
@@ -1239,27 +1856,48 @@ class Payload(object):
                         group_name, group["m365_id"]
                     )
                 )
+            else:
+                success = False
+
+        if success:
+            self.writeStatusFile(section_name, self._groups)
+
+        return success
 
         # end method definition
 
-    def processUsers(self):
+    def processUsers(self, section_name: str = "users") -> bool:
         """Process users in payload and create them in Extended ECM.
 
         Args:
             None
         Returns:
-            None
+            bool: True if payload has been processed without errors, False otherwise
         Side Effects:
             the user items are modified by adding an "id" dict element that
             includes the technical ID of the user in Extended ECM
         """
 
+        if not self._users:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         # Add all users in payload and establish membership in
         # specified groups:
         for user in self._users:
             # Sanity checks:
             if not "name" in user:
                 logger.error("User is missing a login - skipping to next user...")
+                success = False
                 continue
             user_name = user["name"]
 
@@ -1278,6 +1916,7 @@ class Payload(object):
                         user_name
                     )
                 )
+                success = False
                 continue
 
             # Sanity checks:
@@ -1290,41 +1929,24 @@ class Payload(object):
                 user["base_group"] = "DefaultGroup"
 
             # Check if the user does already exist (e.g. if job is restarted)
-            # As this is a pattern search it could return multiple users:
-            existing_users = self._otcs.getUser(user_name)
-            if existing_users and existing_users["data"]:
-                logger.debug(
-                    "Found existing users -> {}".format(existing_users["data"])
-                )
-                # Get list of all matching users:
-                existing_users_list = existing_users["data"]
-                # Find the user with the exact match of the name:
-                existing_user = next(
-                    (item for item in existing_users_list if item["name"] == user_name),
-                    None,
-                )
-                # Have we found an exact match?
-                if existing_user is not None:
-                    logger.info(
-                        "Found existing user -> {} ({}) - skipping to next user...".format(
-                            existing_user["name"], existing_user["id"]
-                        )
-                    )
-                    user["id"] = existing_user["id"]
-                    continue
-                else:
-                    logger.info(
-                        "Did not find an exact match for the user - creating a new user..."
+            # determineUserID() also writes back the user ID into the payload
+            # if it has gathered it from OTCS.
+            user_id = self.determineUserID(user)
+            if user_id:
+                logger.info(
+                    "Found existing user -> {} ({}) - skipping to next user...".format(
+                        user_name, user_id
                     )
-            else:
-                logger.info("Did not find any matching user - creating a new user...")
+                )
+                continue
+            logger.info("Did not find an existing user - creating a new user...")
 
             # Find the base group of the user. Assume 'Default Group' (= 1001) if not found:
             base_group = next(
                 (
                     item["id"]
                     for item in self._groups
-                    if item["name"] == user["base_group"]
+                    if item["name"] == user["base_group"] and item.get("id")
                 ),
                 1001,
             )
@@ -1365,6 +1987,7 @@ class Payload(object):
                             logger.error(
                                 "Group -> {} not found. Skipping...".format(group_name)
                             )
+                            success = False
                             continue
                         group = group["data"][0]
 
@@ -1374,6 +1997,7 @@ class Payload(object):
                                 group["name"]
                             )
                         )
+                        success = False
                         continue
 
                     logger.info(
@@ -1381,10 +2005,14 @@ class Payload(object):
                             user["name"], user["id"], group["name"], group["id"]
                         )
                     )
-                    self._otcs.addGroupMember(user["id"], group["id"])
+                    response = self._otcs.addGroupMember(user["id"], group["id"])
+                    if not response:
+                        success = False
                 # for some unclear reason the user is not added to its base group in OTDS
                 # so we do this explicitly:
-                self._otds.addUserToGroup(user["name"], user["base_group"])
+                response = self._otds.addUserToGroup(user["name"], user["base_group"])
+                if not response:
+                    success = False
 
                 # Extra OTDS attributes for the user can be provided in "extra_attributes"
                 # as part of the user payload.
@@ -1397,6 +2025,7 @@ class Payload(object):
                             logger.error(
                                 "User attribute is missing a name or value. Skipping..."
                             )
+                            success = False
                             continue
                         logger.info(
                             "Set user attribute -> {} to -> {}".format(
@@ -1406,6 +2035,8 @@ class Payload(object):
                         user_partition = self._otcs.config()["partition"]
                         if not user_partition:
                             logger.error("User partition not found!")
+                            success = False
+                            continue
                         self._otds.updateUser(
                             user_partition,
                             user["name"],
@@ -1413,23 +2044,42 @@ class Payload(object):
                             attribute_value,
                         )
 
+        if success:
+            self.writeStatusFile(section_name, self._users)
+
+        return success
+
         # end method definition
 
-    def processUsersM365(self):
+    def processUsersM365(self, section_name: str = "usersM365") -> bool:
         """Process users in payload and create them in Microsoft 365 via MS Graph API.
 
         Args:
             None
         Returns:
-            None
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._users:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         # Add all users in payload and establish membership in
         # specified groups:
         for user in self._users:
             # Sanity checks:
             if not "name" in user:
                 logger.error("User is missing a login - skipping to next user...")
+                success = False
                 continue
             user_name = user["name"]
 
@@ -1455,6 +2105,7 @@ class Payload(object):
                         user_name
                     )
                 )
+                success = False
                 continue
             user_password = user["password"]
             # be careful with the following fields - they could be empty
@@ -1504,6 +2155,7 @@ class Payload(object):
                             user_name
                         )
                     )
+                    success = False
                     continue
 
             # Now we assign a license to the new M365 user.
@@ -1524,6 +2176,7 @@ class Payload(object):
                                 sku_id, user_name
                             )
                         )
+                        success = False
                     else:
                         if (
                             not "m365_skus" in user
@@ -1579,7 +2232,7 @@ class Payload(object):
                         user_name, group_names, user_department
                     )
                 )
-                # Go through all
+                # Go through all group names:
                 for group_name in group_names:
                     # Find the group payload item to the parent group name:
                     group = next(
@@ -1620,6 +2273,7 @@ class Payload(object):
                                     group_name
                                 )
                             )
+                            success = False
                         else:
                             group_id = response["value"][0]["id"]
 
@@ -1694,6 +2348,7 @@ class Payload(object):
                                     group_name
                                 )
                             )
+                            success = False
                             continue
                         parent_group_id = response["value"][0]["id"]
 
@@ -1722,9 +2377,14 @@ class Payload(object):
                         )
                         self._m365.addGroupMember(parent_group_id, user_id)
 
+        if success:
+            self.writeStatusFile(section_name, self._users)
+
+        return success
+
         # end method definition
 
-    def processTeamsM365(self):
+    def processTeamsM365(self, section_name: str = "teamsM365") -> bool:
         """Process groups in payload and create matching Teams in Microsoft 365.
            We need to do this after the creation of the M365 users as wie require
            Group Owners to create teams.
@@ -1732,12 +2392,26 @@ class Payload(object):
         Args:
             None
         Returns:
-            None
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._groups:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for group in self._groups:
             if not "name" in group:
                 logger.error("Team needs a name. Skipping...")
+                success = False
                 continue
             group_name = group["name"]
 
@@ -1766,6 +2440,7 @@ class Payload(object):
                         group_name
                     )
                 )
+                success = False
                 continue
 
             if not self._m365.hasTeam(group_name):
@@ -1776,6 +2451,8 @@ class Payload(object):
                 )
                 # Now "upgrading" this group to a MS Team:
                 new_team = self._m365.addTeam(group_name)
+                if not new_team:
+                    success = False
             else:
                 logger.info(
                     "M365 group -> {} already has an MS Team connected. Skipping...".format(
@@ -1783,6 +2460,11 @@ class Payload(object):
                     )
                 )
 
+        if success:
+            self.writeStatusFile(section_name, self._groups)
+
+        return success
+
         # end method definition
 
     def cleanupStaleTeamsM365(self, workspace_types: list):
@@ -1825,35 +2507,86 @@ class Payload(object):
 
         # end method definition
 
-    def cleanupAllTeamsM365(self) -> bool:
+    def cleanupAllTeamsM365(self, section_name: str = "teamsM365Cleanup") -> bool:
         """Delete Microsoft Teams that are left-overs from former deployments
 
         Args:
             None
         Returns:
-            boolean: True if teams have been deleted, False otherwise
+            bool: True if teams have been deleted, False otherwise
         """
 
+        # We want this cleanup to only run once even if we have
+        # multiple payload files - so we pass payload_specific=False here:
+        if self.checkStatusFile(
+            payload_section_name=section_name, payload_specific=False
+        ):
+            logger.info(
+                "Payload section -> {} has been processed successfully before. Skip cleanup of M365 teams...".format(
+                    section_name
+                )
+            )
+            return True
+        else:
+            logger.info("Processing payload section -> {}...".format(section_name))
+
+        # We don't want to delete MS Teams that are matching the regular OTCS Group Names (like "Sales")
         exception_list = self.getAllGroupNames()
-        pattern_list = [r"\(\d+\)", r"\d+\s-\s"]
+
+        # These are the patterns that each MS Teams needs to match at least one of to be deleted
+        # Pattern 1: all MS teams with a name that has a number in brackets, line "(1234)"
+        # Pattern 2: all MS Teams with a name that starts with a number followed by a space,
+        #            followed by a "- and followed by another space
+        # Pattern 3: all MS Teams with a name that starts with "WS" and a 1-4 digit number
+        #            (these are the workspaces for Purchase Contracts generated for Intelligent Filing)
+        # Pattern 4: all MS Teams with a name that ends with a 1-2 character + a number in brackets, like (US-1000)
+        #            this is a specialization of pattern 1
+        pattern_list = [
+            r"\(\d+\)",
+            r"\d+\s-\s",
+            r"^WS\d{1,4}$",
+            r"^.+?\s\(.{1,2}-\d+\)$",
+        ]
 
         result = self._m365.deleteAllTeams(exception_list, pattern_list)
 
+        # We want this cleanup to only run once even if we have
+        # multiple payload files - so we pass payload_specific=False here:
+        self.writeStatusFile(
+            payload_section_name=section_name,
+            payload_section=exception_list + pattern_list,
+            payload_specific=False,
+        )
+
         return result
 
         # end method definition
 
-    def processAdminSettings(self, admin_settings: list) -> bool:
+    def processAdminSettings(
+        self, admin_settings: list, section_name: str = "adminSettings"
+    ) -> bool:
         """Process admin settings in payload and import them to Extended ECM.
 
         Args:
             admin_settings (list): list of admin settings. We need this parameter
                                    as we process two different lists.
         Returns:
-            boolean: True if a restart of the OTCS pods is required. False otherwise.
+            bool: True if a restart of the OTCS pods is required. False otherwise.
         """
 
-        restart_required = False
+        if not admin_settings:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        restart_required: bool = False
+        success: bool = True
 
         for admin_setting in admin_settings:
             # Sanity checks:
@@ -1903,23 +2636,40 @@ class Payload(object):
                 logger.error(
                     "Admin settings file -> {} not found.".format(settings_file)
                 )
+                success = False
+
+        if success:
+            self.writeStatusFile(section_name, admin_settings)
 
         return restart_required
 
         # end method definition
 
-    def processExternalSystems(self):
+    def processExternalSystems(self, section_name: str = "externalSystems") -> bool:
         """Process external systems in payload and create them in Extended ECM.
 
         Args:
             None
         Returns:
-            None
+            bool: True if payload has been processed without errors, False otherwise
         Side Effects:
             - based on system_type different other settings in the dict are set
             - reachability is tested and a flag is set in the dict are set
         """
 
+        if not self._external_systems:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for external_system in self._external_systems:
             #
             # 1: Do sanity checks for the payload:
@@ -1928,6 +2678,7 @@ class Payload(object):
                 logger.error(
                     "External System connection needs a logical system name! Skipping to next external system..."
                 )
+                success = False
                 continue
             system_name = external_system["external_system_name"]
 
@@ -1937,6 +2688,7 @@ class Payload(object):
                         system_name
                     )
                 )
+                success = False
                 continue
             system_type = external_system["external_system_type"]
 
@@ -1954,6 +2706,15 @@ class Payload(object):
                 else ""
             )
 
+            # Possible Connection Types for external systems:
+            # "Business Scenario Sample" (Business Scenarios Sample Adapter)
+            # "ot.sap.c4c.SpiAdapter" (SAP C4C SPI Adapter)
+            # "ot.sap.c4c.SpiAdapterV2" (C4C SPI Adapter V2)
+            # "HTTP" (Default WebService Adapter)
+            # "ot.sap.S4HANAAdapter" (S/4HANA SPI Adapter)
+            # "SF" (SalesForce Adapter)
+            # "SFInstance" (SFWebService)
+
             # Set the default settings for the different system types:
             match system_type:
                 # Check if we have a SuccessFactors system:
@@ -1993,6 +2754,7 @@ class Payload(object):
                         system_name
                     )
                 )
+                success = False
                 continue
             as_url = external_system["as_url"]
 
@@ -2045,6 +2807,7 @@ class Payload(object):
                                 system_name
                             )
                         )
+                        success = False
                         continue
                     if not "oauth_client_secret" in external_system:
                         logger.error(
@@ -2052,6 +2815,7 @@ class Payload(object):
                                 system_name
                             )
                         )
+                        success = False
                         continue
                     oauth_client_id = external_system["oauth_client_id"]
                     oauth_client_secret = external_system["oauth_client_secret"]
@@ -2108,6 +2872,7 @@ class Payload(object):
                         system_name, connection_type
                     )
                 )
+                success = False
             else:
                 logger.info(
                     "Successfully created external system -> {}".format(system_name)
@@ -2127,6 +2892,7 @@ class Payload(object):
                                 connection_type,
                             )
                         )
+                        success = False
                         continue
                     saml_url = external_system["saml_url"]
                     if not "otds_sp_endpoint" in external_system:
@@ -2136,6 +2902,7 @@ class Payload(object):
                                 connection_type,
                             )
                         )
+                        success = False
                         continue
                     otds_sp_endpoint = external_system["otds_sp_endpoint"]
 
@@ -2150,6 +2917,7 @@ class Payload(object):
                         logger.info("Successfully added SAML authentication handler.")
                     else:
                         logger.error("Failed to add SAML authentication handler.")
+                        success = False
                 case "SAP":
                     # Configure a certificate-based SAP authentication handler:
                     if not "certificate_file" in external_system:
@@ -2167,6 +2935,7 @@ class Payload(object):
                                 external_system["certificate_file"],
                             )
                         )
+                        success = False
                         continue
                     certificate_file = external_system["certificate_file"]
                     certificate_password = external_system["certificate_password"]
@@ -2181,6 +2950,7 @@ class Payload(object):
                         logger.info("Successfully added SAP authentication handler.")
                     else:
                         logger.error("Failed to add SAP authentication handler.")
+                        success = False
                     # Upload and enable certificate file for Archive Center that is required for SAP scenarios
                     # we only do this if the necessary information is in payload and if OTAC is enabled:
                     if (
@@ -2219,6 +2989,7 @@ class Payload(object):
                                 connection_type,
                             )
                         )
+                        success = False
                         continue
                     authorization_endpoint = external_system["authorization_endpoint"]
                     if not "token_endpoint" in external_system:
@@ -2228,6 +2999,7 @@ class Payload(object):
                                 connection_type,
                             )
                         )
+                        success = False
                         continue
                     token_endpoint = external_system["token_endpoint"]
                     response = self._otds.addAuthHandlerOAuth(
@@ -2244,11 +3016,19 @@ class Payload(object):
                     if response:
                         logger.info("Successfully added OAuth authentication handler.")
                     else:
+                        success = False
                         logger.error("Failed to add OAuth authentication handler.")
 
+        if success:
+            self.writeStatusFile(section_name, self._external_systems)
+
+        return success
+
         # end method definition
 
-    def processTransportPackages(self, transport_packages: list):
+    def processTransportPackages(
+        self, transport_packages: list, section_name: str = "transportPackages"
+    ) -> bool:
         """Process transport packages in payload and import them to Extended ECM.
 
         Args:
@@ -2257,14 +3037,28 @@ class Payload(object):
                                        content_transport, transport_post) so
                                        we need a parameter
         Returns:
-            None
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not transport_packages:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for transport_package in transport_packages:
             if not "name" in transport_package:
                 logger.error(
                     "Transport Package needs a name! Skipping to next transport..."
                 )
+                success = False
                 continue
             name = transport_package["name"]
 
@@ -2282,6 +3076,7 @@ class Payload(object):
                         name
                     )
                 )
+                success = False
                 continue
             if not "description" in transport_package:
                 logger.warning(
@@ -2311,22 +3106,41 @@ class Payload(object):
                 logger.error(
                     "Failed to deploy transport -> {}; URL -> {}".format(name, url)
                 )
+                success = False
                 if self._stop_on_error:
-                    return
+                    break
             else:
                 logger.info("Successfully deployed transport -> {}".format(name))
 
+        if success:
+            self.writeStatusFile(section_name, transport_packages)
+
+        return success
+
         # end method definition
 
-    def processUserPhotos(self):
+    def processUserPhotos(self, section_name: str = "userPhotos") -> bool:
         """Process user photos in payload and assign them to Extended ECM users.
 
         Args:
             None
         Returns:
-            None
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._users:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         # we assume the nickname of the photo item equals the login name of the user
         # we also assume that the photos have been uploaded / transported into the target system
         for user in self._users:
@@ -2346,6 +3160,7 @@ class Payload(object):
                         user_name
                     )
                 )
+                success = False
                 continue
 
             user_id = user["id"]
@@ -2360,8 +3175,9 @@ class Payload(object):
                 continue
             photo_id = self._otcs.getResultValue(response, "id")
             response = self._otcs.updateUserPhoto(user_id, photo_id)
-            if response == None:
-                logger.warning("Failed to add photo for user -> {}".format(user_name))
+            if not response:
+                logger.error("Failed to add photo for user -> {}".format(user_name))
+                success = False
             else:
                 logger.info("Successfully added photo for user -> {}".format(user_name))
 
@@ -2369,25 +3185,43 @@ class Payload(object):
         response = self._otcs.getNodeFromNickname("admin")
         if response == None:
             logger.warning("Missing photo for admin - nickname not found. Skipping...")
-            return
-        photo_id = self._otcs.getResultValue(response, "id")
-        response = self._otcs.updateUserPhoto(1000, photo_id)
-        if response == None:
-            logger.warning("Failed to add photo for admin")
         else:
-            logger.info("Successfully added photo for admin")
+            photo_id = self._otcs.getResultValue(response, "id")
+            response = self._otcs.updateUserPhoto(1000, photo_id)
+            if response == None:
+                logger.warning("Failed to add photo for admin")
+            else:
+                logger.info("Successfully added photo for admin")
+
+        if success:
+            self.writeStatusFile(section_name, self._users)
+
+        return success
 
         # end method definition
 
-    def processUserPhotosM365(self):
+    def processUserPhotosM365(self, section_name: str = "userPhotosM365") -> bool:
         """Process user photos in payload and assign them to Microsoft 365 users.
 
         Args:
             None
         Returns:
-            None
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._users:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         # we assume the nickname of the photo item equals the login name of the user
         # we also assume that the photos have been uploaded / transported into the target system
         for user in self._users:
@@ -2398,6 +3232,7 @@ class Payload(object):
                         user_name
                     )
                 )
+                success = False
                 continue
 
             # Check if element has been disabled in payload (enabled = false).
@@ -2420,6 +3255,7 @@ class Payload(object):
                         user_name
                     )
                 )
+                success = False
                 continue
 
             user_m365_id = user["m365_id"]
@@ -2456,6 +3292,7 @@ class Payload(object):
                         user_name
                     )
                 )
+                success = False
             else:
                 logger.info(
                     "Successfully downloaded photo for user -> {} from Extended ECM to file -> {}".format(
@@ -2471,6 +3308,7 @@ class Payload(object):
                         user_name
                     )
                 )
+                success = False
             else:
                 logger.info(
                     "Successfully uploaded photo for user -> {} to Microsoft 365".format(
@@ -2478,9 +3316,14 @@ class Payload(object):
                     )
                 )
 
+        if success:
+            self.writeStatusFile(section_name, self._users)
+
+        return success
+
         # end method definition
 
-    def processWorkspaceTypes(self) -> list:
+    def processWorkspaceTypes(self, section_name: str = "workspaceTypes") -> list:
         """Create a data structure for all workspace types in the Extended ECM system.
 
         Args:
@@ -2494,6 +3337,11 @@ class Payload(object):
                     + id
         """
 
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
         # get all workspace types (these have been created by the transports and are not in the payload!):
         response = self._otcs.getWorkspaceTypes()
         if response == None:
@@ -2569,113 +3417,36 @@ class Payload(object):
                 )
                 continue
 
+        self.writeStatusFile(section_name, self._workspace_types)
+
         return self._workspace_types
 
         # end method definition
 
-    def processWorkspaceTemplateRegistrations(self):
-        """Process workspace template registrations for Extended ECM for Engineering.
-        This has been a work-around for a transport issue in 22.4. This code is not required
-        for 23.1 or newer. Right now we just disabled the payload. We may consider to remove
-        the code in future versions.
-
-        Args: None
-        Return: None
-        """
-
-        # loop through the workspace template registrations in the payload:
-        for workspace_template_registration in self._workspace_template_registrations:
-            # Do some sanity checks first and read the workspace type name
-            # and workspace template name from the payload:
-            if not "workspace_type_name" in workspace_template_registration:
-                logger.error(
-                    "Workspace template registration needs a workspace type name! Skipping to next workspace template registration..."
-                )
-                continue
-            type_name = workspace_template_registration["workspace_type_name"]
-
-            if (
-                "enabled" in workspace_template_registration
-                and not workspace_template_registration["enabled"]
-            ):
-                logger.info(
-                    "Payload for Workspace Template Registration for Workspace Type -> {} is disabled. Skipping...".format(
-                        type_name
-                    )
-                )
-                continue
-
-            if not "workspace_template_name" in workspace_template_registration:
-                logger.error(
-                    "Workspace template registration needs a workspace template name! Skipping to next workspace template registration..."
-                )
-                continue
-            template_name = workspace_template_registration["workspace_template_name"]
-
-            # now we have the template type name and the template name from the
-            # payload. We can now proceed to find these items in the workspace types
-            # data structure. First we lookup the workspace type:
-            workspace_type = next(
-                (item for item in self._workspace_types if item["name"] == type_name),
-                None,
-            )
-            if workspace_type is None:
-                logger.error(
-                    "Workspace Type with name -> {} not found.".format(type_name)
-                )
-                continue
+    def processWorkspaces(self, section_name: str = "workspaces") -> bool:
+        """Process workspaces in payload and create them in Extended ECM.
 
-            # now we use the template list in the workspace type datastructure
-            # to find the workspace template:
-            workspace_template_list = workspace_type["templates"]
-            if workspace_template_list is []:
-                logger.error(
-                    "Workspace Type with name -> {} has no templates.".format(type_name)
-                )
-                continue
+        Args:
+            None
+        Return:
+            bool: True if payload has been processed without errors, False otherwise
 
-            workspace_template = next(
-                (
-                    item
-                    for item in workspace_template_list
-                    if item["name"] == template_name
-                ),
-                None,
-            )
-            if workspace_template is None:
-                logger.error(
-                    "Workspace Type with name -> {} has no Template with name -> {}.".format(
-                        type_name, template_name
-                    )
-                )
-                continue
-            workspace_template_id = workspace_template["id"]
+        Side Effects:
+            Set workspace["nodeId] to the node ID of the created workspace
+        """
 
+        if not self._workspaces:
             logger.info(
-                "Register workspace template -> {} ({}) with workspace type -> {}".format(
-                    template_name, workspace_template_id, type_name
-                )
+                "Payload section -> {} is empty. Skipping...".format(section_name)
             )
+            return True
 
-            response = self._otcs.registerWorkspaceTemplate(workspace_template_id)
-            if response == None:
-                logger.error(
-                    "Failed to register workspace template -> {} with workspace type -> {}".format(
-                        template_name, type_name
-                    )
-                )
-                continue
-
-        # end method definition
-
-    def processWorkspaces(self):
-        """Process workspaces in payload and create them in Extended ECM.
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
 
-        Args: None
-        Return: None
-        Side Effects:
-            Set workspace["nodeId] to the node ID of the created workspace
-        """
+        success: bool = True
 
         for workspace in self._workspaces:
             # Read name from payload:
@@ -2708,14 +3479,10 @@ class Payload(object):
                     name, type_name
                 )
             )
-            response = self._otcs.getWorkspaceByTypeAndName(type_name, name)
-            logger.debug(
-                "Search for existing workspace delivered -> {}".format(response)
-            )
-            workspace_id = self._otcs.getResultValue(response, "id")
+            workspace_id = self.determineWorkspaceID(workspace)
             if workspace_id:
                 # we still want to set the nodeId as other parts of the payload depend on it:
-                workspace["nodeId"] = workspace_id
+                # workspace["nodeId"] = workspace_id
                 logger.info(
                     "Workspace -> {} of type -> {} does already exist and has ID -> {}! Skipping to next workspace...".format(
                         name, type_name, workspace_id
@@ -2752,13 +3519,13 @@ class Payload(object):
                     )
                     continue
 
-                if not "nodeId" in parent_workspace:
+                parent_workspace_node_id = self.determineWorkspaceID(parent_workspace)
+                if not parent_workspace_node_id:
                     logger.warning(
                         "Parent Workspace without node ID (parent workspace creation may have failed) - skipping to next workspace..."
                     )
                     continue
-                # now determine the actual node IDs of the parent workspace (should have been created before):
-                parent_workspace_node_id = parent_workspace["nodeId"]
+
                 logger.info(
                     "Parent Workspace with logical ID -> {} has node ID -> {}".format(
                         parent_id, parent_workspace_node_id
@@ -3347,7 +4114,7 @@ class Payload(object):
             workspace["nodeId"] = self._otcs.getResultValue(response, "id")
 
             # We also get the name the workspace was finally created with.
-            # This can be different form the namein the payload as additional
+            # This can be different form the name in the payload as additional
             # naming conventions from the Workspace Type definitions may apply.
             # This is important to make the python container idem-potent.
             response = self._otcs.getWorkspace(workspace["nodeId"])
@@ -3415,9 +4182,16 @@ class Payload(object):
                                 )
                             )
 
+        if success:
+            self.writeStatusFile(section_name, self._workspaces)
+
+        return success
+
         # end method definition
 
-    def processWorkspaceRelationships(self):
+    def processWorkspaceRelationships(
+        self, section_name: str = "workspaceRelationships"
+    ) -> bool:
         """Process workspaces relationships in payload and create them in Extended ECM.
 
         Relationships can only be created if all workspaces have been created before.
@@ -3426,10 +4200,25 @@ class Payload(object):
         Relationships are created between the node IDs of two business workspaces
         (and not the logical IDs in the inital payload specification)
 
-        Args: None
-        Return: None
+        Args:
+            None
+        Return:
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._workspaces:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for workspace in self._workspaces:
             # Read name from payload:
             if not "name" in workspace:
@@ -3464,13 +4253,13 @@ class Payload(object):
             workspace_id = workspace["id"]
             logger.info("Workspace -> {} has relationships - creating...".format(name))
 
-            if not "nodeId" in workspace:
+            workspace_node_id = self.determineWorkspaceID(workspace)
+            if not workspace_node_id:
                 logger.warning(
                     "Workspace without node ID cannot have a relationship (workspace creation may have failed) - skipping to next workspace..."
                 )
                 continue
             # now determine the actual node IDs of the workspaces (have been created above):
-            workspace_node_id = workspace["nodeId"]
             logger.info(
                 "Workspace with logical ID -> {} has node ID -> {}".format(
                     workspace_id, workspace_node_id
@@ -3493,6 +4282,7 @@ class Payload(object):
                             related_workspace_id
                         )
                     )
+                    success = False
                     continue
 
                 if "enabled" in related_workspace and not related_workspace["enabled"]:
@@ -3503,13 +4293,13 @@ class Payload(object):
                     )
                     continue
 
-                if not "nodeId" in related_workspace:
+                related_workspace_node_id = self.determineWorkspaceID(related_workspace)
+                if not related_workspace_node_id:
                     logger.warning(
                         "Related Workspace without node ID (workspaces creation may have failed) - skipping to next workspace..."
                     )
                     continue
-                # now determine the actual node IDs of the related workspace (should have been created above):
-                related_workspace_node_id = related_workspace["nodeId"]
+
                 logger.info(
                     "Related Workspace with logical ID -> {} has node ID -> {}".format(
                         related_workspace_id, related_workspace_node_id
@@ -3539,20 +4329,41 @@ class Payload(object):
                 response = self._otcs.createWorkspaceRelationship(
                     workspace_node_id, related_workspace_node_id
                 )
-                if response == None:
+                if not response:
                     logger.error("Failed to create workspace relationship.")
+                    success = False
                 else:
                     logger.info("Successfully created workspace relationship.")
 
+        if success:
+            self.writeStatusFile(section_name, self._workspaces)
+
+        return success
+
         # end method definition
 
-    def processWorkspaceMembers(self):
+    def processWorkspaceMembers(self, section_name: str = "workspaceMembers") -> bool:
         """Process workspaces members in payload and create them in Extended ECM.
 
-        Args: None
-        Return: None
+        Args:
+            None
+        Return:
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._workspaces:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for workspace in self._workspaces:
             # Read name from payload (just for logging):
             if not "name" in workspace:
@@ -3586,14 +4397,14 @@ class Payload(object):
                 )
             )
 
-            if not "nodeId" in workspace:
+            workspace_node_id = self.determineWorkspaceID(workspace)
+            if not workspace_node_id:
                 logger.warning(
                     "Workspace without node ID cannot have a members (workspaces creation may have failed) - skipping to next workspace..."
                 )
                 continue
 
             # now determine the actual node IDs of the workspaces (have been created by processWorkspaces()):
-            workspace_node_id = workspace["nodeId"]
             workspace_node = self._otcs.getNode(workspace_node_id)
             workspace_owner_id = self._otcs.getResultValue(
                 workspace_node, "owner_user_id"
@@ -3656,6 +4467,7 @@ class Payload(object):
                             workspace_name
                         )
                     )
+                    success = False
                     continue
                 if (
                     member_users == [] and member_groups == []
@@ -3677,6 +4489,7 @@ class Payload(object):
                             workspace_name, member_role_name
                         )
                     )
+                    success = False
                     continue
                 logger.info("Role -> {} has ID -> {}".format(member_role_name, role_id))
 
@@ -3726,6 +4539,7 @@ class Payload(object):
                                 workspace_name,
                             )
                         )
+                        success = False
                     else:
                         logger.info(
                             "Successfully added user -> {} ({}) to role -> {} of workspace -> {}".format(
@@ -3746,6 +4560,7 @@ class Payload(object):
                         logger.error(
                             "Cannot find group with name -> {}".format(member_group)
                         )
+                        success = False
                         continue
                     group_id = member_group_id["id"]
 
@@ -3761,6 +4576,7 @@ class Payload(object):
                                 workspace_name,
                             )
                         )
+                        success = False
                     else:
                         logger.info(
                             "Successfully added group -> {} ({}) to role -> {} of workspace -> {}".format(
@@ -3771,17 +4587,38 @@ class Payload(object):
                             )
                         )
 
+        if success:
+            self.writeStatusFile(section_name, self._workspaces)
+
+        return success
+
         # end method definition
 
-    def processWebReports(self, web_reports: list):
+    def processWebReports(
+        self, web_reports: list, section_name: str = "webReports"
+    ) -> bool:
         """Process web reports in payload and run them in Extended ECM.
 
         Args:
             web_reports (list): list of web reports. As we have two different list (pre and post)
                                 we need to pass the actual list as parameter.
-        Return: None
+        Return:
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not web_reports:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for web_report in web_reports:
             nick_name = web_report["nickname"]
 
@@ -3803,6 +4640,7 @@ class Payload(object):
                         nick_name
                     )
                 )
+                success = False
                 continue
 
             # be careful to avoid key errors as Web Report parameters are optional:
@@ -3824,6 +4662,7 @@ class Payload(object):
                             nick_name
                         )
                     )
+                    success = False
                     continue
                 lets_continue = False
                 # Check 2: Iterate through the actual parameters given in the payload
@@ -3840,6 +4679,7 @@ class Payload(object):
                                 nick_name, key
                             )
                         )
+                        success = False
                         lets_continue = True  # we cannot do a "continue" here directly as we are in an inner loop
                 # Check 3: Iterate through the formal parameters and validate there's a matching
                 # actual parameter defined in the payload for each mandatory formal parameter
@@ -3855,6 +4695,7 @@ class Payload(object):
                                 nick_name, formal_param["parm_name"]
                             )
                         )
+                        success = False
                         lets_continue = True  # we cannot do a "continue" here directly as we are in an inner loop
                 # Did any of the checks fail?
                 if lets_continue:
@@ -3885,6 +4726,7 @@ class Payload(object):
                                 nick_name, required_param["parm_name"]
                             )
                         )
+                        success = False
                         continue
                     else:  # we are good to proceed!
                         logger.debug(
@@ -3895,19 +4737,41 @@ class Payload(object):
                 response = self._otcs.runWebReport(nick_name)
             if response == None:
                 logger.error("Failed to run web report -> {}".format(nick_name))
+                success = False
+
+        if success:
+            self.writeStatusFile(section_name, web_reports)
+
+        return success
 
         # end method definition
 
-    def processCSApplications(self, otcs_object: object = None):
+    def processCSApplications(
+        self, otcs_object: object = None, section_name: str = "csApplications"
+    ) -> bool:
         """Process CS applications in payload and install them in Extended ECM.
         The CS Applications need to be installed in all frontend and backends.
 
         Args:
             otcs_object (object): this can either be the OTCS frontend or OTCS backend. If None
                                   then the otcs_backend is used.
-        Return: None
+        Return:
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._cs_applications:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         # OTCS backend is the default:
         if not otcs_object:
             otcs_object = self._otcs_backend
@@ -3937,19 +4801,38 @@ class Payload(object):
                 logger.error(
                     "Failed to install CS Application -> {}!".format(application_name)
                 )
+                success = False
+
+        if success:
+            self.writeStatusFile(section_name, self._cs_applications)
+
+        return success
 
         # end method definition
 
-    def processUserSettings(self):
+    def processUserSettings(self, section_name: str = "userSettings") -> bool:
         """Process user settings in payload and apply themin OTDS.
            This includes password settings and user display settings.
 
         Args:
             None
         Returns:
-            None
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._users:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for user in self._users:
             user_name = user["name"]
 
@@ -3964,6 +4847,8 @@ class Payload(object):
             user_partition = self._otcs.config()["partition"]
             if not user_partition:
                 logger.error("User partition not found!")
+                success = False
+                continue
 
             # Set the OTDS display name. Extended ECM does not use this but
             # it makes AppWorks display users correctly (and it doesn't hurt)
@@ -3985,6 +4870,7 @@ class Payload(object):
                             user_name, user_display_name
                         )
                     )
+                    success = False
 
             # Don't enforce the user to reset password at first login (settings in OTDS):
             logger.info(
@@ -3993,10 +4879,19 @@ class Payload(object):
             response = self._otds.updateUser(
                 user_partition, user_name, "UserMustChangePasswordAtNextSignIn", "False"
             )
+            if not response:
+                success = False
+
+        if success:
+            self.writeStatusFile(section_name, self._users)
+
+        return success
 
         # end method definition
 
-    def processUserFavoritesAndProfiles(self):
+    def processUserFavoritesAndProfiles(
+        self, section_name: str = "userFavoritesAndProfiles"
+    ) -> bool:
         """Process user favorites in payload and create them in Extended ECM.
            This method also simulates browsing the favorites to populate the
            widgets on the landing pages and sets personal preferences.
@@ -4004,9 +4899,22 @@ class Payload(object):
         Args:
             None
         Returns:
-            None
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._users:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         # We can only set favorites if we impersonate / authenticate as the user.
         # The following code (for loop) will change the authenticated user - we need to
         # switch it back to admin user later so we safe the admin credentials for this:
@@ -4037,6 +4945,7 @@ class Payload(object):
             cookie = self._otcs.authenticate(True)
             if not cookie:
                 logger.error("Couldn't authenticate user -> {}".format(user_name))
+                success = False
                 continue
 
             # we update the user profile to activate navigation tree:
@@ -4060,34 +4969,21 @@ class Payload(object):
                     (item for item in self._workspaces if item["id"] == favorite), None
                 )
                 is_workspace = False
-                if favorite_item is not None:
+                if favorite_item:
                     logger.info(
                         "Found favorite item (workspace) in payload -> {}".format(
                             favorite_item["name"]
                         )
                     )
-                    if "nodeId" in favorite_item:
-                        favorite_id = favorite_item["nodeId"]
-                    else:
-                        logger.info(
-                            "Favorite -> {} (workspace) does not have a nodeId in payload - check if it was created by an external systems...".format(
-                                favorite
+                    favorite_id = self.determineWorkspaceID(favorite_item)
+                    if not favorite_id:
+                        logger.warning(
+                            "Workspace of type -> {} and name -> {} does not exist. Cannot create favorite. Skipping...".format(
+                                favorite_item["type_name"], favorite_item["name"]
                             )
                         )
-                        response = self._otcs.getWorkspaceByTypeAndName(
-                            favorite_item["type_name"], favorite_item["name"]
-                        )
-                        favorite_id = self._otcs.getResultValue(response, "id")
-                        if not favorite_id:
-                            logger.warning(
-                                "Workspace of type -> {} and name -> {} does not exist. Cannot create favorite. Skipping...".format(
-                                    favorite_item["type_name"], favorite_item["name"]
-                                )
-                            )
-                            continue
-                        else:
-                            # store ID in payload in case it is used again
-                            favorite_item["nodeId"] = favorite_id
+                        continue
+
                     is_workspace = True
                 else:
                     # alternatively try to find the item as a nickname:
@@ -4141,6 +5037,7 @@ class Payload(object):
                             proxy, user_name
                         )
                     )
+                    success = False
                     continue
                 proxy_user_id = proxy_user["id"]
 
@@ -4175,15 +5072,37 @@ class Payload(object):
             # True = force new login with new user
             cookie = self._otcs.authenticate(True)
 
+        if success:
+            self.writeStatusFile(section_name, self._users)
+
+        return success
+
         # end method definition
 
-    def processSecurityClearances(self):
+    def processSecurityClearances(
+        self, section_name: str = "securityClearances"
+    ) -> bool:
         """Process Security Clearances for Extended ECM.
 
-        Args: None
-        Return: None
+        Args:
+            None
+        Return:
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._security_clearances:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for security_clearance in self._security_clearances:
             clearance_level = security_clearance.get("level")
             clearance_name = security_clearance.get("name")
@@ -4212,16 +5131,39 @@ class Payload(object):
                 logger.error(
                     "Cannot create Security Clearance - either level or name is missing!"
                 )
+                success = False
+
+        if success:
+            self.writeStatusFile(section_name, self._security_clearances)
+
+        return success
 
         # end method definition
 
-    def processSupplementalMarkings(self):
+    def processSupplementalMarkings(
+        self, section_name: str = "supplementalMarkings"
+    ) -> bool:
         """Process Supplemental Markings for Extended ECM.
 
-        Args: None
-        Return: None
+        Args:
+            None
+        Return:
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._supplemental_markings:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for supplemental_marking in self._supplemental_markings:
             code = supplemental_marking.get("code")
 
@@ -4250,16 +5192,37 @@ class Payload(object):
                 logger.error(
                     "Cannot create Supplemental Marking - either code or description is missing!"
                 )
+                success = False
+
+        if success:
+            self.writeStatusFile(section_name, self._supplemental_markings)
+
+        return success
 
         # end method definition
 
-    def processUserSecurity(self):
+    def processUserSecurity(self, section_name: str = "userSecurity"):
         """Process Security Clearance and Supplemental Markings for Extended ECM users.
 
-        Args: None
-        Return: None
+        Args:
+            None
+        Return:
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._users:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for user in self._users:
             user_id = user.get("id")
             user_name = user.get("name")
@@ -4286,9 +5249,16 @@ class Payload(object):
                     user_id, user_supplemental_markings
                 )
 
+        if success:
+            self.writeStatusFile(section_name, self._users)
+
+        return success
+
         # end method definition
 
-    def processRecordsManagementSettings(self):
+    def processRecordsManagementSettings(
+        self, section_name: str = "recordsManagementSettings"
+    ):
         """Process Records Management Settings for Extended ECM.
         The setting files need to be placed in the OTCS file system file via
         a transport into the Support Asset Volume.
@@ -4297,6 +5267,19 @@ class Payload(object):
         Return: None
         """
 
+        if not self._records_management_settings:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         if (
             "records_management_system_settings" in self._records_management_settings
             and self._records_management_settings["records_management_system_settings"]
@@ -4308,7 +5291,9 @@ class Payload(object):
                     "records_management_system_settings"
                 ]
             )
-            self._otcs.importRecordsManagementSettings(filename)
+            response = self._otcs.importRecordsManagementSettings(filename)
+            if not response:
+                success = False
 
         if (
             "records_management_codes" in self._records_management_settings
@@ -4318,7 +5303,9 @@ class Payload(object):
                 self._custom_settings_dir
                 + self._records_management_settings["records_management_codes"]
             )
-            self._otcs.importRecordsManagementCodes(filename)
+            response = self._otcs.importRecordsManagementCodes(filename)
+            if not response:
+                success = False
 
         if (
             "records_management_rsis" in self._records_management_settings
@@ -4328,7 +5315,9 @@ class Payload(object):
                 self._custom_settings_dir
                 + self._records_management_settings["records_management_rsis"]
             )
-            self._otcs.importRecordsManagementRSIs(filename)
+            response = self._otcs.importRecordsManagementRSIs(filename)
+            if not response:
+                success = False
 
         if (
             "physical_objects_system_settings" in self._records_management_settings
@@ -4339,7 +5328,9 @@ class Payload(object):
                 self._custom_settings_dir
                 + self._records_management_settings["physical_objects_system_settings"]
             )
-            self._otcs.importPhysicalObjectsSettings(filename)
+            response = self._otcs.importPhysicalObjectsSettings(filename)
+            if not response:
+                success = False
 
         if (
             "physical_objects_codes" in self._records_management_settings
@@ -4349,7 +5340,9 @@ class Payload(object):
                 self._custom_settings_dir
                 + self._records_management_settings["physical_objects_codes"]
             )
-            self._otcs.importPhysicalObjectsCodes(filename)
+            response = self._otcs.importPhysicalObjectsCodes(filename)
+            if not response:
+                success = False
 
         if (
             "physical_objects_locators" in self._records_management_settings
@@ -4359,7 +5352,9 @@ class Payload(object):
                 self._custom_settings_dir
                 + self._records_management_settings["physical_objects_locators"]
             )
-            self._otcs.importPhysicalObjectsLocators(filename)
+            response = self._otcs.importPhysicalObjectsLocators(filename)
+            if not response:
+                success = False
 
         if (
             "security_clearance_codes" in self._records_management_settings
@@ -4369,17 +5364,39 @@ class Payload(object):
                 self._custom_settings_dir
                 + self._records_management_settings["security_clearance_codes"]
             )
-            self._otcs.importSecurityClearanceCodes(filename)
+            response = self._otcs.importSecurityClearanceCodes(filename)
+            if not response:
+                success = False
+
+        if success:
+            self.writeStatusFile(section_name, self._records_management_settings)
+
+        return success
 
         # end method definition
 
-    def processHolds(self):
+    def processHolds(self, section_name: str = "holds") -> bool:
         """Process Records Management Holds for Extended ECM users.
 
-        Args: None
-        Return: None
+        Args:
+            None
+        Return:
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._holds:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for hold in self._holds:
             if not "name" in hold:
                 logger.error("Cannot create Hold without a name! Skipping...")
@@ -4392,6 +5409,7 @@ class Payload(object):
                         hold_name
                     )
                 )
+                success = False
                 continue
             hold_type = hold["type"]
 
@@ -4451,16 +5469,40 @@ class Payload(object):
                         hold_name, hold["holdID"]
                     )
                 )
+            else:
+                success = False
+
+        if success:
+            self.writeStatusFile(section_name, self._holds)
+
+        return success
 
         # end method definition
 
-    def processAdditionalGroupMembers(self):
+    def processAdditionalGroupMembers(
+        self, section_name: str = "additionalGroupMemberships"
+    ) -> bool:
         """Process additional groups memberships we want to have in OTDS.
 
-        Args: None
-        Return: None
+        Args:
+            None
+        Return:
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._additional_group_members:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for additional_group_member in self._additional_group_members:
             if not "parent_group" in additional_group_member:
                 logger.error("Missing parent_group! Skipping...")
@@ -4484,6 +5526,7 @@ class Payload(object):
                 logger.error(
                     "Either group_name or user_name need to be specified! Skipping..."
                 )
+                success = False
                 continue
             if "group_name" in additional_group_member:
                 group_name = additional_group_member["group_name"]
@@ -4499,6 +5542,7 @@ class Payload(object):
                             group_name, parent_group
                         )
                     )
+                    success = False
             elif "user_name" in additional_group_member:
                 user_name = additional_group_member["user_name"]
                 logger.info(
@@ -4513,16 +5557,39 @@ class Payload(object):
                             user_name, parent_group
                         )
                     )
+                    success = False
+
+        if success:
+            self.writeStatusFile(section_name, self._additional_group_members)
+
+        return success
 
         # end method definition
 
-    def processAdditionalAccessRoleMembers(self):
+    def processAdditionalAccessRoleMembers(
+        self, section_name: str = "additionalAccessRoleMemberships"
+    ) -> bool:
         """Process additional access role memberships we want to have in OTDS.
 
-        Args: None
-        Return: None
+        Args:
+            None
+        Return:
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._additional_access_role_members:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for additional_access_role_member in self._additional_access_role_members:
             if not "access_role" in additional_access_role_member:
                 logger.error("Missing access_role! Skipping...")
@@ -4548,6 +5615,7 @@ class Payload(object):
                 logger.error(
                     "Either group_name or user_name need to be specified! Skipping..."
                 )
+                success = False
                 continue
             if "group_name" in additional_access_role_member:
                 group_name = additional_access_role_member["group_name"]
@@ -4563,6 +5631,7 @@ class Payload(object):
                             group_name, access_role
                         )
                     )
+                    success = False
             elif "user_name" in additional_access_role_member:
                 user_name = additional_access_role_member["user_name"]
                 logger.info(
@@ -4577,6 +5646,7 @@ class Payload(object):
                             user_name, access_role
                         )
                     )
+                    success = False
             elif "partition_name" in additional_access_role_member:
                 partition_name = additional_access_role_member["partition_name"]
                 logger.info(
@@ -4593,16 +5663,37 @@ class Payload(object):
                             partition_name, access_role
                         )
                     )
+                    success = False
+
+        if success:
+            self.writeStatusFile(section_name, self._additional_access_role_members)
+
+        return success
 
         # end method definition
 
-    def processRenamings(self):
+    def processRenamings(self, section_name: str = "renamings") -> bool:
         """Process renamings specified in payload and rename existing Extended ECM items.
 
-        Args: None
-        Return: None
+        Args:
+            None
+        Return:
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._renamings:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for renaming in self._renamings:
             if not "nodeid" in renaming:
                 if not "volume" in renaming:
@@ -4631,19 +5722,38 @@ class Payload(object):
                         node_id, renaming["name"]
                     )
                 )
+                success = False
+
+        if success:
+            self.writeStatusFile(section_name, self._renamings)
+
+        return success
 
         # end method definition
 
-    def processItems(self, items: list):
+    def processItems(self, items: list, section_name: str = "items") -> bool:
         """Process items specified in payload and create them in Extended ECM.
 
         Args:
-            otcs: OTCS object
             items: list of items to create (need this as parameter as we
                    have multiple lists)
-        Return: None
+        Return:
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not items:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for item in items:
             if not "name" in item:
                 logger.error("Item needs a name. Skipping...")
@@ -4676,6 +5786,7 @@ class Payload(object):
                             item_name, parent_nickname
                         )
                     )
+                    success = False
                     continue
             else:  # use parent_path and Enterprise Volume
                 parent_node = self._otcs.getNodeByVolumeAndPath(141, parent_path)
@@ -4687,6 +5798,7 @@ class Payload(object):
                             item_name
                         )
                     )
+                    success = False
                     continue
 
             original_nickname = item.get("original_nickname")
@@ -4702,6 +5814,7 @@ class Payload(object):
                             item_name, original_nickname
                         )
                     )
+                    success = False
                     continue
             elif original_path:
                 original_node = self._otcs.getNodeByVolumeAndPath(141, original_path)
@@ -4713,12 +5826,14 @@ class Payload(object):
                             item_name
                         )
                     )
+                    success = False
                     continue
             else:
                 original_id = 0
 
             if not "type" in item:
                 logger.error("Item -> {} needs a type. Skipping...".format(item_name))
+                success = False
                 continue
 
             item_type = item.get("type")
@@ -4734,6 +5849,7 @@ class Payload(object):
                                 item_name
                             )
                         )
+                        success = False
                         continue
                 case 1:  # Shortcut
                     if original_id == 0:
@@ -4742,12 +5858,15 @@ class Payload(object):
                                 item_name
                             )
                         )
+                        success = False
                         continue
 
             # 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):
-            response = self._otcs.getNodeByParentAndName(parent_id, item_name, False)
+            response = self._otcs.getNodeByParentAndName(
+                parent_id, item_name, show_error=False
+            )
             if self._otcs.getResultValue(response, "name") == item_name:
                 logger.info(
                     "Item with name -> {} does already exist in parent folder with ID -> {}".format(
@@ -4760,10 +5879,18 @@ class Payload(object):
             )
             if not response:
                 logger.error("Failed to create item -> {}.".format(item_name))
+                success = False
+
+        if success:
+            self.writeStatusFile(section_name, items)
+
+        return success
 
         # end method definition
 
-    def processPermissions(self, permissions: list):
+    def processPermissions(
+        self, permissions: list, section_name: str = "permissions"
+    ) -> bool:
         """Process items specified in payload and upadate permissions.
 
         Args:
@@ -4791,9 +5918,23 @@ class Payload(object):
                                 apply_to = 2
                             }
 
-        Return: None
+        Return:
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not permissions:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for permission in permissions:
             if (
                 not "path" in permission
@@ -4801,6 +5942,7 @@ class Payload(object):
                 and not "nickname" in permission
             ):
                 logger.error("Item to change permission is not specified. Skipping...")
+                success = False
                 continue
 
             # Check if element has been disabled in payload (enabled = false).
@@ -4827,6 +5969,7 @@ class Payload(object):
                             volume_type
                         )
                     )
+                    success = False
                     continue
 
             # Check if "path" is in payload and not empty list
@@ -4842,6 +5985,7 @@ class Payload(object):
                 node_id = self._otcs.getResultValue(node, "id")
                 if not node_id:
                     logger.error("Path -> {} does not exist. Skipping...".format(path))
+                    success = False
                     continue
 
             # Check if "nickname" is in payload and not empty string:
@@ -4856,11 +6000,13 @@ class Payload(object):
                 node_id = self._otcs.getResultValue(node, "id")
                 if not node_id:
                     logger.error("Nickname -> {} does not exist. Skipping...")
+                    success = False
                     continue
 
             # Now we should have a value for node_id:
             if not node_id:
                 logger.error("No node ID found! Skipping permission...")
+                success = False
                 continue
             else:
                 node_name = self._otcs.getResultValue(node, "name")
@@ -4892,6 +6038,7 @@ class Payload(object):
                             node_id
                         )
                     )
+                    success = False
 
             # 2. Process Owner Group Permissions
             if "owner_group_permissions" in permission:
@@ -4910,6 +6057,7 @@ class Payload(object):
                             node_id
                         )
                     )
+                    success = False
 
             # 3. Process Public Permissions
             if "public_permissions" in permission:
@@ -4928,6 +6076,7 @@ class Payload(object):
                             node_id
                         )
                     )
+                    success = False
                     continue
 
             # 3. Process Assigned User Permissions (if specified and not empty)
@@ -4938,6 +6087,7 @@ class Payload(object):
                         logger.error(
                             "Missing user name or permissions in user permission specificiation. Cannot set user permissions. Skipping..."
                         )
+                        success = False
                         continue
                     user_name = user["name"]
                     permissions = user["permissions"]
@@ -4948,6 +6098,7 @@ class Payload(object):
                                 user_name
                             )
                         )
+                        success = False
                         continue
                     user_id = otcs_user["data"][0]["id"]
                     logger.info(
@@ -4964,6 +6115,7 @@ class Payload(object):
                                 node_id
                             )
                         )
+                        success = False
 
             # 4. Process Assigned Group Permissions (if specified and not empty)
             if "groups" in permission and permission["groups"]:
@@ -4988,6 +6140,7 @@ class Payload(object):
                                 group_name
                             )
                         )
+                        success = False
                         continue
                     group_id = otcs_group["data"][0]["id"]
                     response = self._otcs.assignPermission(
@@ -4999,21 +6152,43 @@ class Payload(object):
                                 node_id
                             )
                         )
+                        success = False
+
+        if success:
+            self.writeStatusFile(section_name, permissions)
+
+        return success
 
         # end method definition
 
-    def processAssignments(self):
+    def processAssignments(self, section_name: str = "assignments") -> bool:
         """Process assignments specified in payload and assign items (such as workspaces and
         items withnicknames) to users or groups.
 
-        Args: None
-        Return: None
+        Args:
+            None
+        Return:
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._assignments:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for assignment in self._assignments:
             # Sanity check: we need a subject - it's mandatory:
             if not "subject" in assignment:
                 logger.error("Assignment needs a subject! Skipping assignment...")
+                success = False
                 continue
             subject = assignment["subject"]
 
@@ -5042,6 +6217,7 @@ class Payload(object):
                         subject
                     )
                 )
+                success = False
                 continue
             # Check if a workspace is specified for the assignment and check it does exist:
             if "workspace" in assignment and assignment["workspace"]:
@@ -5053,14 +6229,23 @@ class Payload(object):
                     ),
                     None,
                 )
-                if not workspace or not "nodeId" in workspace:
+                if not workspace:
+                    logger.error(
+                        "Assignment -> {} has specified a not existing workspace -> {}! Skipping assignment...".format(
+                            subject, assignment["workspace"]
+                        )
+                    )
+                    success = False
+                    continue
+                node_id = self.determineWorkspaceID(workspace)
+                if not node_id:
                     logger.error(
                         "Assignment -> {} has specified a not existing workspace -> {}! Skipping assignment...".format(
                             subject, assignment["workspace"]
                         )
                     )
+                    success = False
                     continue
-                node_id = workspace["nodeId"]
             # If we don't have a workspace then check if a nickname is specified for the assignment:
             elif "nickname" in assignment:
                 response = self._otcs.getNodeFromNickname(assignment["nickname"])
@@ -5072,6 +6257,7 @@ class Payload(object):
                             assignment["nickname"]
                         )
                     )
+                    success = False
                     continue
             else:
                 logger.error(
@@ -5079,6 +6265,7 @@ class Payload(object):
                         subject
                     )
                 )
+                success = False
                 continue
 
             assignees = []
@@ -5101,6 +6288,7 @@ class Payload(object):
                                 group_assignee
                             )
                         )
+                        success = False
                         continue
                     if not "id" in group:
                         logger.error(
@@ -5108,6 +6296,7 @@ class Payload(object):
                                 group_assignee
                             )
                         )
+                        success = False
                         continue
                     group_id = group["id"]
                     # add the group ID to the assignee list:
@@ -5127,6 +6316,7 @@ class Payload(object):
                                 user_assignee
                             )
                         )
+                        success = False
                         continue
                     if not "id" in user:
                         logger.error(
@@ -5134,6 +6324,7 @@ class Payload(object):
                                 user_assignee
                             )
                         )
+                        success = False
                         continue
                     user_id = user["id"]
                     # add the group ID to the assignee list:
@@ -5145,7 +6336,8 @@ class Payload(object):
                         subject, node_id
                     )
                 )
-                return
+                success = False
+                continue
 
             response = self._otcs.assignItemToUserGroup(
                 node_id, subject, instruction, assignees
@@ -5156,6 +6348,12 @@ class Payload(object):
                         subject, node_id, assignees
                     )
                 )
+                success = False
+
+        if success:
+            self.writeStatusFile(section_name, self._assignments)
+
+        return success
 
         # end method definition
 
@@ -5165,7 +6363,8 @@ class Payload(object):
         license_feature: str,
         license_name: str,
         user_specific_payload_field: str = "licenses",
-    ):
+        section_name: str = "userLicenses",
+    ) -> bool:
         """Assign a specific OTDS license feature to all Extended ECM users.
            This method is used for OTIV and Extended ECM licenses.
 
@@ -5175,20 +6374,34 @@ class Payload(object):
             license_name: Name of the license Key (e.g. "EXTENDED_ECM" or "INTELLIGENT_VIEWING")
             user_specific_payload_field: name of the user specific field in payload
                                          (if empty it will be ignored)
-        Return: None
+        Return:
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._users:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         otds_resource = self._otds.getResource(resource_name)
         if not otds_resource:
             logger.error(
                 "OTDS Resource -> {} not found. Cannot assign licenses to users."
             )
-            return
+            return False
 
         user_partition = self._otcs.config()["partition"]
         if not user_partition:
             logger.error("OTCS user partition not found in OTDS!")
-            return
+            return False
 
         for user in self._users:
             user_name = user["name"]
@@ -5211,36 +6424,70 @@ class Payload(object):
             else:  # use the default feature from the actual parameter
                 user_license_feature = [license_feature]
 
-            for lic_feature in user_license_feature:
+            for license_feature in user_license_feature:
+                if self._otds.isUserLicensed(
+                    user_name=user_name,
+                    resource_id=otds_resource["resourceID"],
+                    license_feature=license_feature,
+                    license_name=license_name,
+                ):
+                    logger.info(
+                        "User -> {} is already licensed for -> {} ({})".format(
+                            user_name, license_name, license_feature
+                        )
+                    )
+                    continue
                 assigned_license = self._otds.assignUserToLicense(
                     user_partition,
                     user_name,  # we want the plain login name here
                     otds_resource["resourceID"],
-                    lic_feature,
+                    license_feature,
                     license_name,
                 )
 
                 if not assigned_license:
                     logger.error(
                         "Failed to assign license feature -> {} to user -> {}!".format(
-                            lic_feature, user["name"]
+                            license_feature, user_name
                         )
                     )
+                    success = False
+
+        if success:
+            self.writeStatusFile(section_name, self._users)
+
+        return success
 
         # end method definition
 
-    def processExecPodCommands(self):
+    def processExecPodCommands(self, section_name: str = "execPodCommands") -> bool:
         """Process commands that should be executed in the Kubernetes pods.
 
-        Args: None
-        Return: None
+        Args:
+            None
+        Return:
+            None
         """
 
+        if not self._exec_pod_commands:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for exec_pod_command in self._exec_pod_commands:
             if not "pod_name" in exec_pod_command:
                 logger.error(
                     "To execute a command in a pod the pod name needs to be specified in the payload! Skipping to next pod command..."
                 )
+                success = False
                 continue
             pod_name = exec_pod_command["pod_name"]
 
@@ -5250,6 +6497,7 @@ class Payload(object):
                         pod_name
                     )
                 )
+                success = False
                 continue
             command = exec_pod_command["command"]
 
@@ -5304,17 +6552,37 @@ class Payload(object):
                     )
                 )
 
+        if success:
+            self.writeStatusFile(section_name, self._exec_pod_commands)
+
+        return success
+
         # end method definition
 
-    def processDocumentGenerators(self):
+    def processDocumentGenerators(
+        self, section_name: str = "documentGenerators"
+    ) -> bool:
         """Generate documents for a defined workspace type based on template
 
         Args:
-            none
+            None
         Returns:
-            none
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._doc_generators:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         # save admin credentials for later switch back to admin user:
         admin_credentials = self._otcs.credentials()
         authenticated_user = "admin"
@@ -5324,6 +6592,7 @@ class Payload(object):
                 logger.error(
                     "To generate documents for workspaces the workspace type needs to be specified in the payload! Skipping to next document generator..."
                 )
+                success = False
                 continue
             workspace_type = doc_generator["workspace_type"]
 
@@ -5333,6 +6602,7 @@ class Payload(object):
                         workspace_type
                     )
                 )
+                success = False
                 continue
             template_path = doc_generator["template_path"]
 
@@ -5352,6 +6622,7 @@ class Payload(object):
                         workspace_type
                     )
                 )
+                success = False
                 continue
             classification_path = doc_generator["classification_path"]
 
@@ -5361,6 +6632,7 @@ class Payload(object):
                         workspace_type
                     )
                 )
+                success = False
                 continue
             category_name = doc_generator["category_name"]
 
@@ -5370,6 +6642,7 @@ class Payload(object):
                         workspace_type
                     )
                 )
+                success = False
                 continue
             attributes = doc_generator["attributes"]
 
@@ -5419,6 +6692,7 @@ class Payload(object):
                         )
                     )
                     admin_context = True
+                    success = False
             else:
                 admin_context = True
 
@@ -5472,6 +6746,7 @@ class Payload(object):
                                 attribute_value
                             )
                         )
+                        success = False
                         continue
                     attribute_value = user["data"][0]["id"]
 
@@ -5532,6 +6807,7 @@ class Payload(object):
                             document_name, workspace_name
                         )
                     )
+                    success = False
                 else:
                     logger.info(
                         "Successfully generated document -> {} in workspace -> {}".format(
@@ -5554,6 +6830,11 @@ class Payload(object):
             # True = force new login with new user
             cookie = self._otcs.authenticate(True)
 
+        if success:
+            self.writeStatusFile(section_name, self._doc_generators)
+
+        return success
+
         # end method definition
 
     def initSAP(
@@ -5620,14 +6901,28 @@ class Payload(object):
 
         # end method definition
 
-    def processSAPRFCs(self, sap_object: object):
+    def processSAPRFCs(self, sap_object: object, section_name: str = "sapRFCs") -> bool:
         """Process SAP RFCs in payload and run them in SAP S/4HANA.
 
         Args:
             sap_object: SAP object
-        Return: None
+        Return:
+            bool: True if payload has been processed without errors, False otherwise
         """
 
+        if not self._doc_generators:
+            logger.info(
+                "Payload section -> {} is empty. Skipping...".format(section_name)
+            )
+            return True
+
+        # if this payload section has been processed successfully before we can return True
+        # and skip processing once more
+        if self.checkStatusFile(section_name):
+            return True
+
+        success: bool = True
+
         for sap_rfc in self._sap_rfcs:
             rfc_name = sap_rfc["name"]
 
@@ -5670,6 +6965,7 @@ class Payload(object):
             result = sap_object.call(rfc_name, rfc_call_options, rfc_params)
             if result == None:
                 logger.error("Failed to call SAP RFC -> {}".format(rfc_name))
+                success = False
             else:
                 logger.info(
                     "Successfully called RFC -> {}. Result -> {}".format(
@@ -5677,6 +6973,11 @@ class Payload(object):
                     )
                 )
 
+        if success:
+            self.writeStatusFile(section_name, self._sap_rfcs)
+
+        return success
+
         # end method definition
 
     def getPayload(self) -> dict: