cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/tasks/salesforce/BaseRetrieveMetadata.py

@@ -0,0 +1,58 @@
+import functools
+from zipfile import ZipFile
+
+from cumulusci.tasks.salesforce.BaseSalesforceMetadataApiTask import (
+    BaseSalesforceMetadataApiTask,
+)
+from cumulusci.utils import process_text_in_zipfile, strip_namespace, tokenize_namespace
+
+
+class BaseRetrieveMetadata(BaseSalesforceMetadataApiTask):
+    task_options = {
+        "path": {
+            "description": "The path to write the retrieved metadata",
+            "required": True,
+        },
+        "namespace_strip": {
+            "description": "If set, all namespace prefixes for the namespace specified are stripped from files and filenames"
+        },
+        "namespace_tokenize": {
+            "description": "If set, all namespace prefixes for the namespace specified are replaced with tokens for use with namespace_inject"
+        },
+        "namespaced_org": {
+            "description": "If True, the tokens %%%NAMESPACED_ORG%%% and ___NAMESPACED_ORG___ will get replaced with the namespace.  The default is false causing those tokens to get stripped and replaced with an empty string.  Set this if deploying to a namespaced scratch org or packaging org."
+        },
+    }
+
+    def _run_task(self):
+        api = self._get_api()
+        src_zip = api()
+        self._extract_zip(src_zip)
+        self.logger.info(
+            "Extracted retrieved metadata into {}".format(self.options["path"])
+        )
+
+    def _process_namespace(self, src_zip):
+        if self.options.get("namespace_tokenize"):
+            src_zip = process_text_in_zipfile(
+                src_zip,
+                functools.partial(
+                    tokenize_namespace,
+                    namespace=self.options["namespace_tokenize"],
+                    logger=self.logger,
+                ),
+            )
+        if self.options.get("namespace_strip"):
+            src_zip = process_text_in_zipfile(
+                src_zip,
+                functools.partial(
+                    strip_namespace,
+                    namespace=self.options["namespace_strip"],
+                    logger=self.logger,
+                ),
+            )
+        return src_zip
+
+    def _extract_zip(self, src_zip: ZipFile):
+        src_zip = self._process_namespace(src_zip)
+        src_zip.extractall(self.options["path"])

cumulusci/tasks/salesforce/BaseSalesforceApiTask.py

@@ -0,0 +1,45 @@
+from salesforce_bulk import SalesforceBulk
+
+from cumulusci.core.exceptions import ConfigError
+from cumulusci.core.tasks import BaseSalesforceTask
+from cumulusci.salesforce_api.utils import get_simple_salesforce_connection
+
+
+class BaseSalesforceApiTask(BaseSalesforceTask):
+    name = "BaseSalesforceApiTask"
+    api_version = None
+
+    def _init_task(self):
+        super()._init_task()
+        self.sf = self._init_api()
+        self.bulk = self._init_bulk()
+        self.tooling = self._init_api("tooling")
+        self._init_class()
+
+    def _init_api(self, base_url=None):
+        rv = get_simple_salesforce_connection(
+            self.project_config,
+            self.org_config,
+            api_version=self.api_version,
+            base_url=base_url,
+        )
+
+        return rv
+
+    def _init_bulk(self):
+        version = self.api_version or self.project_config.project__package__api_version
+        if not version:
+            raise ConfigError("Cannot find Salesforce version")
+        return SalesforceBulk(
+            host=self.org_config.instance_url.replace("https://", "").rstrip("/"),
+            sessionId=self.org_config.access_token,
+            API_version=version,
+        )
+
+    def _init_class(self):
+        pass
+
+    def _get_tooling_object(self, obj_name):
+        obj = getattr(self.tooling, obj_name)
+        obj.base_url = obj.base_url.replace("/sobjects/", "/tooling/sobjects/")
+        return obj

cumulusci/tasks/salesforce/BaseSalesforceMetadataApiTask.py

@@ -0,0 +1,18 @@
+from cumulusci.tasks.salesforce import BaseSalesforceTask
+
+
+class BaseSalesforceMetadataApiTask(BaseSalesforceTask):
+    api_class = None
+    name = "BaseSalesforceMetadataApiTask"
+
+    def _get_api(self):
+        return self.api_class(self)
+
+    def _run_task(self):
+        api = self._get_api()
+        result = None
+        if api:
+            result = api()
+            self.org_config.reset_installed_packages()
+            self.return_values = result
+        return result

cumulusci/tasks/salesforce/BaseSalesforceTask.py

@@ -0,0 +1,4 @@
+# This moved to prevent an import cycle.
+from cumulusci.core.tasks import BaseSalesforceTask
+
+__all__ = ("BaseSalesforceTask",)

cumulusci/tasks/salesforce/BaseUninstallMetadata.py

@@ -0,0 +1,41 @@
+from cumulusci.core.utils import process_bool_arg
+from cumulusci.salesforce_api.package_zip import DestructiveChangesZipBuilder
+from cumulusci.tasks.salesforce import Deploy
+
+uninstall_task_options = Deploy.task_options.copy()
+uninstall_task_options["purge_on_delete"] = {
+    "description": "Sets the purgeOnDelete option for the deployment. Defaults to True"
+}
+uninstall_task_options["dry_run"] = {
+    "description": "Perform a dry run of the operation without actually deleting any components, and display the components that would be deleted."
+}
+
+
+class BaseUninstallMetadata(Deploy):
+    task_options = uninstall_task_options
+
+    def _init_options(self, kwargs):
+        super(BaseUninstallMetadata, self)._init_options(kwargs)
+        self.options["purge_on_delete"] = process_bool_arg(
+            self.options.get("purge_on_delete", True)
+        )
+        self.options["dry_run"] = process_bool_arg(self.options.get("dry_run", False))
+
+    def _get_api(self, path=None):
+        destructive_changes = self._get_destructive_changes(path=path)
+        if not destructive_changes:
+            return
+        if self.options["dry_run"]:
+            self.logger.info(
+                "Performing uninstall dry run. This destructive deployment was created:"
+            )
+            self.logger.info(destructive_changes)
+            return
+
+        package_zip = DestructiveChangesZipBuilder(
+            destructive_changes, self.project_config.project__package__api_version
+        )
+        api = self.api_class(
+            self, package_zip(), purge_on_delete=self.options["purge_on_delete"]
+        )
+        return api

cumulusci/tasks/salesforce/CreateCommunity.py

@@ -0,0 +1,124 @@
+import json
+from datetime import datetime
+
+from simple_salesforce.exceptions import SalesforceMalformedRequest
+
+from cumulusci.core.exceptions import CumulusCIException, SalesforceException
+from cumulusci.core.utils import process_bool_arg
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+
+
+class CreateCommunity(BaseSalesforceApiTask):
+    COMMUNITY_EXISTS_ERROR_MSG = "Enter a different name. That one already exists."
+    api_version = "48.0"
+    task_docs = """
+    Create a Salesforce Community via the Connect API.
+
+    Specify the `template` "VF Template" for Visualforce Tabs community,
+    or the name for a specific desired template
+    """
+    task_options = {
+        "template": {
+            "description": "Name of the template for the community.",
+            "required": True,
+        },
+        "name": {"description": "Name of the community.", "required": True},
+        "description": {
+            "description": "Description of the community.",
+            "required": False,
+        },
+        "url_path_prefix": {
+            "description": "URL prefix for the community.",
+            "required": False,
+        },
+        "retries": {
+            "description": "Number of times to retry community creation request"
+        },
+        "timeout": {
+            "description": "Time to wait, in seconds, for the community to be created"
+        },
+        "skip_existing": {
+            "description": "If True, an existing community with the "
+            "same name will not raise an exception."
+        },
+    }
+
+    def _init_options(self, kwargs):
+        super(CreateCommunity, self)._init_options(kwargs)
+        self.options["retries"] = int(self.options.get("retries", 6))
+        self.options["timeout"] = int(self.options.get("timeout", 300))
+        self.options["skip_existing"] = process_bool_arg(
+            self.options.get("skip_existing", False)
+        )
+
+    def _run_task(self):
+        community = self._get_community()
+        if community is not None:
+            error_msg = f'A community named "{self.options["name"]}" already exists.'
+            if self.options["skip_existing"]:
+                self.logger.info(error_msg)
+                return
+            raise CumulusCIException(error_msg)
+
+        self.logger.info('Creating community "{}"'.format(self.options["name"]))
+        tries = 0
+        while True:
+            tries += 1
+            try:
+                self._create_community()
+            except Exception as e:
+                if tries > self.options["retries"]:
+                    raise
+                else:
+                    self.logger.warning(str(e))
+                    self.logger.info("Retrying community creation request")
+                    self.poll_interval_s = 1
+            else:
+                break  # pragma: no cover
+
+    def _create_community(self):
+        payload = {
+            "name": self.options["name"],
+            "description": self.options.get("description") or "",
+            "templateName": self.options["template"],
+            "urlPathPrefix": self.options.get("url_path_prefix") or "",
+        }
+
+        self.logger.info("Sending request to create Community")
+        try:
+            self.sf.restful(
+                "connect/communities", method="POST", data=json.dumps(payload)
+            )
+        except SalesforceMalformedRequest as e:
+            if CreateCommunity.COMMUNITY_EXISTS_ERROR_MSG in str(e):
+                # We can end up here if the previous try timed out
+                # but the community finished creating before we tried again.
+                community = self._get_community()
+                self.poll_complete = True
+                self.logger.info("Community {} created".format(community["id"]))
+                return
+            else:
+                raise
+
+        # Wait for the community to be created
+        self.time_start = datetime.now()
+        self._poll()
+
+    def _poll_action(self):
+        elapsed = datetime.now() - self.time_start
+        if elapsed.total_seconds() > self.options["timeout"]:
+            raise SalesforceException(
+                "Community creation not finished after {timeout} seconds".format(
+                    **self.options
+                )
+            )
+
+        community = self._get_community()
+        if community is not None:
+            self.poll_complete = True
+            self.logger.info("Community {} created".format(community["id"]))
+
+    def _get_community(self):
+        community_list = self.sf.restful("connect/communities")["communities"]
+        communities = {c["name"].lower().upper(): c for c in community_list}
+        return communities.get(self.options["name"].lower().upper())

cumulusci/tasks/salesforce/CreatePackage.py

@@ -0,0 +1,29 @@
+from cumulusci.salesforce_api.package_zip import CreatePackageZipBuilder
+from cumulusci.tasks.salesforce import Deploy
+
+
+class CreatePackage(Deploy):
+    task_options = {
+        "package": {
+            "description": "The name of the package to create.  Defaults to project__package__name",
+            "required": True,
+        },
+        "api_version": {
+            "description": "The api version to use when creating the package.  Defaults to project__package__api_version",
+            "required": True,
+        },
+    }
+
+    def _init_options(self, kwargs):
+        super(CreatePackage, self)._init_options(kwargs)
+        if "package" not in self.options:
+            self.options["package"] = self.project_config.project__package__name
+        if "api_version" not in self.options:
+            self.options[
+                "api_version"
+            ] = self.project_config.project__package__api_version
+
+    def _get_package_zip(self, path=None):
+        return CreatePackageZipBuilder(
+            self.options["package"], self.options["api_version"]
+        ).as_base64()

cumulusci/tasks/salesforce/Deploy.py

@@ -0,0 +1,240 @@
+import pathlib
+from typing import List, Optional, Union
+
+from defusedxml.minidom import parseString
+from pydantic import ValidationError
+
+from cumulusci.cli.ui import CliTable
+from cumulusci.core.dependencies.utils import TaskContext
+from cumulusci.core.exceptions import TaskOptionsError
+from cumulusci.core.sfdx import convert_sfdx_source
+from cumulusci.core.source_transforms.transforms import (
+    SourceTransform,
+    SourceTransformList,
+)
+from cumulusci.core.utils import process_bool_arg, process_list_arg, determine_managed_mode
+from cumulusci.salesforce_api.metadata import ApiDeploy, ApiRetrieveUnpackaged
+from cumulusci.salesforce_api.package_zip import MetadataPackageZipBuilder
+from cumulusci.salesforce_api.rest_deploy import RestDeploy
+from cumulusci.tasks.metadata.package import process_common_components
+from cumulusci.tasks.salesforce.BaseSalesforceMetadataApiTask import (
+    BaseSalesforceMetadataApiTask,
+)
+from cumulusci.utils.xml import metadata_tree
+
+
+class Deploy(BaseSalesforceMetadataApiTask):
+    api_class = ApiDeploy
+    api_retrieve_unpackaged = ApiRetrieveUnpackaged
+    task_options = {
+        "path": {
+            "description": "The path to the metadata source to be deployed",
+            "required": True,
+        },
+        "unmanaged": {
+            "description": "If True, changes namespace_inject to replace tokens with a blank string"
+        },
+        "namespace_inject": {
+            "description": "If set, the namespace tokens in files and filenames are replaced with the namespace's prefix"
+        },
+        "namespace_strip": {
+            "description": "If set, all namespace prefixes for the namespace specified are stripped from files and filenames"
+        },
+        "check_only": {
+            "description": "If True, performs a test deployment (validation) of components without saving the components in the target org"
+        },
+        "collision_check": {
+            "description": "If True, performs a collision check with metadata already present in the target org"
+        },
+        "test_level": {
+            "description": "Specifies which tests are run as part of a deployment. Valid values: NoTestRun, RunLocalTests, RunAllTestsInOrg, RunSpecifiedTests."
+        },
+        "specified_tests": {
+            "description": "Comma-separated list of test classes to run upon deployment. Applies only with test_level set to RunSpecifiedTests."
+        },
+        "static_resource_path": {
+            "description": "The path where decompressed static resources are stored.  Any subdirectories found will be zipped and added to the staticresources directory of the build."
+        },
+        "namespaced_org": {
+            "description": "If True, the tokens %%%NAMESPACED_ORG%%% and ___NAMESPACED_ORG___ will get replaced with the namespace.  The default is false causing those tokens to get stripped and replaced with an empty string.  Set this if deploying to a namespaced scratch org or packaging org."
+        },
+        "clean_meta_xml": {
+            "description": "Defaults to True which strips the <packageVersions/> element from all meta.xml files.  The packageVersion element gets added automatically by the target org and is set to whatever version is installed in the org.  To disable this, set this option to False"
+        },
+        "transforms": {
+            "description": "Apply source transforms before deploying. See the CumulusCI documentation for details on how to specify transforms."
+        },
+        "rest_deploy": {"description": "If True, deploy metadata using REST API"},
+    }
+
+    namespaces = {"sf": "http://soap.sforce.com/2006/04/metadata"}
+
+    transforms: List[SourceTransform] = []
+
+    def _init_options(self, kwargs):
+        super(Deploy, self)._init_options(kwargs)
+
+        self.check_only = process_bool_arg(self.options.get("check_only", False))
+        self.test_level = self.options.get("test_level")
+        if self.test_level and self.test_level not in [
+            "NoTestRun",
+            "RunLocalTests",
+            "RunAllTestsInOrg",
+            "RunSpecifiedTests",
+        ]:
+            raise TaskOptionsError(
+                f"Specified test run level {self.test_level} is not valid."
+            )
+
+        self.specified_tests = process_list_arg(self.options.get("specified_tests", []))
+
+        if bool(self.specified_tests) != (self.test_level == "RunSpecifiedTests"):
+            raise TaskOptionsError(
+                "The specified_tests option and test_level RunSpecifiedTests must be used together."
+            )
+
+        self.options["namespace_inject"] = (
+            self.options.get("namespace_inject")
+            or self.project_config.project__package__namespace
+        )
+        if "collision_check" not in self.options:
+            self.options["collision_check"] = False
+
+        if "transforms" in self.options:
+            try:
+                self.transforms = SourceTransformList.parse_obj(
+                    self.options["transforms"]
+                ).as_transforms()
+            except ValidationError as e:
+                raise TaskOptionsError(
+                    "The transform spec is not valid. See CumulusCI documentation for details of how to specify transforms. "
+                    f"The validation error was {str(e)}"
+                )
+
+        # Set class variable to true if rest_deploy is set to True
+        self.rest_deploy = process_bool_arg(self.options.get("rest_deploy", False))
+
+    def _get_api(self, path=None):
+        if not path:
+            path = self.options.get("path")
+
+        package_zip = self._get_package_zip(path)
+
+        if isinstance(package_zip, dict):
+            self.logger.warning(
+                "Deploy getting aborted due to collision of following components"
+            )
+            table_header_row = ["Type", "Component API Name"]
+            table_data = [table_header_row]
+            for type in package_zip.keys():
+                for component_name in package_zip[type]:
+                    table_data.append([type, component_name])
+            table = CliTable(
+                table_data,
+            )
+            table.echo()
+            return None
+        elif package_zip is not None:
+            self.logger.info("Payload size: {} bytes".format(len(package_zip)))
+        else:
+            self.logger.warning("Deployment package is empty; skipping deployment.")
+            return
+
+        # If rest_deploy param is set, update api_class to be RestDeploy
+        if self.rest_deploy:
+            self.api_class = RestDeploy
+
+        return self.api_class(
+            self,
+            package_zip,
+            purge_on_delete=False,
+            check_only=self.check_only,
+            test_level=self.test_level,
+            run_tests=self.specified_tests,
+        )
+
+    def _has_namespaced_package(self, ns: Optional[str]) -> bool:
+        return determine_managed_mode(
+            self.options, self.project_config, self.org_config
+        )
+
+    def _is_namespaced_org(self, ns: Optional[str]) -> bool:
+        if "namespaced_org" in self.options:
+            return process_bool_arg(self.options.get("namespaced_org", False))
+        return bool(ns) and ns == self.org_config.namespace
+
+    def _create_api_object(self, package_xml, api_version):
+        api_retrieve_unpackaged_object = self.api_retrieve_unpackaged(
+            self, package_xml, api_version
+        )
+        return api_retrieve_unpackaged_object
+
+    def _collision_check(self, src_path):
+        is_collision = False
+        package_xml = open(f"{src_path}/package.xml", "r")
+        source_xml_tree = metadata_tree.parse(f"{src_path}/package.xml")
+
+        api_retrieve_unpackaged_response = self._create_api_object(
+            package_xml.read(), source_xml_tree.version.text
+        )
+
+        xml_map = metadata_tree.parse_package_xml_types("name", source_xml_tree)
+
+        messages = parseString(
+            api_retrieve_unpackaged_response._get_response().content
+        ).getElementsByTagName("messages")
+
+        process_common_components(messages, xml_map)
+
+        for type, api_names in xml_map.items():
+            if len(api_names) != 0:
+                is_collision = True
+                break
+
+        return is_collision, xml_map
+
+    def _get_package_zip(self, path) -> Union[str, dict, None]:
+        assert path, f"Path should be specified for {self.__class__.name}"
+        if not pathlib.Path(path).exists():
+            self.logger.warning(f"{path} not found.")
+            return
+        namespace = self.options["namespace_inject"]
+        options = {
+            **self.options,
+            "clean_meta_xml": process_bool_arg(
+                self.options.get("clean_meta_xml", True)
+            ),
+            "namespace_inject": namespace,
+            "unmanaged": not self._has_namespaced_package(namespace),
+            "namespaced_org": self._is_namespaced_org(namespace),
+        }
+        package_zip = None
+
+        with convert_sfdx_source(path, None, self.logger) as src_path:
+            ##############
+            is_collision = False
+            if "collision_check" in options and options["collision_check"]:
+                is_collision, xml_map = self._collision_check(src_path)
+            #############
+            if not is_collision:
+                context = TaskContext(self.org_config, self.project_config, self.logger)
+                package_zip = MetadataPackageZipBuilder(
+                    path=src_path,
+                    context=context,
+                    options=options,
+                    transforms=self.transforms,
+                )
+
+                # If the package is empty, do nothing.
+                if not package_zip.zf.namelist():
+                    return
+                return package_zip.as_base64()
+            else:
+                return xml_map
+
+    def freeze(self, step):
+        steps = super().freeze(step)
+        for step in steps:
+            if step["kind"] == "other":
+                step["kind"] = "metadata"
+        return steps

cumulusci/tasks/salesforce/DeployBundles.py

@@ -0,0 +1,88 @@
+import copy
+import os
+
+from cumulusci.tasks.salesforce import Deploy
+
+deploy_options = copy.deepcopy(Deploy.task_options)
+deploy_options["path"][
+    "description"
+] = "The path to the parent directory containing the metadata bundles directories"
+
+
+class DeployBundles(Deploy):
+    task_options = deploy_options
+
+    def _run_task(self):
+        path = self.options["path"]
+        pwd = os.getcwd()
+
+        path = os.path.join(pwd, path)
+
+        self.logger.info("Deploying all metadata bundles in path {}".format(path))
+
+        if not os.path.isdir(path):
+            self.logger.warning("Path {} not found, skipping".format(path))
+            return
+
+        for item in sorted(os.listdir(path)):
+            item_path = os.path.join(path, item)
+            if not os.path.isdir(item_path):
+                continue
+
+            self.logger.info(
+                "Deploying bundle: {}/{}".format(self.options["path"], item)
+            )
+
+            self._deploy_bundle(item_path)
+
+    def _deploy_bundle(self, path):
+        api = self._get_api(path)
+        return api()
+
+    def freeze(self, step):
+        ui_options = self.task_config.config.get("ui_options", {})
+        path = self.options["path"]
+        if not os.path.isdir(path):
+            return []
+        steps = []
+        for i, item in enumerate(sorted(os.listdir(path)), 1):
+            if not os.path.isdir(os.path.join(path, item)):
+                continue
+            name = os.path.basename(item)
+            subpath = os.path.relpath(
+                os.path.join(os.path.realpath(path), item),
+                os.path.realpath(self.project_config.repo_root),
+            ).replace(os.sep, "/")
+
+            # TODO: copying the options for this task
+            # to freeze a different task is not ideal.
+            dependency = self.options.copy()
+            dependency.pop("path")
+            dependency.update(
+                {
+                    "github": self.project_config.repo_url,
+                    "ref": self.project_config.repo_commit,
+                    "subfolder": subpath,
+                }
+            )
+            task_config = {
+                "options": {"dependencies": [dependency]},
+                "checks": self.task_config.checks or [],
+            }
+            ui_step = {
+                "name": "Deploy {}".format(subpath),
+                "kind": "metadata",
+                "is_required": True,
+            }
+            ui_step.update(ui_options.get(name, {}))
+            ui_step.update(
+                {
+                    "path": "{}.{}".format(step.path, name),
+                    "step_num": "{}.{}".format(step.step_num, i),
+                    "task_class": "cumulusci.tasks.salesforce.UpdateDependencies",
+                    "task_config": task_config,
+                    "source": step.project_config.source.frozenspec,
+                }
+            )
+            steps.append(ui_step)
+        return steps

cumulusci/tasks/salesforce/DescribeMetadataTypes.py

@@ -0,0 +1,26 @@
+from cumulusci.salesforce_api.metadata import ApiListMetadataTypes
+from cumulusci.tasks.salesforce import BaseRetrieveMetadata
+
+
+class DescribeMetadataTypes(BaseRetrieveMetadata):
+    api_class = ApiListMetadataTypes
+    task_options = {
+        "api_version": {
+            "description": "Override the API version used to list metadatatypes"
+        },
+    }
+
+    def _init_options(self, kwargs):
+        super(DescribeMetadataTypes, self)._init_options(kwargs)
+        if "api_version" not in self.options:
+            self.options[
+                "api_version"
+            ] = self.project_config.project__package__api_version
+
+    def _get_api(self):
+        return self.api_class(self, self.options.get("api_version"))
+
+    def _run_task(self):
+        api_object = self._get_api()
+        self.return_values = api_object()
+        return self.return_values