cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/tasks/salesforce/UninstallPackaged.py

@@ -0,0 +1,56 @@
+from cumulusci.salesforce_api.metadata import ApiRetrievePackaged
+from cumulusci.tasks.salesforce import UninstallLocal
+from cumulusci.utils import temporary_dir, zip_subfolder
+
+
+class UninstallPackaged(UninstallLocal):
+
+    task_options = {
+        "package": {
+            "description": "The package name to uninstall.  All metadata from the package will be retrieved and a custom destructiveChanges.xml package will be constructed and deployed to delete all deleteable metadata from the package.  Defaults to project__package__name",
+            "required": True,
+        },
+        "purge_on_delete": {
+            "description": "Sets the purgeOnDelete option for the deployment.  Defaults to True",
+            "required": True,
+        },
+        "dry_run": {
+            "description": "Perform a dry run of the operation without actually deleting any components, and display the components that would be deleted."
+        },
+    }
+
+    def _init_options(self, kwargs):
+        super(UninstallPackaged, self)._init_options(kwargs)
+        if "package" not in self.options:
+            self.options["package"] = self.project_config.project__package__name
+
+    def _retrieve_packaged(self):
+        retrieve_api = ApiRetrievePackaged(
+            self,
+            self.options["package"],
+            self.project_config.project__package__api_version,
+        )
+        packaged = retrieve_api()
+        packaged = zip_subfolder(packaged, self.options["package"])
+        return packaged
+
+    def _get_destructive_changes(self, path=None):
+        self.logger.info(
+            "Retrieving metadata in package {} from target org".format(
+                self.options["package"]
+            )
+        )
+        packaged = self._retrieve_packaged()
+
+        with temporary_dir() as tempdir:
+            packaged.extractall(tempdir)
+            destructive_changes = super(
+                UninstallPackaged, self
+            )._get_destructive_changes(tempdir)
+
+        self.logger.info(
+            "Deleting metadata in package {} from target org".format(
+                self.options["package"]
+            )
+        )
+        return destructive_changes

cumulusci/tasks/salesforce/UpdateAdminProfile.py

@@ -0,0 +1,8 @@
+# for backwards compatibility
+from cumulusci.tasks.salesforce.update_profile import *  # noqa
+from cumulusci.utils.deprecation import warn_moved
+
+warn_moved(
+    "cumulusci.tasks.salesforce.update_profile",
+    __name__,
+)

cumulusci/tasks/salesforce/__init__.py

@@ -0,0 +1,79 @@
+"""Salesforce tasks
+
+This package uses a lazy import system inspired by werkzeug
+(for startup speed and to avoid problems with import cycles).
+We should be able to replace LazyModule with a module-level __getattr__
+one we drop support for Python 3.6.
+"""
+
+from types import ModuleType
+import sys
+
+ORIGINS = {
+    "BaseRetrieveMetadata": "cumulusci.tasks.salesforce.BaseRetrieveMetadata",
+    "BaseSalesforceTask": "cumulusci.tasks.salesforce.BaseSalesforceTask",
+    "BaseSalesforceApiTask": "cumulusci.tasks.salesforce.BaseSalesforceApiTask",
+    "BaseSalesforceMetadataApiTask": "cumulusci.tasks.salesforce.BaseSalesforceMetadataApiTask",
+    "BaseUninstallMetadata": "cumulusci.tasks.salesforce.BaseUninstallMetadata",
+    "CreateCommunity": "cumulusci.tasks.salesforce.CreateCommunity",
+    "CreatePackage": "cumulusci.tasks.salesforce.CreatePackage",
+    "Deploy": "cumulusci.tasks.salesforce.Deploy",
+    "DeployBundles": "cumulusci.tasks.salesforce.DeployBundles",
+    "EnsureRecordTypes": "cumulusci.tasks.salesforce.EnsureRecordTypes",
+    "GetInstalledPackages": "cumulusci.tasks.preflight.packages",
+    "InstallPackageVersion": "cumulusci.tasks.salesforce.install_package_version",
+    "ListCommunities": "cumulusci.tasks.salesforce.ListCommunities",
+    "ListCommunityTemplates": "cumulusci.tasks.salesforce.ListCommunityTemplates",
+    "LoadCustomSettings": "cumulusci.tasks.salesforce.custom_settings",
+    "PackageUpload": "cumulusci.tasks.salesforce.package_upload",
+    "ProfileGrantAllAccess": "cumulusci.tasks.salesforce.update_profile",
+    "PublishCommunity": "cumulusci.tasks.salesforce.PublishCommunity",
+    "RetrievePackaged": "cumulusci.tasks.salesforce.RetrievePackaged",
+    "RetrieveReportsAndDashboards": "cumulusci.tasks.salesforce.RetrieveReportsAndDashboards",
+    "DescribeMetadataTypes": "cumulusci.tasks.salesforce.DescribeMetadataTypes",
+    "RetrieveUnpackaged": "cumulusci.tasks.salesforce.RetrieveUnpackaged",
+    "SOQLQuery": "cumulusci.tasks.salesforce.SOQLQuery",
+    "SetTDTMHandlerStatus": "cumulusci.tasks.salesforce.trigger_handlers",
+    "UninstallLocal": "cumulusci.tasks.salesforce.UninstallLocal",
+    "UninstallLocalBundles": "cumulusci.tasks.salesforce.UninstallLocalBundles",
+    "UninstallLocalNamespacedBundles": "cumulusci.tasks.salesforce.UninstallLocalNamespacedBundles",
+    "UninstallPackage": "cumulusci.tasks.salesforce.UninstallPackage",
+    "UninstallPackaged": "cumulusci.tasks.salesforce.UninstallPackaged",
+    "UninstallPackagedIncremental": "cumulusci.tasks.salesforce.uninstall_packaged_incremental",
+    "UpdateDependencies": "cumulusci.tasks.salesforce.update_dependencies",
+    "UpdateProfile": "cumulusci.tasks.salesforce.update_profile",
+    "UpdateAdminProfile": "cumulusci.tasks.salesforce.update_profile",
+}
+
+
+class LazyModule(ModuleType):
+    def __getattr__(self, name):
+        # Import and set attribute on demand
+        # (__getattr__ is only called if it hasn't been set already)
+        if name in ORIGINS:
+            origin = ORIGINS[name]
+            module = __import__(origin, None, None, [name])
+            setattr(self, name, getattr(module, name))
+        return ModuleType.__getattribute__(self, name)
+
+    def __setattr__(self, name, value):
+        # Avoid shadowing our intended classes with submodules of the same name
+        # when they are imported.
+        if name in ORIGINS and isinstance(value, ModuleType):
+            return
+        ModuleType.__setattr__(self, name, value)
+
+
+# create LazyModule and replace the reference to ourself in sys.modules
+new_module = sys.modules[__name__] = LazyModule(__name__)
+
+# copy over some special attributes
+new_module.__dict__.update(
+    {
+        "__doc__": __doc__,
+        "__file__": __file__,
+        "__path__": __path__,
+        "__spec__": __spec__,
+        "__all__": tuple(ORIGINS),
+    }
+)

cumulusci/tasks/salesforce/activate_flow.py

@@ -0,0 +1,74 @@
+from cumulusci.core.exceptions import TaskOptionsError
+from cumulusci.core.utils import process_list_arg
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+
+
+class ActivateFlow(BaseSalesforceApiTask):
+    """
+    Activate the Flows with the supplied Developer Names
+    """
+
+    task_options = {
+        "developer_names": {
+            "description": "List of DeveloperNames to query in SOQL",
+            "required": True,
+        },
+        "status": {
+            "description": "Flag to check whether to activate or deactivate the flow",
+            "required": False,
+        },
+    }
+
+    def _init_options(self, kwargs):
+        super(ActivateFlow, self)._init_options(kwargs)
+        self.options["developer_names"] = process_list_arg(
+            self.options.get("developer_names")
+        )
+        self.api_version = self.project_config.project__api_version
+        if not self.options["developer_names"]:
+            raise TaskOptionsError(
+                "Error you are missing developer_names definition in your task cumulusci.yml file. Please pass in developer_names for your task configuration or use -o to developer_names as a commandline argument"
+            )
+
+    def _run_task(self):
+        if self.options["status"]:
+            self.logger.info(
+                f"Activating the following Flows: {self.options['developer_names']}"
+            )
+        else:
+            self.logger.info(
+                f"Deactivating the following Flows: {self.options['developer_names']}"
+            )
+
+        self.logger.info("Querying flow definitions...")
+        result = self.tooling.query(
+            "SELECT Id, ActiveVersion.VersionNumber, LatestVersion.VersionNumber, DeveloperName FROM FlowDefinition WHERE DeveloperName IN ({0})".format(
+                ",".join([f"'{n}'" for n in self.options["developer_names"]])
+            )
+        )
+
+        results = []
+        for listed_flow in result["records"]:
+            results.append(listed_flow["DeveloperName"])
+            self.logger.info(f'Processing: {listed_flow["DeveloperName"]}')
+            path = f"tooling/sobjects/FlowDefinition/{listed_flow['Id']}"
+
+            urlpath = self.sf.base_url + path
+
+            if self.options["status"]:
+                updated_version_number = listed_flow["LatestVersion"]["VersionNumber"]
+            else:
+                updated_version_number = 0
+            data = {"Metadata": {"activeVersionNumber": updated_version_number}}
+            self.logger.info(urlpath)
+            response = self.tooling._call_salesforce("PATCH", urlpath, json=data)
+            self.logger.info(response)
+
+        excluded = []
+        for i in self.options["developer_names"]:
+            if i not in results:
+                excluded.append(i)
+        if len(excluded) > 0:
+            self.logger.warning(
+                f"The following developer names were not found: {excluded}"
+            )

cumulusci/tasks/salesforce/check_components.py

@@ -0,0 +1,324 @@
+import json
+import os
+import shutil
+import tempfile
+from collections import defaultdict
+from itertools import chain
+from xml.etree.ElementTree import ParseError
+
+from defusedxml.minidom import parseString
+
+from cumulusci.core.config import FlowConfig, TaskConfig
+from cumulusci.core.exceptions import TaskOptionsError
+from cumulusci.core.flowrunner import FlowCoordinator
+from cumulusci.core.sfdx import convert_sfdx_source
+from cumulusci.core.utils import process_list_arg
+from cumulusci.salesforce_api.metadata import ApiRetrieveUnpackaged
+from cumulusci.tasks.metadata.package import process_common_components
+from cumulusci.tasks.salesforce import BaseSalesforceTask
+from cumulusci.utils import cd
+from cumulusci.utils.xml import metadata_tree
+
+
+class CheckComponents(BaseSalesforceTask):
+    api_retrieve_unpackaged = ApiRetrieveUnpackaged
+    task_options = {
+        "paths": {
+            "description": "List of deploy paths to check",
+            "required": False,
+        },
+        "name": {
+            "description": "The name of the current plan or flow to detect deploy paths",
+            "required": False,
+        },
+    }
+    deploy_paths = []
+
+    def _init_options(self, kwargs):
+        super(CheckComponents, self)._init_options(kwargs)
+        if "paths" in self.options and "name" in self.options:
+            raise TaskOptionsError("Please provide either --paths or --name")
+        if "paths" not in self.options and "name" not in self.options:
+            raise TaskOptionsError(
+                "This task requires a plan/flow name or paths options. Pass --paths or --name options"
+            )
+
+    def _run_task(self):
+        # Check if paths are provided in options. Assuming to only check for those paths
+        paths = self.options.get("paths")
+        plan_or_flow_name = self.options.get("name")
+
+        (
+            components,
+            api_retrieve_unpackaged_response,
+        ) = self.get_repo_existing_components(plan_or_flow_name, paths)
+
+        if not components:
+            self.logger.info("No components found in deploy path")
+            raise TaskOptionsError("No plan or paths options provided")
+
+        self.logger.debug("Components detected at source")
+        for component_type, component_names in components.items():
+            self.logger.debug(f"{component_type}: {', '.join(component_names)}")
+        # check common components
+        components.pop("Settings", None)
+        existing_components = process_common_components(
+            api_retrieve_unpackaged_response, components
+        )
+
+        if existing_components:
+            self.logger.info("Components exists in the target org:")
+            for component_type, component_names in existing_components.items():
+                self.logger.info(f"{component_type}: {', '.join(component_names)}")
+            self.return_values["existing_components"] = existing_components
+        else:
+            self.logger.info(
+                "No components from the deploy paths exist in the target org."
+            )
+
+    def get_repo_existing_components(self, plan_or_flow_name, paths=""):
+        if paths:
+            paths = process_list_arg(paths)
+            self.logger.info(f"Using provided paths: {paths}")
+            self.deploy_paths = paths
+        elif plan_or_flow_name:
+            # if path is not provided
+            is_plan = self._is_plan(plan_or_flow_name)
+            if is_plan is None:
+                raise TaskOptionsError(
+                    f"Plan or flow name '{plan_or_flow_name}' not found"
+                )
+
+            self.logger.info(
+                f"Analyzing project {'plan' if is_plan else 'flow'}: {plan_or_flow_name}"
+            )
+
+            # load deploy paths from all the steps in plan or flow
+            self._load_deploy_paths(plan_or_flow_name, is_plan)
+            if not self.deploy_paths:
+                self.logger.warning("No deploy paths found in the plan or flow.")
+                return
+            self.logger.debug(
+                f"deploy paths found in the plan or flow.{self.deploy_paths}"
+            )
+        # Temp dir to copy all deploy paths from task options
+        temp_dir = tempfile.mkdtemp()
+        self.logger.info(f"Temporary deploy directory created: {temp_dir}")
+        mdapi_components = {}
+        mdapi_response_messages = []
+        for path in self.deploy_paths:
+            full_path = os.path.join(self.project_config.repo_root, path)
+            if not os.path.exists(full_path):
+                self.logger.info(f"Skipping path: '{path}' - path doesn't exist")
+                continue
+            elif "package.xml" in os.listdir(full_path):
+                package_xml_path = os.path.join(full_path, "package.xml")
+                source_xml_tree = metadata_tree.parse(package_xml_path)
+                components = metadata_tree.parse_package_xml_types(
+                    "name", source_xml_tree
+                )
+                response_messages = self._get_api_object_responce(
+                    package_xml_path, source_xml_tree.version.text
+                )
+                merged = {}
+                for key in set(components).union(mdapi_components):
+                    merged[key] = list(
+                        set(
+                            chain(
+                                components.get(key, []), mdapi_components.get(key, [])
+                            )
+                        )
+                    )
+                mdapi_components = merged
+                mdapi_response_messages.extend(response_messages)
+                continue
+            self._copy_to_tempdir(path, temp_dir)
+
+        (
+            components,
+            api_retrieve_unpackaged_response,
+        ) = self._collect_components_from_paths(temp_dir)
+
+        # remove temp dir
+        shutil.rmtree(temp_dir)
+        merged = {}
+        if components:
+            for key in set(components).union(mdapi_components):
+                merged[key] = list(
+                    set(chain(components.get(key, []), mdapi_components.get(key, [])))
+                )
+            components = merged
+        else:
+            components = mdapi_components
+
+        if api_retrieve_unpackaged_response:
+            api_retrieve_unpackaged_response.extend(mdapi_response_messages)
+        else:
+            api_retrieve_unpackaged_response = mdapi_response_messages
+
+        return [components, api_retrieve_unpackaged_response]
+
+    def _copy_to_tempdir(self, src_dir, temp_dir):
+        for item in os.listdir(src_dir):
+            src_item = os.path.join(src_dir, item)
+            dst_item = os.path.join(temp_dir, item)
+
+            if os.path.isdir(src_item):
+                if not os.path.exists(dst_item):
+                    shutil.copytree(src_item, dst_item)
+                else:
+                    self._merge_directories(src_item, dst_item)
+            else:
+                if not os.path.exists(dst_item):
+                    shutil.copy2(src_item, dst_item)
+                else:
+                    self.logger.debug(f"File {dst_item} already exists, skipping...")
+
+    def _merge_directories(self, src_dir, dst_dir):
+        for item in os.listdir(src_dir):
+            src_item = os.path.join(src_dir, item)
+            dst_item = os.path.join(dst_dir, item)
+
+            if os.path.isdir(src_item):
+                if not os.path.exists(dst_item):
+                    shutil.copytree(src_item, dst_item)
+                    self._merge_directories(src_item, dst_item)
+            else:
+                if not os.path.exists(dst_item):
+                    shutil.copy2(src_item, dst_item)  # Copy file if it doesn't exist
+                else:
+                    self.logger.debug(f"File {dst_item} already exists, skipping...")
+
+    def _is_plan(self, name):
+
+        if self.project_config.lookup(f"plans__{name}") is not None:
+            return True
+        elif self.project_config.lookup(f"flows__{name}") is not None:
+            return False
+        else:
+            raise TaskOptionsError(
+                "No paths provided and unable to determine the current plan or flow name."
+            )
+
+    def _get_plan_tasks(self, name, is_plan=False):
+
+        tasks = []
+        if is_plan:
+            step_config = self.project_config.lookup(f"plans__{name}")
+        else:
+            step_config = self.project_config.lookup(f"flows__{name}")
+
+        tasks = self._freeze_steps(self.project_config, step_config)
+
+        return tasks
+
+    def _freeze_steps(self, project_config, plan_config) -> list:
+        steps = plan_config["steps"]
+        flow_config = FlowConfig(plan_config)
+        flow_config.project_config = project_config
+        flow = FlowCoordinator(project_config, flow_config)
+        steps = []
+        for step in flow.steps:
+            if step.skip:
+                continue
+            with cd(step.project_config.repo_root):
+                task = step.task_class(
+                    step.project_config,
+                    TaskConfig(step.task_config),
+                    name=step.task_name,
+                )
+                steps.extend(task.freeze(step))
+        self.logger.debug("Prepared steps:\n" + json.dumps(steps, indent=4))
+        return steps
+
+    def _load_deploy_paths(self, name, is_plan=False):
+        tasks = self._get_plan_tasks(name, is_plan)
+        if tasks:
+            self.deploy_paths = self._get_deployable_paths(tasks)
+
+    def _get_deployable_paths(self, tasks):
+        found_paths = []
+        paths_to_search = ["path", "subfolder"]
+        for task in tasks:
+            if "task_config" in task and "options" in task["task_config"]:
+                options = task["task_config"]["options"]
+                found_paths.extend(self._search_for_paths(options, paths_to_search))
+        return found_paths
+
+    def _search_for_paths(self, options, keys_to_search):
+        found_values = []
+
+        if not keys_to_search:
+            return found_values
+
+        def recursive_search(obj):
+            if isinstance(obj, dict):
+                for key, value in obj.items():
+                    if key in keys_to_search and isinstance(value, str):
+                        found_values.append(value)
+                    elif isinstance(value, (dict, list)):
+                        recursive_search(value)
+
+            elif isinstance(obj, list):
+                for item in obj:
+                    recursive_search(item)
+
+        recursive_search(options)
+
+        return found_values
+
+    def _collect_components_from_paths(self, full_path):
+
+        if not os.path.exists(full_path):
+            return None, None
+
+        components = defaultdict(set)
+        self.logger.info(f"Collecting components from path: {full_path}")
+        # remove if any exiting package.xml files coppied from deploy_pre/post paths
+
+        if os.path.exists(os.path.join(full_path, "package.xml")):
+            os.remove(os.path.join(full_path, "package.xml"))
+
+        with convert_sfdx_source(full_path, None, self.logger) as src_path:
+            package_xml_path = os.path.join(src_path, "package.xml")
+            if os.path.exists(package_xml_path):
+                try:
+                    source_xml_tree = metadata_tree.parse(package_xml_path)
+                    self.logger.info("parsing package.xml")
+
+                    components = metadata_tree.parse_package_xml_types(
+                        "name", source_xml_tree
+                    )
+
+                    response_messages = self._get_api_object_responce(
+                        package_xml_path, source_xml_tree.version.text
+                    )
+
+                    return [components, response_messages]
+
+                except ParseError as e:
+                    self.logger.error(f"Error parsing package.xml: {e}")
+                    return None, None
+            else:
+                self.logger.warning(
+                    f"No package.xml found in {full_path}, scanning directories"
+                )
+
+        return None, None
+
+    def _get_api_object_responce(self, pakcage_xml_path, version):
+
+        if not os.path.exists(pakcage_xml_path):
+            return None
+
+        package_xml = open(pakcage_xml_path, "r")
+
+        api_retrieve_unpackaged_object = self.api_retrieve_unpackaged(
+            self, package_xml.read(), version
+        )
+
+        response_messages = parseString(
+            api_retrieve_unpackaged_object._get_response().content
+        ).getElementsByTagName("messages")
+
+        return response_messages

cumulusci/tasks/salesforce/composite.py

@@ -0,0 +1,142 @@
+import json
+import random
+import re
+import string
+from pathlib import Path
+
+from cumulusci.cli.ui import CliTable
+from cumulusci.core.exceptions import SalesforceException
+from cumulusci.core.utils import process_bool_arg, process_list_arg, determine_managed_mode
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+from cumulusci.utils import inject_namespace
+
+API_ROLLBACK_MESSAGE = "The transaction was rolled back since another operation in the same transaction failed."
+API_INVALID_REF_MESSAGE = "Invalid reference specified."
+
+
+class CompositeApi(BaseSalesforceApiTask):
+    task_docs = """
+This task is a wrapper for Composite REST API calls. Given a list of JSON files
+(one request body per file), POST each and process the returned composite
+result. Files are processed in the order given by the ``data_files`` option.
+
+In addition, this task will process the request body and replace namespace
+(``%%%NAMESPACE%%%``) and user ID (``%%%USERID%%%``) tokens. To avoid username
+collisions, use the ``randomize_username`` option to replace the top-level
+domains in any ``Username`` field with a random string.
+
+When the top-level ``allOrNone`` property for the request is set to true a
+SalesforceException is raised if an error is returned for any subrequest,
+otherwise partial successes will not raise an exception.
+
+Example Task Definition
+-----------------------
+
+.. code-block::  yaml
+
+  tasks:
+      example_composite_request:
+          class_path: cumulusci.tasks.salesforce.composite.CompositeApi
+          options:
+             data_files:
+                 - "datasets/composite/users.json"
+                 - "datasets/composite/setup_objects.json"
+    """
+
+    task_options = {
+        "data_files": {
+            "description": "A list of paths, where each path is a JSON file containing a composite request body.",
+            "required": True,
+        },
+        "managed": {
+            "description": "If True, replaces namespace tokens with the namespace prefix.",
+            "default": False,
+        },
+        "namespaced": {
+            "description": "If True, replaces namespace tokens with the namespace prefix.",
+            "default": False,
+        },
+        "randomize_username": {
+            "description": "If True, randomize the TLD for any 'Username' fields.",
+            "default": False,
+        },
+    }
+
+    def _init_options(self, kwargs):
+        super()._init_options(kwargs)
+        self.data_files = process_list_arg(self.options.get("data_files") or [])
+
+    def _run_task(self):
+        for data_file_path in self.data_files:
+            self.logger.info(f"Processing {data_file_path}")
+            self._composite_request(data_file_path)
+
+    def _composite_request(self, data_file_path):
+        request_body = self._process_json(Path(data_file_path).read_text())
+        self.is_all_or_none = json.loads(request_body).get("allOrNone", False)
+        result = self.sf.restful("composite", method="POST", data=request_body)
+        self._process_response(result)
+
+    def _process_json(self, body):
+        """Replace namespace tokens and randomize username domains."""
+        user_id = self.org_config.user_id
+        body = body.replace("%%%USERID%%%", user_id)
+
+        namespace = self.project_config.project__package__namespace
+        managed = determine_managed_mode(
+            self.options, self.project_config, self.org_config
+        )
+
+        _, body = inject_namespace(
+            "composite",
+            body,
+            namespace=namespace,
+            managed=managed,
+            namespaced_org=self.options.get("namespaced", self.org_config.namespaced),
+        )
+
+        if self.options.get("randomize_username", False):
+            random_tld = "".join(random.choices(string.ascii_lowercase, k=4))
+            body = re.sub(
+                r'("Username": .[\w-]+@[\w-]+\.)+[\w-]+', rf"\1{random_tld}", body
+            )
+
+        return body
+
+    def _process_response(self, result):
+        """Handle the compositeResponse and raise an exception if failed."""
+        subrequests = result["compositeResponse"]
+        status_codes = {subrequest["httpStatusCode"] for subrequest in subrequests}
+
+        all_success = all([self._http_ok(code) for code in status_codes])
+        if self.is_all_or_none and not all_success:
+            self._log_exception_message(subrequests)
+            raise SalesforceException(json.dumps(subrequests, indent=2))
+        else:
+            self._log_success_message(subrequests)
+
+    def _http_ok(self, status_code):
+        return status_code >= 200 and status_code < 300
+
+    def _log_exception_message(self, subrequests):
+        table_data = [["ReferenceId", "Message"]]
+        table_data.extend(
+            [sub["referenceId"], body["message"]]
+            for sub in subrequests
+            for body in sub["body"]
+            if body.get("message") != API_ROLLBACK_MESSAGE
+        )
+        table = CliTable(
+            table_data,
+        )
+        self.logger.error("The request failed with the following message(s):\n\n")
+        table.echo()
+
+    def _log_success_message(self, subrequests):
+        table_data = [["ReferenceId", "Success"]]
+        table_data.extend(
+            [sub["referenceId"], self._http_ok(sub["httpStatusCode"])]
+            for sub in subrequests
+        )
+        table = CliTable(table_data, title="Subrequest Results")
+        table.echo()