cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/tasks/salesforce/create_permission_sets.py

@@ -0,0 +1,35 @@
+from cumulusci.core.utils import process_list_arg
+from cumulusci.tasks.salesforce.BaseSalesforceApiTask import BaseSalesforceApiTask
+
+
+class CreatePermissionSet(BaseSalesforceApiTask):
+    task_options = {
+        "api_name": {
+            "description": "API name of generated Permission Set",
+            "required": True,
+        },
+        "label": {"description": "Label of generated Permission Set"},
+        "user_permissions": {
+            "description": "List of User Permissions to include in the Permission Set.",
+            "required": True,
+        },
+    }
+
+    def _init_options(self, kwargs):
+        super()._init_options(kwargs)
+
+        self.options["user_permissions"] = process_list_arg(
+            self.options["user_permissions"]
+        )
+
+    def _run_task(self):
+        result = self.sf.PermissionSet.create(
+            {
+                "Name": self.options["api_name"],
+                "Label": self.options.get("label") or self.options["api_name"],
+                **{perm: True for perm in self.options["user_permissions"]},
+            }
+        )
+        self.sf.PermissionSetAssignment.create(
+            {"AssigneeId": self.org_config.user_id, "PermissionSetId": result["id"]}
+        )

cumulusci/tasks/salesforce/custom_settings.py

@@ -0,0 +1,134 @@
+import pathlib
+
+import yaml
+
+from cumulusci.core.exceptions import CumulusCIException, TaskOptionsError
+from cumulusci.tasks.salesforce.BaseSalesforceApiTask import BaseSalesforceApiTask
+
+
+class LoadCustomSettings(BaseSalesforceApiTask):
+    """Load Custom Settings (both List and Hierarchy) into an org
+     from a YAML-format settings file.
+
+     Each top-level YAML key should be the API name of a Custom Setting.
+     List Custom Settings should contain a nested map of names to values.
+     Hierarchy Custom settings should contain a list, each of which contains
+     a ``data`` key and a ``location`` key. The ``location`` key may contain either
+     ``profile: <profile name>``, ``user: name: <username>``, ``user: email: <email>``,
+     or ``org``. Example:
+
+    .. code-block:: yaml
+
+         List__c:
+             Test:
+                 MyField__c: 1
+             Test 2:
+                 MyField__c: 2
+         Hierarchy__c:
+             -
+                 location: org
+                 data:
+                     MyField__c: 1
+             -
+                 location:
+                     user:
+                         name: test@example.com
+                 data:
+                     MyField__c: 2
+    """
+
+    task_options = {  # TODO: should use `class Options instead`
+        "settings_path": {
+            "description": "The path to a YAML settings file",
+            "required": True,
+        }
+    }
+
+    def _run_task(self):
+        path = pathlib.Path(self.options["settings_path"])
+        if not path.is_file():
+            raise TaskOptionsError(f"File {path} does not exist")
+
+        with path.open("r") as f:
+            self.settings = yaml.safe_load(f)
+
+        self.logger.info("Starting Custom Settings load")
+        self._load_settings()
+        self.logger.info("Finished Custom Settings load")
+
+    def _load_settings(self):
+        # For each top-level heading in our YAML doc, create one or more
+        # custom settings.
+
+        for custom_setting, settings_data in self.settings.items():
+            proxy_obj = getattr(self.sf, custom_setting)
+            # If this level is a dict, we're working with a List Custom Setting
+            # If it's a list, we have a Hierarchy Custom Setting.
+            if isinstance(settings_data, dict):
+                for setting_instance, instance_data in settings_data.items():
+                    self.logger.info(
+                        f"Loading List Custom Setting {custom_setting}.{setting_instance}"
+                    )
+                    proxy_obj.upsert("Name/{}".format(setting_instance), instance_data)
+            elif isinstance(settings_data, list):
+                for setting_instance in settings_data:
+                    query = None
+
+                    if "location" in setting_instance:
+                        if "profile" in setting_instance["location"]:
+                            # Query for a matching Profile to assign the Setup Owner Id.
+                            profile_name = setting_instance["location"]["profile"]
+                            query = (
+                                f"SELECT Id FROM Profile WHERE Name = '{profile_name}'"
+                            )
+                        elif "user" in setting_instance["location"]:
+                            if "name" in setting_instance["location"]["user"]:
+                                # Query for a matching User to assign the Setup Owner Id.
+                                user_name = setting_instance["location"]["user"]["name"]
+                                query = f"SELECT Id FROM User WHERE Username = '{user_name}'"
+                            elif "email" in setting_instance["location"]["user"]:
+                                # Query for a matching User to assign the Setup Owner Id.
+                                email_address = setting_instance["location"]["user"][
+                                    "email"
+                                ]
+                                query = f"SELECT Id FROM User WHERE Email = '{email_address}'"
+                        elif "org" == setting_instance["location"]:
+                            # Assign the Setup Owner Id to the organization.
+                            query = "SELECT Id FROM Organization"
+
+                    if query is None:
+                        raise CumulusCIException(
+                            f"No valid Setup Owner assignment found for Custom Setting {custom_setting}. Add a `location:` key."
+                        )
+
+                    matches = self.sf.query(query)
+                    if matches["totalSize"] != 1:
+                        raise CumulusCIException(
+                            f"{matches['totalSize']} records matched the settings location query {query}. Exactly one result is required."
+                        )
+
+                    setup_owner_id = matches["records"][0]["Id"]
+
+                    # We can't upsert on SetupOwnerId. Query for any existing records.
+                    existing_records = self.sf.query(
+                        f"SELECT Id FROM {custom_setting} WHERE SetupOwnerId = '{setup_owner_id}'"
+                    )
+
+                    setting_instance["data"].update({"SetupOwnerId": setup_owner_id})
+                    if existing_records["totalSize"] == 0:
+                        self.logger.info(
+                            f"Loading Hierarchy Custom Setting {custom_setting} with owner id {setup_owner_id}"
+                        )
+                        proxy_obj.create(setting_instance["data"])
+                    else:
+                        self.logger.info(
+                            f"Updating Hierarchy Custom Setting {custom_setting} with owner id {setup_owner_id}"
+                        )
+                        proxy_obj.update(
+                            existing_records["records"][0]["Id"],
+                            setting_instance["data"],
+                        )
+            else:
+                raise CumulusCIException(
+                    "Each Custom Settings entry must be a list or a map structure."
+                )

cumulusci/tasks/salesforce/custom_settings_wait.py

@@ -0,0 +1,132 @@
+""" a task for waiting on a specific custom settings value """
+
+from simple_salesforce.exceptions import SalesforceError
+
+from cumulusci.core.exceptions import TaskOptionsError
+from cumulusci.core.utils import process_bool_arg, determine_managed_mode
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+
+
+class CustomSettingValueWait(BaseSalesforceApiTask):
+    """CustomSettingValueWait polls an org until the specific value exists in a custom settings field"""
+
+    name = "CustomSettingValueWait"
+
+    task_options = {
+        "object": {
+            "description": "Name of the Hierarchical Custom Settings object to query. Can include the %%%NAMESPACE%%% token. ",
+            "required": True,
+        },
+        "field": {
+            "description": "Name of the field on the Custom Settings to query. Can include the %%%NAMESPACE%%% token. ",
+            "required": True,
+        },
+        "value": {
+            "description": "Value of the field to wait for (String, Integer or Boolean). ",
+            "required": True,
+        },
+        "managed": {
+            "description": (
+                "If True, will insert the project's namespace prefix.  "
+                "Defaults to False or no namespace."
+            ),
+            "required": False,
+        },
+        "namespaced": {
+            "description": (
+                "If True, the %%%NAMESPACE%%% token "
+                "will get replaced with the namespace prefix for the object and field."
+                "Defaults to False."
+            ),
+            "required": False,
+        },
+        "poll_interval": {
+            "description": (
+                "Seconds to wait before polling for batch job completion. "
+                "Defaults to 10 seconds."
+            )
+        },
+    }
+
+    def _run_task(self):
+        self.poll_interval_s = int(self.options.get("poll_interval", 10))
+
+        # Retrieve polling object/field/value options
+        self.object_name = self.options["object"]
+        self.field_name = self.options["field"]
+        self.check_value = self.options["value"]
+
+        # Process namespace tokens
+        self._apply_namespace()
+
+        # will block until poll_complete
+        self._poll()
+
+        self.logger.info("Value Matched.")
+
+        return True
+
+    def _poll_action(self):
+        try:
+            query_results = self.sf.query(self._object_query)
+        except SalesforceError as e:
+            message = e.content[0]["message"]
+            if "No such column 'SetupOwnerId'" in message:
+                message = "Only Hierarchical Custom Settings objects are supported."
+            raise TaskOptionsError(f"Query Error: {message}")
+
+        self.record = None
+        for row in query_results["records"]:
+            if row["SetupOwnerId"].startswith("00D"):
+                self.record = row
+
+        if self.record:
+            self.poll_complete = not self._poll_again()
+        else:
+            self.logger.info(
+                f"{self.field_name}: Looking for {self.check_value} and found no custom settings record"
+            )
+
+    def _poll_again(self):
+        return not self.success
+
+    def _apply_namespace(self):
+        # Process namespace tokens
+        namespace = self.project_config.project__package__namespace
+        managed = determine_managed_mode(
+            self.options, self.project_config, self.org_config
+        )
+        if "namespaced" in self.options:
+            namespaced = process_bool_arg(self.options["namespaced"])
+        else:
+            namespaced = bool(namespace) and self.org_config.namespace == namespace
+
+        namespace_prefix = ""
+        if namespace and (managed or namespaced):
+            namespace_prefix = namespace + "__"
+        self.object_name = self.object_name.replace("%%%NAMESPACE%%%", namespace_prefix)
+        self.field_name = self.field_name.replace("%%%NAMESPACE%%%", namespace_prefix)
+
+    @property
+    def success(self):
+        lower_case_record = {k.lower(): v for k, v in self.record.items()}
+        self.field_value = lower_case_record[self.field_name.lower()]
+
+        if isinstance(self.field_value, bool):
+            self.check_value = process_bool_arg(self.check_value)
+            self.field_value = process_bool_arg(self.field_value)
+        elif isinstance(self.field_value, (int, float)):
+            self.check_value = float(self.check_value)
+            self.field_value = float(self.field_value)
+        elif isinstance(self.field_value, str):
+            self.check_value = str(self.check_value).lower()
+            self.field_value = str(self.field_value).lower()
+
+        self.logger.info(
+            f"{self.field_name}: Looking for {self.check_value} and found {self.field_value}"
+        )
+        return self.field_value == self.check_value
+
+    @property
+    def _object_query(self):
+        return f"SELECT SetupOwnerId, {self.field_name} FROM {self.object_name}"

cumulusci/tasks/salesforce/enable_prediction.py

@@ -0,0 +1,107 @@
+from simple_salesforce.exceptions import SalesforceError
+
+from cumulusci.core.exceptions import CumulusCIException
+from cumulusci.core.utils import process_bool_arg, process_list_arg, determine_managed_mode
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+from cumulusci.utils import inject_namespace
+from cumulusci.utils.http.requests_utils import safe_json_from_response
+
+
+class EnablePrediction(BaseSalesforceApiTask):
+    task_docs = """
+    This task updates the state of Einstein Prediction Builder predictions from 'Draft' to 'Enabled' by
+    posting to the Tooling API.
+
+    cci task run enable_prediction --org dev -o api_names Example_Prediction_v0
+    """
+
+    task_options = {
+        "managed": {
+            "description": "If False, changes namespace_inject to replace tokens with a blank string"
+        },
+        "namespaced_org": {
+            "description": "If False, changes namespace_inject to replace namespaced-org tokens with a blank string"
+        },
+        "namespace_inject": {
+            "description": "If set, the namespace tokens in files and filenames are replaced with the namespace's prefix"
+        },
+        "api_names": {
+            "description": "List of API names of the MLPredictionDefinitions.",
+            "required": True,
+        },
+    }
+
+    def _init_namespace_injection(self):
+        namespace = (
+            self.options.get("namespace_inject")
+            or self.project_config.project__package__namespace
+        )
+        self.options["namespace_inject"] = namespace
+        self.options["managed"] = determine_managed_mode(
+            self.options, self.project_config, self.org_config
+        )
+        if "namespaced_org" in self.options:
+            self.options["namespaced_org"] = process_bool_arg(
+                self.options["namespaced_org"] or False
+            )
+        else:
+            self.options["namespaced_org"] = (
+                bool(namespace) and namespace == self.org_config.namespace
+            )
+
+    def _inject_namespace(self, text):
+        """Inject the namespace into the given text if running in managed mode."""
+        # We might not have an org yet if this is called from _init_options
+        # while freezing steps for metadeploy.
+        if self.org_config is None:
+            return text
+        return inject_namespace(
+            "",
+            text,
+            namespace=self.options["namespace_inject"],
+            managed=self.options.get("managed") or False,
+            namespaced_org=self.options.get("namespaced_org"),
+        )[1]
+
+    def _run_task(self):
+        # org_config might be None if we're freezing steps for metadeploy.
+        # We can only autodetect the context for namespace injection if we have the org.
+        if self.org_config:
+            self._init_namespace_injection()
+
+        api_names = [
+            self._inject_namespace(api_name)
+            for api_name in process_list_arg(self.options["api_names"])
+        ]
+
+        for api_name in api_names:
+            try:
+                ml_prediction_definition_id = self._get_ml_prediction_definition_id(
+                    api_name
+                )
+
+                response = self.tooling._call_salesforce(
+                    method="GET",
+                    url=f"{self.tooling.base_url}sobjects/MLPredictionDefinition/{ml_prediction_definition_id}",
+                )
+                result = safe_json_from_response(response)
+                metadata = result["Metadata"]
+
+                metadata["status"] = "Enabled"
+
+                self.tooling._call_salesforce(
+                    method="PATCH",
+                    url=f"{self.tooling.base_url}sobjects/MLPredictionDefinition/{ml_prediction_definition_id}",
+                    json={"Metadata": metadata},
+                )
+            except SalesforceError as e:
+                raise CumulusCIException(f"Failed to enable prediction: {e}")
+
+    def _get_ml_prediction_definition_id(self, api_name: str):
+        query = (
+            f"SELECT Id FROM MLPredictionDefinition WHERE DeveloperName = '{api_name}'"
+        )
+        try:
+            return self.tooling.query(query)["records"][0]["Id"]
+        except IndexError:
+            raise CumulusCIException(f"MLPredictionDefinition {api_name} not found.")

cumulusci/tasks/salesforce/insert_record.py

@@ -0,0 +1,40 @@
+from cumulusci.core.exceptions import SalesforceException
+from cumulusci.core.utils import process_bool_arg, process_list_of_pairs_dict_arg
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+
+
+class InsertRecord(BaseSalesforceApiTask):
+    task_docs = """
+        For example:
+
+        cci task run insert_record --org dev -o object PermissionSet -o values Name:HardDelete,PermissionsBulkApiHardDelete:true
+    """
+
+    task_options = {
+        "object": {"description": "An sObject type to insert", "required": True},
+        "values": {
+            "description": "Field names and values in the format 'aa:bb,cc:dd', or a YAML dict in cumulusci.yml.",
+            "required": True,
+        },
+        "tooling": {"description": "If True, use the Tooling API instead of REST API."},
+    }
+
+    def _init_options(self, kwargs):
+        super()._init_options(kwargs)
+        self.values = process_list_of_pairs_dict_arg(self.options["values"])
+        self.object = self.options["object"]
+        self.use_tooling = process_bool_arg(self.options.get("tooling", False))
+
+    def _run_task(self):
+        api = self.sf if not self.use_tooling else self.tooling
+        object_handler = getattr(api, self.object)
+
+        rc = object_handler.create(self.values)
+        if rc["success"]:
+            self.logger.info(f"{self.object} record inserted: {rc['id']}")
+        else:
+            # this will probably never execute, due to simple_salesforce throwing
+            # an exception, but just in case:
+            raise SalesforceException(
+                f"Could not insert {self.object} record : {rc['errors']}"
+            )