cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/tasks/salesforce/org_settings.py

@@ -0,0 +1,193 @@
+import contextlib
+import json
+import pathlib
+import textwrap
+from typing import Optional
+
+from cumulusci.core.utils import dictmerge
+from cumulusci.tasks.metadata.package import PackageXmlGenerator
+from cumulusci.tasks.salesforce import Deploy
+from cumulusci.utils import temporary_dir
+
+SETTINGS_XML = """<?xml version="1.0" encoding="UTF-8"?>
+<{settingsName} xmlns="http://soap.sforce.com/2006/04/metadata">
+{values}
+</{settingsName}>"""
+ORGPREF = """<preferences>
+    <settingName>{name}</settingName>
+    <settingValue>{value}</settingValue>
+</preferences>"""
+
+
+class DeployOrgSettings(Deploy):
+    task_doc = """Deploys org settings from an sfdx scratch org definition file."""
+
+    task_options = {
+        "definition_file": {"description": "sfdx scratch org definition file"},
+        "settings": {"description": "A dict of settings to apply"},
+        "object_settings": {"description": "A dict of objectSettings to apply"},
+        "api_version": {"description": "API version used to deploy the settings"},
+    }
+
+    def _init_options(self, kwargs):
+        super()._init_options(kwargs)
+        # We have no need for namespace injection when deploying settings,
+        # so let's explicitly disable it to prevent the Deploy task
+        # from making API calls to check if it's needed.
+        self.options["managed"] = False
+        self.options["namespaced_org"] = False
+
+    def _run_task(self):
+        settings = {}
+        object_settings = {}
+        if self.options.get("definition_file"):
+            with open(self.options["definition_file"], "r") as f:
+                scratch_org_definition = json.load(f)
+                settings = scratch_org_definition.get("settings", {})
+                object_settings = scratch_org_definition.get("objectSettings", {})
+
+        dictmerge(settings, self.options.get("settings", {}))
+        dictmerge(object_settings, self.options.get("object_settings", {}))
+
+        if not settings and not object_settings:
+            self.logger.info("No settings provided to deploy.")
+            return
+
+        api_version = (
+            self.options.get("api_version") or self.org_config.latest_api_version
+        )
+        with build_settings_package(settings, object_settings, api_version) as path:
+            self.options["path"] = path
+            return super()._run_task()
+
+
+def capitalize(s):
+    """
+    Just capitalize first letter (different from .title, as it preserves
+    the rest of the case).
+    e.g. accountSettings -> AccountSettings
+    """
+    return s[0].upper() + s[1:]
+
+
+@contextlib.contextmanager
+def build_settings_package(
+    settings: Optional[dict], object_settings: Optional[dict], api_version: str
+):
+    with temporary_dir() as path:
+        if settings:
+            pathlib.Path("settings").mkdir()
+            for section, section_settings in settings.items():
+                settings_name = capitalize(section)
+                if section == "orgPreferenceSettings":
+                    values = "    " + "\n    ".join(
+                        line
+                        for line in "\n".join(
+                            ORGPREF.format(name=capitalize(k), value=v)
+                            for k, v in section_settings.items()
+                        ).splitlines()
+                    )
+                else:
+                    values = textwrap.indent(_dict_to_xml(section_settings), "    ")
+                # e.g. AccountSettings -> settings/Account.settings
+                settings_file = (
+                    pathlib.Path("settings")
+                    / f"{settings_name[: -len('Settings')]}.settings"
+                )
+                with open(settings_file, "w", encoding="utf-8") as f:
+                    f.write(
+                        SETTINGS_XML.format(settingsName=settings_name, values=values)
+                    )
+
+        if object_settings:
+            pathlib.Path("objects").mkdir()
+            for obj_lower_name, this_obj_settings in object_settings.items():
+                object_name = capitalize(obj_lower_name)
+                file_content = _get_object_file(object_name, this_obj_settings)
+                with open(
+                    pathlib.Path("objects") / f"{object_name}.object",
+                    "w",
+                    encoding="utf-8",
+                ) as f:
+                    f.write(file_content)
+
+        package_generator = PackageXmlGenerator(path, api_version)
+        with open("package.xml", "w") as f:
+            f.write(package_generator())
+
+        yield path
+
+
+def _get_object_file(object_name: str, settings: dict) -> str:
+    sharing_model = ""
+    if "sharingModel" in settings:
+        sharing_model = (
+            f"    <sharingModel>{capitalize(settings['sharingModel'])}</sharingModel>"
+        )
+
+    record_type = ""
+    business_process = ""
+    if "defaultRecordType" in settings:
+        # Use the same default picklist values as SFDX to generate a Business Process,
+        # if this object requires one.
+        picklist_value = {
+            "Case": "New",
+            "Lead": "New - Not Contacted",
+            "Opportunity": "Prospecting",
+            "Solution": "Draft",
+        }.get(object_name, "")
+        default_status = (
+            "<default>true</default>" if object_name == "Opportunity" else ""
+        )
+
+        business_process_reference = ""
+        if picklist_value:
+            # We need to add a Business Process
+            business_process_reference = (
+                f"<businessProcess>Default{object_name}</businessProcess>"
+            )
+            default_status = ""
+            business_process = f"""    <businessProcesses>
+        <fullName>Default{object_name}</fullName>
+        <isActive>true</isActive>
+        <values>
+            <fullName>{picklist_value}</fullName>
+            {default_status}
+        </values>
+    </businessProcesses>"""
+        record_type = f"""    <recordTypes>
+        <fullName>{capitalize(settings['defaultRecordType'])}</fullName>
+        <label>{capitalize(settings['defaultRecordType'])}</label>
+        <active>true</active>
+        {business_process_reference}
+    </recordTypes>
+        """
+
+    return f"""<?xml version="1.0" encoding="UTF-8"?>
+<Object xmlns="http://soap.sforce.com/2006/04/metadata">
+{sharing_model}
+{record_type}
+{business_process}
+</Object>"""
+
+
+def _dict_to_xml(d: dict) -> str:
+    items = []
+    for k, v in d.items():
+        if isinstance(v, dict):
+            v = "\n" + textwrap.indent(_dict_to_xml(v), "    ") + "\n"
+        elif isinstance(v, str):
+            pass
+        elif isinstance(v, bool):
+            v = str(v).lower()
+        elif isinstance(v, list):
+            for li in v:
+                if not isinstance(li, dict):
+                    raise TypeError(f"Unexpected list item type {type(v)} for {k}")
+                li_xml = textwrap.indent(_dict_to_xml(li), "    ") + "\n"
+                items.append(f"<{k}>\n{li_xml}</{k}>")
+            continue
+        else:
+            raise TypeError(f"Unexpected type {type(v)} for {k}")
+        items.append(f"<{k}>{v}</{k}>")
+    return "\n".join(items)

cumulusci/tasks/salesforce/package_upload.py

@@ -0,0 +1,328 @@
+from datetime import datetime
+
+from cumulusci.cli.ui import CliTable
+from cumulusci.core.dependencies.resolvers import get_static_dependencies
+from cumulusci.core.exceptions import (
+    ApexTestException,
+    SalesforceException,
+    TaskOptionsError,
+)
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+
+
+class PackageUpload(BaseSalesforceApiTask):
+    name = "PackageUpload"
+    api_version = "48.0"
+    task_options = {
+        "name": {"description": "The name of the package version.", "required": True},
+        "production": {
+            "description": "If True, uploads a production release.  Defaults to uploading a beta"
+        },
+        "description": {
+            "description": "A description of the package and what this version contains."
+        },
+        "password": {
+            "description": "An optional password for sharing the package privately with anyone who has the password. Don't enter a password if you want to make the package available to anyone on AppExchange and share your package publicly."
+        },
+        "post_install_url": {
+            "description": "The fully-qualified URL of the post-installation instructions. Instructions are shown as a link after installation and are available from the package detail view."
+        },
+        "release_notes_url": {
+            "description": "The fully-qualified URL of the package release notes. Release notes are shown as a link during the installation process and are available from the package detail view after installation."
+        },
+        "namespace": {
+            "description": "The namespace of the package.  Defaults to project__package__namespace"
+        },
+        "resolution_strategy": {
+            "description": "The name of a sequence of resolution_strategy (from project__dependency_resolutions) to apply to dynamic dependencies. Defaults to 'production'."
+        },
+        "major_version": {
+            "description": "The desired major version number for the uploaded package. Defaults to latest major version.",
+            "required": False,
+        },
+        "minor_version": {
+            "description": "The desired minor version number for the uploaded package. Defaults to next available minor version for the current major version.",
+            "required": False,
+        },
+    }
+
+    def _init_options(self, kwargs):
+        super(PackageUpload, self)._init_options(kwargs)
+
+        self.upload = None
+        self.upload_id = None
+        self.package_id = None
+
+        # Set the namespace option to the value from cumulusci.yml if not already set
+        if "namespace" not in self.options:
+            self.options["namespace"] = self.project_config.project__package__namespace
+
+    def _run_task(self):
+
+        self._validate_versions()
+        self._set_package_id()
+
+        self._set_package_info()
+
+        self._make_package_upload_request()
+
+        if self.upload["Status"] == "ERROR":
+            self._log_package_upload_errors()
+        else:
+            self._set_package_version_values_on_self()
+            self._set_return_values()
+            self._set_dependencies()
+            self._log_package_upload_success()
+
+    def _validate_versions(self):
+        """This functions validates the major version and minor version if passed and sets them in the options dictionary if not passed."""
+
+        # Fetching the latest major,minor and patch version from Database
+        version = self._get_one_record(
+            (
+                """
+                SELECT MajorVersion,
+                MinorVersion,
+                PatchVersion,
+                ReleaseState
+                FROM MetadataPackageVersion
+                ORDER BY
+                MajorVersion DESC,
+                MinorVersion DESC,
+                PatchVersion DESC,
+                ReleaseState DESC
+                LIMIT 1
+                """
+            ),
+            "Version not found",
+        )
+
+        # This if-else condition updates the major version to latest major version in options if not passed via command line and validates it if passed.
+        if "major_version" in self.options:
+            try:
+                if int(self.options["major_version"]) < version["MajorVersion"]:
+                    raise TaskOptionsError("Major Version not valid.")
+            except ValueError:
+                raise TaskOptionsError("Major Version not valid.")
+
+        else:
+            self.options["major_version"] = str(version["MajorVersion"])
+
+        # This if is executed only when major version is equal to latest major version. Updates the minor version in options if not passed and validates if passed
+        # Updates minor version when not passed in remaining cases.
+        if self.options["major_version"] == str(version["MajorVersion"]):
+            if "minor_version" in self.options:
+                try:
+                    if int(self.options["minor_version"]) < version["MinorVersion"]:
+                        raise TaskOptionsError("Minor Version not valid.")
+                    elif (
+                        int(self.options["minor_version"]) == version["MinorVersion"]
+                        and version["ReleaseState"] == "Released"
+                    ):
+                        raise TaskOptionsError("Minor Version not valid.")
+                    else:
+                        if (
+                            int(self.options["minor_version"]) > version["MinorVersion"]
+                            and version["ReleaseState"] == "Beta"
+                        ):
+                            raise TaskOptionsError(
+                                "Latest Minor Version is Beta so minor version cannot be greater than that."
+                            )
+                except ValueError:
+                    raise TaskOptionsError("Minor Version not valid.")
+            else:
+                if version["ReleaseState"] == "Beta":
+                    self.options["minor_version"] = str(version["MinorVersion"])
+                else:
+                    self.options["minor_version"] = str(version["MinorVersion"] + 1)
+        else:
+            if "minor_version" not in self.options:
+                self.options["minor_version"] = "0"
+
+    def _set_package_info(self):
+        if not self.package_id:
+            self._set_package_id()
+
+        production = self.options.get("production", False) in [True, "True", "true"]
+
+        self.package_info = {
+            "VersionName": self.options["name"],
+            "IsReleaseVersion": production,
+            "MetadataPackageId": self.package_id,
+            "MajorVersion": self.options["major_version"],
+            "MinorVersion": self.options["minor_version"],
+        }
+
+        if "description" in self.options:
+            self.package_info["Description"] = self.options["description"]
+        if "password" in self.options:
+            self.package_info["Password"] = self.options["password"]
+        if "post_install_url" in self.options:
+            self.package_info["PostInstallUrl"] = self.options["post_install_url"]
+        if "release_notes_url" in self.options:
+            self.package_info["ReleaseNotesUrl"] = self.options["release_notes_url"]
+
+    def _set_package_id(self):
+        namespace = self.options["namespace"]
+        package = self._get_one_record(
+            f"SELECT Id FROM MetadataPackage WHERE NamespacePrefix='{namespace}'",
+            f"No package found with namespace {namespace}",
+        )
+        self.package_id = package["Id"]
+
+    def _make_package_upload_request(self):
+        """Creates a PackageUploadRequest in self.upload"""
+        PackageUploadRequest = self._get_tooling_object("PackageUploadRequest")
+
+        self._upload_start_time = datetime.utcnow()
+        self.upload = PackageUploadRequest.create(self.package_info)
+
+        self.upload_id = self.upload["id"]
+        self.logger.info(
+            f"Created PackageUploadRequest {self.upload_id} for Package {self.package_id}"
+        )
+        self._poll()
+
+    def _log_package_upload_errors(self):
+        self.logger.error("Package upload failed with the following errors")
+        error = {"message": ""}
+        apex_test_failures = False
+        for error in self.upload["Errors"]["errors"]:
+            self.logger.error(f"  {error['message']}")
+            if error["message"] == "ApexTestFailure":
+                apex_test_failures = True
+
+        if apex_test_failures:
+            self._handle_apex_test_failures()
+
+        exception = self._get_exception_type(error)
+        raise exception("Package upload failed")
+
+    def _handle_apex_test_failures(self):
+        self.logger.error("Failed Apex Tests:")
+        test_results = self._get_apex_test_results_from_upload()
+        self._log_failures(test_results)
+
+    def _get_apex_test_results_from_upload(self):
+        soql_query = self._get_failed_tests_soql_query()
+        return self.tooling.query(soql_query)
+
+    def _log_failures(self, results):
+        """Logs failures using CliTable"""
+        table_title = "Failed Apex Tests"
+        table_data = self._get_table_data(results)
+        table = CliTable(
+            table_data,
+            table_title,
+        )
+        table.echo()
+
+    def _get_table_data(self, results):
+        """Returns table data compatible with CliTable class"""
+        table_header_row = ["Class", "Method", "Message", "Stacktrace"]
+        table_data = [table_header_row]
+        for test in results["records"]:
+            table_data.append(
+                [
+                    test["ApexClass"]["Name"],
+                    test["MethodName"],
+                    test["Message"],
+                    test["StackTrace"],
+                ]
+            )
+        return table_data
+
+    def _get_failed_tests_soql_query(self):
+        return (
+            "SELECT ApexClass.Name, "
+            "MethodName, "
+            "Message, "
+            "StackTrace "
+            "FROM ApexTestResult "
+            "WHERE Outcome='Fail' "
+            f"AND TestTimestamp > {self._upload_start_time.isoformat()}Z"
+        )
+
+    def _get_exception_type(self, error):
+        return (
+            ApexTestException
+            if error["message"] == "ApexTestFailure"
+            else SalesforceException
+        )
+
+    def _set_return_values(self):
+        self.return_values = {
+            "version_number": str(self.version_number),
+            "version_id": self.version_id,
+            "package_id": self.package_id,
+        }
+
+    def _set_dependencies(self):
+        dependencies = get_static_dependencies(
+            self.project_config,
+            resolution_strategy=self.options.get("resolution_strategy") or "production",
+        )
+        if dependencies:
+            dependencies = self.org_config.resolve_04t_dependencies(dependencies)
+        self.return_values["dependencies"] = [
+            d.dict(exclude_none=True) for d in dependencies
+        ]
+
+    def _log_package_upload_success(self):
+        self.logger.info(
+            f"Uploaded package version {self.version_number} with Id {self.version_id}"
+        )
+
+    def _set_package_version_values_on_self(self):
+        """Sets version_id and version_number on self.
+        Assumes that self.upload['Status'] was a success"""
+        self.version_id = self.upload["MetadataPackageVersionId"]
+        version = self._get_one_record(
+            (
+                "SELECT MajorVersion, "
+                "MinorVersion, "
+                "PatchVersion, "
+                "BuildNumber, "
+                "ReleaseState "
+                "FROM MetadataPackageVersion "
+                f"WHERE Id='{self.version_id}'"
+            ),
+            f"Version {self.version_id} not found",
+        )
+        version_parts = [str(version["MajorVersion"]), str(version["MinorVersion"])]
+
+        if version["PatchVersion"]:
+            version_parts.append(str(version["PatchVersion"]))
+
+        self.version_number = ".".join(version_parts)
+
+        if version["ReleaseState"] == "Beta":
+            self.version_number += f" (Beta {version['BuildNumber']})"
+
+    def _get_one_record(self, query, message):
+        result = self.tooling.query(query)
+        if result["totalSize"] != 1:
+            self.logger.error(message)
+            raise SalesforceException(message)
+        return result["records"][0]
+
+    def _poll_action(self):
+        soql_check_upload = (
+            "SELECT Id, "
+            "Status, "
+            "Errors, "
+            "MetadataPackageVersionId "
+            "FROM PackageUploadRequest "
+            f"WHERE Id = '{self.upload_id}'"
+        )
+        self.upload = self._get_one_record(
+            soql_check_upload, f"Failed to get info for upload with id {self.upload_id}"
+        )
+        self.logger.info(
+            f"PackageUploadRequest {self.upload_id} is {self.upload['Status']}"
+        )
+
+        self.poll_complete = not self._poll_again(self.upload["Status"])
+
+    def _poll_again(self, upload_status):
+        return upload_status in ["IN_PROGRESS", "QUEUED"]

cumulusci/tasks/salesforce/profiles.py

@@ -0,0 +1,74 @@
+from cumulusci.core.exceptions import TaskOptionsError
+from cumulusci.salesforce_api.metadata import ApiNewProfile
+from cumulusci.salesforce_api.utils import get_simple_salesforce_connection
+from cumulusci.tasks.salesforce.BaseSalesforceMetadataApiTask import (
+    BaseSalesforceMetadataApiTask,
+)
+
+
+class CreateBlankProfile(BaseSalesforceMetadataApiTask):
+    api_class = ApiNewProfile
+    task_options = {
+        "license": {
+            "description": "The name of the salesforce license to use in the profile, defaults to 'Salesforce'",
+        },
+        "license_id": {
+            "description": "The ID of the salesforce license to use in the profile.",
+        },
+        "name": {
+            "description": "The name of the the new profile",
+            "required": True,
+        },
+        "description": {
+            "description": "The description of the the new profile",
+            "required": False,
+        },
+    }
+
+    def _init_options(self, kwargs):
+        super(CreateBlankProfile, self)._init_options(kwargs)
+        if {"license", "license_id"}.isdisjoint(self.options.keys()):
+            raise TaskOptionsError(
+                "Either the name or the ID of the user license must be set."
+            )
+        self.license = self.options.get("license", "Salesforce")
+
+    def _run_task(self):
+
+        self.name = self.options["name"]
+        self.description = self.options.get("description") or ""
+        self.license_id = self.options.get("license_id")
+
+        if not self.license_id:
+            self.license_id = self._get_user_license_id(self.license)
+
+        api = self._get_api()
+        result = api()
+        self.return_values = {"profile_id": result}
+        self.logger.info(f"Profile '{self.name}' created with id: {result}")
+        return result
+
+    def _get_user_license_id(self, license_name):
+        """Returns the Id of a UserLicense from a given Name"""
+        self.sf = get_simple_salesforce_connection(
+            self.project_config,
+            self.org_config,
+            api_version=self.org_config.latest_api_version,
+            base_url=None,
+        )
+        res = self.sf.query(
+            f"SELECT Id, Name FROM UserLicense WHERE Name = '{license_name}' LIMIT 1"
+        )
+        if res["records"]:
+            return res["records"][0]["Id"]
+        else:
+            raise TaskOptionsError(f"License name '{license_name}' was not found.")
+
+    def _get_api(self):
+        return self.api_class(
+            self,
+            api_version=self.org_config.latest_api_version,
+            license_id=self.license_id,
+            name=self.name,
+            description=self.description,
+        )