cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/tasks/salesforce/EnsureRecordTypes.py

@@ -0,0 +1,202 @@
+import os
+import re
+from xml.sax.saxutils import escape
+
+from cumulusci.core.exceptions import TaskOptionsError
+from cumulusci.core.utils import process_bool_arg
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask, Deploy
+from cumulusci.utils import temporary_dir
+
+BUSINESS_PROCESS_METADATA = """<businessProcesses>
+        <fullName>{record_type_developer_name}</fullName>
+        <isActive>true</isActive>
+        <values>
+            <fullName>{stage_name}</fullName>
+            <default>{default}</default>
+        </values>
+    </businessProcesses>"""
+
+BUSINESS_PROCESS_LINK = (
+    """<businessProcess>{record_type_developer_name}</businessProcess>"""
+)
+
+SOBJECT_METADATA = """<?xml version="1.0" encoding="utf-8"?>
+<CustomObject xmlns="http://soap.sforce.com/2006/04/metadata">
+    {business_process_metadata}
+    <recordTypes>
+        <fullName>{record_type_developer_name}</fullName>
+        <active>true</active>
+        {business_process_link}
+        <label>{record_type_label}</label>
+        <description>{record_type_description}</description>
+    </recordTypes>
+</CustomObject>
+"""
+
+PACKAGE_XML = """<?xml version="1.0" encoding="UTF-8"?>
+<Package xmlns="http://soap.sforce.com/2006/04/metadata">
+    <types>
+        <members>*</members>
+        <name>CustomObject</name>
+    </types>
+    <version>45.0</version>
+</Package>"""
+
+SOBJECT_MAP = {
+    "Opportunity": "StageName",
+    "Lead": "Status",
+    "Case": "Status",
+    "Solution": "Status",
+}
+
+
+class EnsureRecordTypes(BaseSalesforceApiTask):
+    task_options = {
+        "record_type_developer_name": {
+            "description": "The Developer Name of the Record Type (unique).  Must contain only alphanumeric characters and underscores.",
+            "required": True,
+        },
+        "record_type_label": {
+            "description": "The Label of the Record Type.",
+            "required": True,
+        },
+        "record_type_description": {
+            "description": "The Description of the Record Type.  Only uses the first 255 characters.",
+            "required": False,
+        },
+        "sobject": {
+            "description": "The sObject on which to deploy the Record Type and optional Business Process.",
+            "required": True,
+        },
+        "force_create": {
+            "description": "If true, the Record Type will be created even if a default Record Type already exists on this sObject. Defaults to False.",
+            "required": False,
+        },
+    }
+    _deploy = Deploy
+
+    def _init_options(self, kwargs):
+        super(EnsureRecordTypes, self)._init_options(kwargs)
+
+        self.options["generate_business_process"] = False
+
+        # Validate developer name
+        if not re.match(r"^\w+$", self.options["record_type_developer_name"]):
+            raise TaskOptionsError(
+                "Record Type Developer Name value must contain only alphanumeric or underscore characters"
+            )
+
+        # Validate Description has 255 characters
+        self.options["record_type_description"] = (
+            str(self.options.get("record_type_description") or "")
+        )[:255]
+
+        # We don't currently support custom objects
+        if self.options["sobject"].endswith("__c"):
+            raise TaskOptionsError("EnsureRecordTypes does not support custom objects")
+
+        self.options["force_create"] = process_bool_arg(
+            self.options.get("force_create") or False
+        )
+
+    def _infer_requirements(self):
+        # If our sObject is Lead, Opportunity, Case, or Solution,
+        # we need to generate businessProcess metadata to make the record type deployable.
+
+        # Regardless of sObject, we don't need to do any work if it already
+        # has record types in the target org.
+        sobject = self.options["sobject"]
+        describe_results = getattr(self.sf, sobject).describe()
+
+        # Check for existing record types. We ignore the record type info with master: True,
+        # because it's present even if record types aren't enabled for the object.
+        record_types = [
+            rt for rt in describe_results["recordTypeInfos"] if not rt["master"]
+        ]
+
+        self.options["generate_record_type"] = (
+            len(record_types) == 0 or self.options["force_create"]
+        )
+
+        if self.options["generate_record_type"] and sobject in SOBJECT_MAP:
+            self.options["generate_business_process"] = True
+            # Salesforce requires that at least one picklist value be present and active
+            stage_field = [
+                f
+                for f in describe_results["fields"]
+                if f["name"] == SOBJECT_MAP[sobject]
+            ][0]
+            active_picklist_values = [
+                value for value in stage_field["picklistValues"] if value["active"]
+            ]
+            self.options["stage_name"] = active_picklist_values[0]["value"]
+
+    def _build_package(self):
+        objects_app_path = "objects"
+        os.mkdir(objects_app_path)
+        with open(
+            os.path.join(objects_app_path, self.options["sobject"] + ".object"), "w"
+        ) as f:
+            if self.options["generate_business_process"]:
+                self.logger.info(
+                    "Generating record type and business process for sObject {}".format(
+                        self.options["sobject"]
+                    )
+                )
+                # Lead, Case, and Solution require a default value in their Business Process
+                # Opportunity prohibits it.
+                default = (
+                    "true" if self.options["sobject"] != "Opportunity" else "false"
+                )
+
+                business_process_metadata = BUSINESS_PROCESS_METADATA.format(
+                    record_type_developer_name=self.options[
+                        "record_type_developer_name"
+                    ],
+                    stage_name=escape(self.options["stage_name"]),
+                    default=default,
+                )
+                business_process_link = BUSINESS_PROCESS_LINK.format(
+                    record_type_developer_name=self.options[
+                        "record_type_developer_name"
+                    ]
+                )
+            else:
+                self.logger.info(
+                    "Generating record type for sObject {}".format(
+                        self.options["sobject"]
+                    )
+                )
+                business_process_metadata = business_process_link = ""
+
+            f.write(
+                SOBJECT_METADATA.format(
+                    record_type_developer_name=self.options[
+                        "record_type_developer_name"
+                    ],
+                    record_type_label=self.options["record_type_label"],
+                    record_type_description=self.options["record_type_description"],
+                    business_process_metadata=business_process_metadata,
+                    business_process_link=business_process_link,
+                )
+            )
+        with open("package.xml", "w") as f:
+            f.write(PACKAGE_XML)
+
+    def _run_task(self):
+        self._infer_requirements()
+
+        if not self.options["generate_record_type"]:
+            self.logger.info(
+                "Record types already enabled for {} in target org; no action needed".format(
+                    self.options["sobject"]
+                )
+            )
+            return
+
+        with temporary_dir() as tempdir:
+            self._build_package()
+            d = self._deploy(
+                self.project_config, self.task_config, self.org_config, path=tempdir
+            )
+            d()

cumulusci/tasks/salesforce/GetInstalledPackages.py

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

cumulusci/tasks/salesforce/ListCommunities.py

@@ -0,0 +1,40 @@
+from rst2ansi import rst2ansi
+
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+
+
+class ListCommunities(BaseSalesforceApiTask):
+    api_version = "46.0"
+    task_docs = """
+    Lists Communities for the current org via the Connect API.
+    """
+    task_options = {}
+
+    def _run_task(self):
+        communities = self.sf.restful("connect/communities")["communities"]
+
+        nameString = "\n==========================================\n"
+
+        communities_output = ["The current Communities in the org are:\n"]
+        for community in communities:
+            communities_output.append("\n{}{}".format(community["name"], nameString))
+            communities_output.append("* **Id:** {}\n".format(community["id"]))
+            communities_output.append("* **Status:** {}\n".format(community["status"]))
+            communities_output.append(
+                "* **Site Url:** `<{}>`_\n".format(community["siteUrl"])
+            )
+            communities_output.append(
+                "* **Url Path Prefix:** {}\n".format(
+                    community.get("urlPathPrefix") or ""
+                )
+            )
+            communities_output.append(
+                "* **Template:** {}\n".format(community["templateName"])
+            )
+            communities_output.append(
+                "* **Description:** {}\n".format(community["description"])
+            )
+
+        communities_output2 = "\n".join(communities_output).encode("utf-8")
+        self.logger.info(rst2ansi(communities_output2))
+        self.return_values = [community["name"] for community in communities]

cumulusci/tasks/salesforce/ListCommunityTemplates.py

@@ -0,0 +1,19 @@
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+
+
+class ListCommunityTemplates(BaseSalesforceApiTask):
+    api_version = "46.0"
+    task_docs = """
+    Lists Salesforce Community templates available for the current org via the Connect API.
+    """
+    task_options = {}
+
+    def _run_task(self):
+        community_template_list = self.sf.restful("connect/communities/templates")[
+            "templates"
+        ]
+
+        self.logger.info(
+            "Community Templates available to the current org:\n%s",
+            "\n".join(t["templateName"] for t in community_template_list),
+        )

cumulusci/tasks/salesforce/PublishCommunity.py

@@ -0,0 +1,62 @@
+from cumulusci.core.exceptions import SalesforceException, TaskOptionsError
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+
+
+class PublishCommunity(BaseSalesforceApiTask):
+    api_version = "46.0"
+    task_docs = """
+    Publish a Salesforce Community via the Connect API. Warning: This does not work with the Community Template 'VF Template' due to an existing bug in the API.
+    """
+    task_options = {
+        "name": {
+            "description": "The name of the Community to publish.",
+            "required": False,
+        },
+        "community_id": {
+            "description": "The id of the Community to publish.",
+            "required": False,
+        },
+    }
+
+    def _run_task(self):
+        community_id = self.options.get("community_id", None)
+        community_name = self.options.get("name", None)
+
+        if community_id is None:
+            if community_name is None:
+                missing_required = ["name", "community_id"]
+                raise TaskOptionsError(
+                    "{} requires one of options ({}) "
+                    "and no values were provided".format(
+                        self.__class__.__name__, ", ".join(missing_required)
+                    )
+                )
+
+            self.logger.info(
+                'Finding id for Community "{}"'.format(self.options["name"])
+            )
+            community_list = self.sf.restful("connect/communities")["communities"]
+            communities = {c["name"]: c for c in community_list}
+
+            if self.options["name"] in communities:
+                community_id = communities[self.options["name"]]["id"]
+            else:
+                raise SalesforceException(
+                    'Unable to find a Community named "{}"'.format(community_id)
+                )
+
+            self.logger.info(
+                'Sending request to publish Community "{}" ({})'.format(
+                    community_name, community_id
+                )
+            )
+        else:
+            self.logger.info(
+                "Sending request to publish Community ({})".format(community_id)
+            )
+
+        response = self.sf.restful(
+            "connect/communities/{}/publish".format(community_id), method="POST"
+        )
+
+        self.logger.info(response["message"])

cumulusci/tasks/salesforce/RetrievePackaged.py

@@ -0,0 +1,41 @@
+from zipfile import ZipFile
+
+from cumulusci.salesforce_api.metadata import ApiRetrievePackaged
+from cumulusci.tasks.salesforce import BaseRetrieveMetadata
+from cumulusci.utils import zip_subfolder
+
+retrieve_packaged_options = BaseRetrieveMetadata.task_options.copy()
+retrieve_packaged_options.update(
+    {
+        "package": {
+            "description": "The package name to retrieve.  Defaults to project__package__name",
+            "required": True,
+        },
+        "api_version": {
+            "description": (
+                "Override the default api version for the retrieve."
+                + " Defaults to project__package__api_version"
+            )
+        },
+    }
+)
+
+
+class RetrievePackaged(BaseRetrieveMetadata):
+    api_class = ApiRetrievePackaged
+
+    task_options = retrieve_packaged_options
+
+    def _init_options(self, kwargs):
+        super(RetrievePackaged, self)._init_options(kwargs)
+        if "package" not in self.options:
+            self.options["package"] = self.project_config.project__package__name
+
+    def _get_api(self):
+        return self.api_class(
+            self, self.options["package"], self.options.get("api_version")
+        )
+
+    def _extract_zip(self, src_zip: ZipFile):
+        src_zip = zip_subfolder(src_zip, self.options.get("package"))
+        super(RetrievePackaged, self)._extract_zip(src_zip)

cumulusci/tasks/salesforce/RetrieveReportsAndDashboards.py

@@ -0,0 +1,82 @@
+from cumulusci.core.exceptions import TaskOptionsError
+from cumulusci.salesforce_api.metadata import ApiListMetadata, ApiRetrieveUnpackaged
+from cumulusci.tasks.salesforce import BaseRetrieveMetadata
+from cumulusci.utils import package_xml_from_dict
+
+retrieve_reportsanddashboards_options = BaseRetrieveMetadata.task_options.copy()
+retrieve_reportsanddashboards_options.update(
+    {
+        "report_folders": {
+            "description": "A list of the report folders to retrieve reports.  Separate by commas for multiple folders."
+        },
+        "dashboard_folders": {
+            "description": "A list of the dashboard folders to retrieve reports.  Separate by commas for multiple folders."
+        },
+        "api_version": {
+            "description": "Override the API version used to list metadata"
+        },
+    }
+)
+
+
+class RetrieveReportsAndDashboards(BaseRetrieveMetadata):
+    api_class = ApiRetrieveUnpackaged
+    list_metadata_api_class = ApiListMetadata
+
+    task_options = retrieve_reportsanddashboards_options
+
+    def _init_options(self, kwargs):
+        super(RetrieveReportsAndDashboards, self)._init_options(kwargs)
+        if "api_version" not in self.options:
+            self.options[
+                "api_version"
+            ] = self.project_config.project__package__api_version
+
+    def _validate_options(self):
+        super(RetrieveReportsAndDashboards, self)._validate_options()
+        if (
+            "report_folders" not in self.options
+            and "dashboard_folders" not in self.options
+        ):
+            raise TaskOptionsError(
+                "You must provide at least one folder name for either report_folders or dashboard_folders"
+            )
+
+    def _get_api(self):
+        metadata = {}
+        if "report_folders" in self.options:
+            for folder in self.options["report_folders"]:
+                api_reports = self.list_metadata_api_class(
+                    self,
+                    "Report",
+                    metadata=metadata,
+                    folder=folder,
+                    as_of_version=self.options["api_version"],
+                )
+                metadata = api_reports()
+        if "dashboard_folders" in self.options:
+            for folder in self.options["dashboard_folders"]:
+                api_dashboards = self.list_metadata_api_class(
+                    self,
+                    "Dashboard",
+                    metadata=metadata,
+                    folder=folder,
+                    as_of_version=self.options["api_version"],
+                )
+                metadata = api_dashboards()
+
+        items = {}
+        if "Report" in metadata:
+            items["Report"] = []
+            items["Report"].extend(self.options["report_folders"])
+            for report in metadata["Report"]:
+                items["Report"].append(report["fullName"])
+        if "Dashboard" in metadata:
+            items["Dashboard"] = []
+            items["Dashboard"].extend(self.options["dashboard_folders"])
+            for dashboard in metadata["Dashboard"]:
+                items["Dashboard"].append(dashboard["fullName"])
+
+        api_version = self.options["api_version"]
+        package_xml = package_xml_from_dict(items, api_version)
+        return self.api_class(self, package_xml, api_version)

cumulusci/tasks/salesforce/RetrieveUnpackaged.py

@@ -0,0 +1,36 @@
+from cumulusci.salesforce_api.metadata import ApiRetrieveUnpackaged
+from cumulusci.tasks.salesforce import BaseRetrieveMetadata
+
+retrieve_unpackaged_options = BaseRetrieveMetadata.task_options.copy()
+retrieve_unpackaged_options.update(
+    {
+        "package_xml": {
+            "description": "The path to a package.xml manifest to use for the retrieve.",
+            "required": True,
+        },
+        "api_version": {
+            "description": (
+                "Override the default api version for the retrieve."
+                + " Defaults to project__package__api_version"
+            )
+        },
+    }
+)
+
+
+class RetrieveUnpackaged(BaseRetrieveMetadata):
+    api_class = ApiRetrieveUnpackaged
+
+    task_options = retrieve_unpackaged_options
+
+    def _init_options(self, kwargs):
+        super(RetrieveUnpackaged, self)._init_options(kwargs)
+
+        if "package_xml" in self.options:
+            with open(self.options["package_xml"], "r") as f:
+                self.options["package_xml_content"] = f.read()
+
+    def _get_api(self):
+        return self.api_class(
+            self, self.options["package_xml_content"], self.options.get("api_version")
+        )

cumulusci/tasks/salesforce/SOQLQuery.py

@@ -0,0 +1,39 @@
+from cumulusci.tasks.salesforce.BaseSalesforceApiTask import BaseSalesforceApiTask
+
+
+class SOQLQuery(BaseSalesforceApiTask):
+    name = "SOQLQuery"
+
+    task_options = {  # TODO: should use `class Options instead`
+        "object": {"required": True, "description": "The object to query"},
+        "query": {
+            "required": True,
+            "description": "A valid bulk SOQL query for the object",
+        },
+        "result_file": {
+            "required": True,
+            "description": "The name of the csv file to write the results to",
+        },
+    }
+
+    def _run_task(self):
+        self.logger.info("Creating bulk job for: {object}".format(**self.options))
+        job = self.bulk.create_query_job(self.options["object"], contentType="CSV")
+        self.logger.info("Job id: {0}".format(job))
+        self.logger.info("Submitting query: {query}".format(**self.options))
+        batch = self.bulk.query(job, self.options["query"])
+        self.logger.info("Batch id: {0}".format(batch))
+        self.bulk.wait_for_batch(job, batch)
+        self.logger.info("Batch {0} finished".format(batch))
+        self.bulk.close_job(job)
+        self.logger.info("Job {0} closed".format(job))
+        with open(self.options["result_file"], "wb") as result_file:
+            first_batch = True
+            for result_iterator in self.bulk.get_all_results_for_query_batch(batch):
+                if not first_batch:
+                    # only include headers for first batch
+                    next(result_iterator)
+                first_batch = False
+                for row in result_iterator:
+                    result_file.write(row)
+        self.logger.info("Wrote results to: {result_file}".format(**self.options))

cumulusci/tasks/salesforce/UninstallLocal.py

@@ -0,0 +1,15 @@
+from cumulusci.tasks.metadata.package import PackageXmlGenerator
+from cumulusci.tasks.salesforce import BaseUninstallMetadata
+
+
+class UninstallLocal(BaseUninstallMetadata):
+    def _get_destructive_changes(self, path=None):
+        if not path:
+            path = self.options["path"]
+
+        generator = PackageXmlGenerator(
+            directory=path,
+            api_version=self.project_config.project__package__api_version,
+            delete=True,
+        )
+        return generator()

cumulusci/tasks/salesforce/UninstallLocalBundles.py

@@ -0,0 +1,28 @@
+import os
+
+from cumulusci.tasks.salesforce import UninstallLocal
+
+
+class UninstallLocalBundles(UninstallLocal):
+    def _run_task(self):
+        path = self.options["path"]
+        path = os.path.abspath(path)
+
+        self.logger.info(
+            "Deleting all metadata from bundles in {} from target org".format(path)
+        )
+
+        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(
+                "Deleting bundle: {}/{}".format(self.options["path"], item)
+            )
+
+            self._delete_bundle(item_path)
+
+    def _delete_bundle(self, path=None):
+        api = self._get_api(path)
+        return api()

cumulusci/tasks/salesforce/UninstallLocalNamespacedBundles.py

@@ -0,0 +1,58 @@
+from cumulusci.core.utils import process_bool_arg
+from cumulusci.tasks.metadata.package import PackageXmlGenerator
+from cumulusci.tasks.salesforce import UninstallLocalBundles
+
+
+class UninstallLocalNamespacedBundles(UninstallLocalBundles):
+
+    task_options = {
+        "path": {
+            "description": "The path to a directory containing the metadata bundles (subdirectories) to uninstall",
+            "required": True,
+        },
+        "managed": {
+            "description": "If True, will insert the actual namespace prefix.  Defaults to False or no namespace"
+        },
+        "namespace": {
+            "description": "The namespace to replace the token with if in managed mode. Defaults to project__package__namespace"
+        },
+        "filename_token": {
+            "description": "The path to the parent directory containing the metadata bundles directories",
+            "required": True,
+        },
+        "purge_on_delete": {
+            "description": "Sets the purgeOnDelete option for the deployment.  Defaults to True",
+            "required": True,
+        },
+    }
+
+    def _init_options(self, kwargs):
+        super(UninstallLocalNamespacedBundles, self)._init_options(kwargs)
+
+        self.options["managed"] = process_bool_arg(self.options.get("managed", False))
+        if "namespace" not in self.options:
+            self.options["namespace"] = self.project_config.project__package__namespace
+        self.options["purge_on_delete"] = process_bool_arg(
+            self.options.get("purge_on_delete", True)
+        )
+
+    def _get_destructive_changes(self, path=None):
+        if not path:
+            path = self.options["path"]
+
+        generator = PackageXmlGenerator(
+            directory=path,
+            api_version=self.project_config.project__package__api_version,
+            delete=True,
+        )
+        namespace = ""
+        if self.options["managed"]:
+            if self.options["namespace"]:
+                namespace = self.options["namespace"] + "__"
+
+        destructive_changes = generator()
+        destructive_changes = destructive_changes.replace(
+            self.options["filename_token"], namespace
+        )
+
+        return destructive_changes

cumulusci/tasks/salesforce/UninstallPackage.py

@@ -0,0 +1,32 @@
+from cumulusci.core.utils import process_bool_arg
+from cumulusci.salesforce_api.package_zip import UninstallPackageZipBuilder
+from cumulusci.tasks.salesforce import Deploy
+
+
+class UninstallPackage(Deploy):
+    task_options = {
+        "namespace": {
+            "description": "The namespace of the package to uninstall.  Defaults to project__package__namespace",
+            "required": True,
+        },
+        "purge_on_delete": {
+            "description": "Sets the purgeOnDelete option for the deployment.  Defaults to True",
+            "required": True,
+        },
+    }
+
+    def _init_options(self, kwargs):
+        super(UninstallPackage, self)._init_options(kwargs)
+        if "namespace" not in self.options:
+            self.options["namespace"] = self.project_config.project__package__namespace
+        self.options["purge_on_delete"] = process_bool_arg(
+            self.options.get("purge_on_delete", True)
+        )
+
+    def _get_api(self, path=None):
+        package_zip = UninstallPackageZipBuilder(
+            self.options["namespace"], self.project_config.project__package__api_version
+        )
+        return self.api_class(
+            self, package_zip(), purge_on_delete=self.options["purge_on_delete"]
+        )