cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/tasks/salesforce/install_package_version.py

@@ -0,0 +1,242 @@
+import click
+
+from cumulusci.core.dependencies.dependencies import (
+    PackageNamespaceVersionDependency,
+    PackageVersionIdDependency,
+)
+from cumulusci.core.dependencies.resolvers import get_resolver_stack
+from cumulusci.core.exceptions import CumulusCIException, TaskOptionsError
+from cumulusci.core.utils import process_bool_arg
+from cumulusci.salesforce_api.package_install import (
+    DEFAULT_PACKAGE_RETRY_OPTIONS,
+    PACKAGE_INSTALL_TASK_OPTIONS,
+    PackageInstallOptions,
+    SecurityType,
+)
+from cumulusci.tasks.salesforce.BaseSalesforceApiTask import BaseSalesforceApiTask
+from cumulusci.vcs.bootstrap import find_previous_release
+
+
+class InstallPackageVersion(BaseSalesforceApiTask):
+    task_options = {
+        "name": {
+            "description": "The name of the package to install.  Defaults to project__package__name_managed",
+            "required": False,
+        },
+        "namespace": {
+            "description": "The namespace of the package to install.  Defaults to project__package__namespace",
+            "required": True,
+        },
+        "version": {
+            "description": 'The version of the package to install.  "latest" and "latest_beta" can be used to trigger lookup via Github Releases on the repository.',
+            "required": True,
+        },
+        "version_number": {
+            "description": "If installing a package using an 04t version Id, display this version "
+            "number to the user and in logs. Has no effect otherwise."
+        },
+        "activateRSS": {
+            "description": "Deprecated. Use activate_remote_site_settings instead."
+        },
+        "retries": {"description": "Number of retries (default=5)"},
+        "retry_interval": {
+            "description": "Number of seconds to wait before the next retry (default=5),"
+        },
+        "retry_interval_add": {
+            "description": "Number of seconds to add before each retry (default=30),"
+        },
+        "interactive": {
+            "description": "If True, stop after resolving the package version and output the package Id that will be installed. Defaults to False."
+        },
+        "base_package_url_format": {
+            "description": "If `interactive` is set to True, display package Ids using a format string ({} will be replaced with the package Id)."
+        },
+        **PACKAGE_INSTALL_TASK_OPTIONS,
+    }
+
+    def _init_options(self, kwargs):
+        super()._init_options(kwargs)
+
+        if "namespace" not in self.options:
+            self.options["namespace"] = self.project_config.project__package__namespace
+        version = self.options.get("version")
+
+        # `name` is shown in the logs and in MetaDeploy
+        # Populate a reasonable default. Note that if we're deploying a different package
+        # than our own, we should not show the name of this repo's package.
+        if "name" not in self.options:
+            if isinstance(version, str) and version.startswith("04t"):
+                self.options["name"] = "Package"
+            elif (
+                self.options["namespace"]
+                == self.project_config.project__package__namespace
+            ):
+                self.options["name"] = (
+                    self.project_config.project__package__name_managed
+                    or self.project_config.project__package__name
+                    or self.options["namespace"]
+                )
+            else:
+                self.options["name"] = self.options["namespace"]
+
+        self.retry_options = DEFAULT_PACKAGE_RETRY_OPTIONS.copy()
+        if "retries" in self.options:
+            self.retry_options["retries"] = self.options["retries"]
+        if "retry_interval" in self.options:
+            self.retry_options["retry_interval"] = self.options["retry_interval"]
+        if "retry_interval_add" in self.options:
+            self.retry_options["retry_interval_add"] = self.options[
+                "retry_interval_add"
+            ]
+
+        dependency = None
+
+        if version in ["latest", "latest_beta"]:
+            strategy = "include_beta" if version == "latest_beta" else "production"
+            vcs_service = self.project_config.repo_service
+            repo = vcs_service.get_repository(options=self.options)
+
+            dependency = vcs_service.dynamic_dependency_class(url=repo.clone_url)
+            dependency.resolve(
+                self.project_config, get_resolver_stack(self.project_config, strategy)
+            )
+        elif version == "previous":
+            vcs_service = self.project_config.repo_service
+            repo = vcs_service.get_repository(options=self.options)
+
+            release = find_previous_release(
+                repo,
+                self.project_config.project__git__prefix_release,
+            )
+
+            vcs_service = self.project_config.repo_service
+            dependency = vcs_service.dynamic_dependency_class(
+                url=repo.clone_url, tag=release.tag_name
+            )
+            dependency.resolve(
+                self.project_config,
+                get_resolver_stack(self.project_config, "production"),
+            )
+        elif isinstance(version, (float, int)):
+            self.logger.warning(
+                f"The `version` option is specified as a number ({version}). "
+                "Please specify as a quoted string to avoid ambiguous results."
+            )
+            self.options["version"] = str(version)
+
+        if dependency:
+            if dependency.package_dependency:
+                # Handle 2GP and 1GP releases in a backwards-compatible way.
+                if isinstance(
+                    dependency.package_dependency, PackageNamespaceVersionDependency
+                ):
+                    self.options["version"] = dependency.package_dependency.version
+                    self.options[
+                        "version_id"
+                    ] = dependency.package_dependency.version_id
+                elif isinstance(
+                    dependency.package_dependency, PackageVersionIdDependency
+                ):
+                    self.options["version"] = dependency.package_dependency.version_id
+                    self.options[
+                        "version_number"
+                    ] = dependency.package_dependency.version_number
+            else:
+                raise CumulusCIException(
+                    f"The release for {version} does not identify a package version."
+                )
+
+        if "activateRSS" in self.options:
+            self.logger.warning(
+                "The activateRSS option is deprecated. Please use activate_remote_site_settings."
+            )
+            self.options["activate_remote_site_settings"] = self.options["activateRSS"]
+            del self.options["activateRSS"]
+
+        self.install_options = PackageInstallOptions.from_task_options(self.options)
+        self._check_for_tooling()
+
+        # Interactivity options
+        self.options["interactive"] = process_bool_arg(
+            self.options.get("interactive") or False
+        )
+        self.options["base_package_url_format"] = (
+            self.options.get("base_package_url_format") or "{}"
+        )
+
+    def _run_task(self):
+        version = self.options["version"]
+
+        if version.startswith("04t"):
+            dep = PackageVersionIdDependency(
+                version_id=version, package_name=self.options["name"]
+            )
+            if "version_number" in self.options:
+                dep.version_number = self.options["version_number"]
+        else:
+            dep = PackageNamespaceVersionDependency(
+                namespace=self.options["namespace"],
+                version=version,
+                package_name=self.options["name"],
+                version_id=self.options.get("version_id"),
+            )
+
+        if self.options.get("interactive", False):
+            if dep.version_id:
+                package_desc = self.options["base_package_url_format"].format(
+                    dep.version_id
+                )
+            else:
+                package_desc = str(dep)
+            self.logger.info("Package to install: {}".format(package_desc))
+            if not click.confirm("Continue to install dependencies?", default=True):
+                raise CumulusCIException("Dependency installation was canceled.")
+
+        dep.install(
+            self.project_config,
+            self.org_config,
+            self.install_options,
+            self.retry_options,
+        )
+
+        self.org_config.reset_installed_packages()
+
+    def freeze(self, step):
+        if self.options["interactive"]:
+            raise CumulusCIException(
+                "update_dependencies cannot be frozen when `interactive` is True."
+            )
+
+        options = self.options.copy()
+        options["version"] = str(options["version"])
+        if "version_id" in options:
+            # This is used only in interactive mode.
+            del options["version_id"]
+        name = options.pop("name")
+        task_config = {"options": options, "checks": self.task_config.checks or []}
+        ui_step = {
+            "name": f"Install {name} {options.get('version_number') or options['version']}",
+            "kind": "managed",
+            "is_required": True,
+        }
+        ui_step.update(step.task_config.get("ui_options", {}))
+        ui_step.update(
+            {
+                "path": step.path,
+                "step_num": str(step.step_num),
+                "task_class": self.task_config.class_path,
+                "task_config": task_config,
+                "source": step.project_config.source.frozenspec,
+            }
+        )
+        return [ui_step]
+
+    def _check_for_tooling(self):
+        version = str(self.options.get("version"))
+        if (
+            version.startswith("04t")
+            and self.install_options.security_type is SecurityType.PUSH
+        ):
+            raise TaskOptionsError(
+                "Cannot use security type 'PUSH' when installing using a 04t package version ID due to Tooling API limitations."
+            )

cumulusci/tasks/salesforce/license_preflights.py

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

cumulusci/tasks/salesforce/network_member_group.py

@@ -0,0 +1,178 @@
+from typing import List
+
+from simple_salesforce import format_soql
+
+from cumulusci.core.exceptions import CumulusCIException, SalesforceException
+from cumulusci.core.utils import process_list_arg
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+
+
+class CreateNetworkMemberGroups(BaseSalesforceApiTask):
+    """
+    Creates NetworkMemberGroup for a Network (Experience Site) for Profiles and Permission Sets
+    that don't already have a corresponding NetworkMemberGroup.
+
+    Raises exceptions if records cannot be found:
+    - Network with Name network_name
+    - Profiles with Names in profile_names
+    - Permission Sets with Names in permission_set_names
+    """
+
+    task_options = {
+        "network_name": {
+            "description": (
+                "Name of Network to add NetworkMemberGroup children records."
+            ),
+            "required": True,
+        },
+        "profile_names": {
+            "description": (
+                "List of Profile Names to add as NetworkMemberGroups "
+                "for this Network."
+            ),
+            "required": False,
+        },
+        "permission_set_names": {
+            "description": (
+                "List of PermissionSet Names to add as NetworkMemberGroups "
+                "for this Network."
+            ),
+            "required": False,
+        },
+    }
+
+    def _get_network_id(self, network_name: str) -> str:
+        """
+        Returns Id of Network record with Name network_name.
+        Raises a SalesforceException if no Network is found.
+        """
+
+        networks = self.sf.query_all(
+            format_soql(
+                "SELECT Id FROM Network WHERE Name = {network_name} LIMIT 1",
+                network_name=network_name,
+            )
+        )
+
+        if not networks["records"]:
+            raise SalesforceException(
+                f'No Network record found with Name "{network_name}"'
+            )
+        self.logger.info(
+            f"Creating NetworkMemberGroup records for {network_name} Network:"
+        )
+        return networks["records"][0]["Id"]
+
+    def _get_network_member_group_parent_ids(self, network_id) -> set:
+        """
+        Collect existing NetworkMemberGroup Parent IDs (associated Profile or Permission Set ID).
+        An excpetion is thrown trying to create a NetworkMemberGroup for a parent who already has a
+        record.
+        """
+
+        network_member_group_parent_ids = set()
+        for record in self.sf.query_all(
+            f"SELECT ParentId FROM NetworkMemberGroup WHERE NetworkId = '{network_id}'"  # noqa: E501
+        )["records"]:
+            network_member_group_parent_ids.add(record["ParentId"])
+        return network_member_group_parent_ids
+
+    def _get_parent_ids_by_name(self, sobject_type: str, record_names: List[str]):
+        """
+        Returns a Dict: Name --> ID of records with Name in record_names for
+        sObject_type.   Dict value are None for all record_names that do not
+        have corresponding records.
+        """
+        parent_ids_by_name = dict((name, None) for name in record_names)
+
+        if sobject_type == "PermissionSet":
+            field_key = "Label"
+        else:
+            field_key = "Name"
+
+        for record in self.sf.query_all(
+            "SELECT Id, {} FROM {} WHERE {} IN ('{}')".format(
+                field_key,
+                sobject_type,
+                field_key,
+                "','".join(record_names),
+            )
+        )["records"]:
+            record_name = record[field_key]
+            parent_ids_by_name[record_name] = record["Id"]
+
+        return parent_ids_by_name
+
+    def _process_parent(self, sobject_type, record_names) -> None:
+        """
+        For a specific sobject_type and record_names, queries all Salesforce IDs
+        corresponding to records of SObjectType sobject_type with Name in
+        record_names.   Then, tries to create NetworkMemberGroup for each
+        parent in record_names.
+        """
+
+        if not record_names:
+            return
+
+        self.logger.info(f"    {sobject_type}:")
+
+        # Collect Parent IDs by Name.
+        parent_ids_by_name = self._get_parent_ids_by_name(sobject_type, record_names)
+
+        # Create NetworkMemberGroup records.
+        for parent_name, parent_id in parent_ids_by_name.items():
+            self._create_network_member_group(sobject_type, parent_name, parent_id)
+
+    def _create_network_member_group(
+        self, sobject_type, parent_name, parent_id
+    ) -> None:
+        """
+        Processes and logs creating a NetworkMemberGroup for a specific parent.
+
+        Outcomes:
+        - Raises a CumulusCIException if record_id is None meaning
+          no corresponding record was found in _get_parent_ids_by_name.
+        - Logs a warning that a NetworkMemberGroup already exists is parent_id
+          is in self._parent_ids.
+        - Creates a NetworkMemberGroup for parent_id and logs the result.
+        """
+
+        # Assert a Parent was found for each Name.
+        if not parent_id:
+            raise CumulusCIException(
+                f'No {sobject_type} record found with Name "{parent_name}"'
+            )
+        # If the Profile/Permission set already exists for a NetworkMemberGroup -
+        if parent_id in self._parent_ids:
+            self.logger.warning(f'        Already exists for "{parent_name}"')
+        else:
+            insert_response = self.sf.NetworkMemberGroup.create(
+                {"NetworkId": self._network_id, "ParentId": parent_id}
+            )
+            if insert_response.get("success") is True:
+                self.logger.info(f'        "{parent_name}"')
+            else:
+                # It might be impossible to get to this state.
+                # If there's a query exception, it gets thrown before this is called.
+                raise SalesforceException(
+                    f'Error creating NetworkMemberGroup for Network "{self._network_id}" for parent {sobject_type} "{parent_name}" {parent_id}.   Errors: {", ".join(insert_response.get("errors") or [])}'
+                )
+
+    def _run_task(self):
+        """
+        Gets required information then tries to create NetworkMemberGroups for
+        Profiles and Permission Sets cooresponding to profile_names and
+        permission_set_names respectively.
+        """
+
+        self._network_id = self._get_network_id(self.options["network_name"])
+        self._parent_ids = self._get_network_member_group_parent_ids(self._network_id)
+
+        # Create NetworkMemberGroup records.
+        for sobject_type, record_names in {
+            "Profile": process_list_arg(self.options.get("profile_names") or []),
+            "PermissionSet": process_list_arg(
+                self.options.get("permission_set_names") or []
+            ),
+        }.items():
+            self._process_parent(sobject_type, record_names)

cumulusci/tasks/salesforce/nonsourcetracking.py

@@ -0,0 +1,228 @@
+import json
+import os
+
+import requests
+
+from cumulusci.core.config import TaskConfig
+from cumulusci.core.exceptions import CumulusCIException
+from cumulusci.core.utils import process_list_arg
+from cumulusci.salesforce_api.metadata import ApiListMetadata
+from cumulusci.tasks.salesforce import (
+    BaseRetrieveMetadata,
+    BaseSalesforceApiTask,
+    DescribeMetadataTypes,
+)
+from cumulusci.tasks.salesforce.sourcetracking import ListChanges, retrieve_components
+
+nl = "\n"
+
+
+class ListNonSourceTrackable(BaseSalesforceApiTask):
+
+    task_options = {
+        "api_version": {
+            "description": "Override the API version used to list metadatatypes",
+        },
+    }
+
+    def _init_task(self):
+        super()._init_task()
+        if "api_version" not in self.options:
+            self.options[
+                "api_version"
+            ] = self.project_config.project__package__api_version
+
+    def get_types_details(self, api_version):
+        # The Metadata coverage report: https://developer.salesforce.com/docs/metadata-coverage/{version} is created from
+        # the below URL. (So the api versions are allowed based on those report ranges)
+        url = f"https://dx-extended-coverage.my.salesforce-sites.com/services/apexrest/report?version={api_version}"
+        response = requests.get(url)
+        if response.status_code == 200:
+            json_response = response.json()
+            return json_response
+        else:
+            raise CumulusCIException(
+                f"Failed to retrieve response with status code {response.status_code}"
+            )
+
+    def _run_task(self):
+        metadatatypes_details = self.get_types_details(self.options["api_version"])[
+            "types"
+        ]
+        all_nonsource_types = []
+        for md_type, details in metadatatypes_details.items():
+            if not details["channels"]:
+                raise CumulusCIException(
+                    f"Api version {self.options['api_version']} not supported"
+                )
+            if (
+                details["channels"]["sourceTracking"] is False
+                and details["channels"]["metadataApi"] is True
+            ):
+                all_nonsource_types.append(md_type)
+
+        types_supported = DescribeMetadataTypes(
+            org_config=self.org_config,
+            project_config=self.project_config,
+            task_config=self.task_config,
+        )._run_task()
+
+        self.return_values = []
+        for md_type in all_nonsource_types:
+            if md_type in types_supported:
+                self.return_values.append(md_type)
+
+        if self.return_values:
+            self.return_values.sort()
+
+        self.logger.info(
+            f"Non source trackable Metadata types supported by org: \n{self.return_values}"
+        )
+        return self.return_values
+
+
+class ListComponents(BaseSalesforceApiTask):
+    api_class = ApiListMetadata
+    task_options = {
+        "api_version": {
+            "description": "Override the API version used to list metadatatypes",
+        },
+        "metadata_types": {"description": "A comma-separated list of metadata types."},
+    }
+
+    def _init_task(self):
+        super()._init_task()
+
+    def _init_options(self, kwargs):
+        super(ListComponents, self)._init_options(kwargs)
+        if "api_version" not in self.options:
+            self.options[
+                "api_version"
+            ] = self.project_config.project__package__api_version
+        if "metadata_types" not in self.options:
+            self.options["metadata_types"] = ListNonSourceTrackable(
+                org_config=self.org_config,
+                project_config=self.project_config,
+                task_config=TaskConfig(
+                    {"options": {"api_version": self.options["api_version"]}}
+                ),
+            )._run_task()
+        else:
+            self.options["metadata_types"] = process_list_arg(
+                self.options.get("metadata_types")
+            )
+
+    def _get_components(self):
+        list_components = []
+        for md_type in self.options["metadata_types"]:
+            api_object = self.api_class(
+                self, metadata_type=md_type, as_of_version=self.options["api_version"]
+            )
+            components = api_object()
+            for temp in components[md_type]:
+                cmp = {
+                    "MemberType": md_type,
+                    "MemberName": temp["fullName"],
+                    "lastModifiedByName": temp["lastModifiedByName"],
+                    "lastModifiedDate": temp["lastModifiedDate"],
+                }
+                if cmp not in list_components:
+                    list_components.append(cmp)
+        return list_components
+
+    def _run_task(self):
+        self.return_values = self._get_components()
+        self.logger.info(
+            f"Found {len(self.return_values)} non source trackable components in the org for the given types."
+        )
+        for change in self.return_values:
+            self.logger.info("{MemberType}: {MemberName}".format(**change))
+        return self.return_values
+
+
+retrieve_components_task_options = ListComponents.task_options.copy()
+retrieve_components_task_options["path"] = {
+    "description": "The path to write the retrieved metadata",
+    "required": False,
+}
+retrieve_components_task_options["include"] = {
+    "description": "Components will be included if one of these names"
+    "is part of either the metadata type or name. "
+    "Example: ``-o include CustomField,Admin`` matches both "
+    "``CustomField: Favorite_Color__c`` and ``Profile: Admin``"
+}
+retrieve_components_task_options["exclude"] = {
+    "description": "Exclude components matching this name."
+}
+retrieve_components_task_options[
+    "namespace_tokenize"
+] = BaseRetrieveMetadata.task_options["namespace_tokenize"]
+
+
+class RetrieveComponents(ListComponents, BaseSalesforceApiTask):
+    task_options = retrieve_components_task_options
+
+    def _init_options(self, kwargs):
+        super(RetrieveComponents, self)._init_options(kwargs)
+        self.options["include"] = process_list_arg(self.options.get("include", []))
+        self.options["exclude"] = process_list_arg(self.options.get("exclude", []))
+        self._include = self.options["include"]
+        self._exclude = self.options["exclude"]
+        self._exclude.extend(self.project_config.project__source__ignore or [])
+
+        package_directories = []
+        default_package_directory = None
+        if os.path.exists("sfdx-project.json"):
+            with open("sfdx-project.json", "r", encoding="utf-8") as f:
+                sfdx_project = json.load(f)
+                for package_directory in sfdx_project.get("packageDirectories", []):
+                    package_directories.append(package_directory["path"])
+                    if package_directory.get("default"):
+                        default_package_directory = package_directory["path"]
+
+        path = self.options.get("path")
+        if path is None:
+            # set default path to src for mdapi format,
+            # or the default package directory from sfdx-project.json for dx format
+            if (
+                default_package_directory
+                and self.project_config.project__source_format == "sfdx"
+            ):
+                path = default_package_directory
+                md_format = False
+            else:
+                path = "src"
+                md_format = True
+        else:
+            md_format = path not in package_directories
+        self.md_format = md_format
+        self.options["path"] = path
+
+    def _run_task(self):
+        components = self._get_components()
+        filtered, ignored = ListChanges._filter_changes(self, components)
+        if not filtered:
+            self.logger.info("No components to retrieve")
+            return
+        for cmp in filtered:
+            self.logger.info("{MemberType}: {MemberName}".format(**cmp))
+
+        target = os.path.realpath(self.options["path"])
+        package_xml_opts = {}
+        if self.options["path"] == "src":
+            package_xml_opts.update(
+                {
+                    "package_name": self.project_config.project__package__name,
+                    "install_class": self.project_config.project__package__install_class,
+                    "uninstall_class": self.project_config.project__package__uninstall_class,
+                }
+            )
+        retrieve_components(
+            filtered,
+            self.org_config,
+            target,
+            md_format=self.md_format,
+            namespace_tokenize=self.options.get("namespace_tokenize"),
+            api_version=self.options["api_version"],
+            extra_package_xml_opts=package_xml_opts,
+        )