cumulusci-plus 5.0.21__py3-none-any.whl → 5.0.43__py3-none-any.whl

cumulusci/tasks/salesforce/update_record.py

@@ -0,0 +1,217 @@
+import os
+from typing import Optional
+
+from pydantic.v1 import root_validator
+
+from cumulusci.core.exceptions import SalesforceException
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+from cumulusci.utils.options import CCIOptions, Field, MappingOption
+
+
+class UpdateRecord(BaseSalesforceApiTask):
+    task_docs = """
+        Update one or more Salesforce records.
+        For example, update by record ID:
+        cci task run update_record --org dev --object Account --record_id 001xx000003DGbXXXX --values Name:UpdatedName,Status__c:Active
+        Or update by query criteria:
+        cci task run update_record --org dev --object Account --where Name:TestAccount,Status__c:Draft --values Name:UpdatedName,Status__c:Active
+        Or use environment variables with transform_values:
+        cci task run update_record --org dev --object Account --record_id 001xx000003DGbXXXX --transform_values Name:ACCOUNT_NAME_VAR,Status__c:ACCOUNT_STATUS_VAR
+    """
+
+    class Options(CCIOptions):
+        object: str = Field(..., description="An sObject type to update")
+        values: Optional[MappingOption] = Field(
+            None,
+            description="Field names and values to update in the format 'aa:bb,cc:dd', or a YAML dict in cumulusci.yml.",
+        )
+        transform_values: Optional[MappingOption] = Field(
+            None,
+            description="Field names and environment variable keys in the format 'field:ENV_KEY,field2:ENV_KEY2'. Values will be extracted from environment variables.",
+        )
+        record_id: Optional[str] = Field(
+            None,
+            description="The ID of a specific record to update. If specified, the 'where' option is ignored.",
+        )
+        where: Optional[str] = Field(
+            None,
+            description="Query criteria to identify records in the format 'field:value,field2:value2'. Multiple records may be updated.",
+        )
+        tooling: bool = Field(
+            False, description="If True, use the Tooling API instead of REST API."
+        )
+        fail_on_error: bool = Field(
+            True,
+            description="If True (default), fail the task if any record update fails. If False, log errors but continue.",
+        )
+
+        @root_validator
+        def validate_options(cls, values):
+            """Validate required option combinations"""
+            # Validate that either record_id or where is provided
+            if not values.get("record_id") and not values.get("where"):
+                raise SalesforceException(
+                    "Either 'record_id' or 'where' option must be specified"
+                )
+
+            # Validate that at least values or transform_values is provided
+            if not values.get("values") and not values.get("transform_values"):
+                raise SalesforceException(
+                    "Either 'values' or 'transform_values' option must be specified"
+                )
+
+            return values
+
+    parsed_options: Options
+
+    def _init_task(self):
+        super()._init_task()
+        self.api = self.sf if not self.parsed_options.tooling else self.tooling
+
+        # Build the final values dict by merging values and transform_values
+        self.final_values = {}
+
+        # Start with regular values if provided
+        if self.parsed_options.values:
+            self.final_values.update(self.parsed_options.values)
+
+        # Process transform_values and extract from environment
+        if self.parsed_options.transform_values:
+            for field, env_key in self.parsed_options.transform_values.items():
+                env_value = os.environ.get(env_key, env_key)
+                self.final_values[field] = env_value
+                self.logger.info(
+                    f"Transform value for field '{field}': {env_key} -> {env_value}"
+                )
+
+    def _run_task(self):
+        if self.parsed_options.record_id:
+            # Direct update by record ID
+            self._update_by_id(self.parsed_options.record_id)
+        else:
+            # Query and update multiple records
+            self._update_by_query()
+
+    def _update_by_id(self, record_id):
+        """Update a single record by ID"""
+        object_handler = getattr(self.api, self.parsed_options.object)
+
+        try:
+            rc = object_handler.update(record_id, self.final_values)
+            if rc == 204 or (isinstance(rc, dict) and rc.get("success")):
+                self.logger.info(
+                    f"{self.parsed_options.object} record updated successfully: {record_id}"
+                )
+            else:
+                error_msg = (
+                    f"Could not update {self.parsed_options.object} record {record_id}"
+                )
+                if isinstance(rc, dict) and "errors" in rc:
+                    error_msg += f": {rc['errors']}"
+                if self.parsed_options.fail_on_error:
+                    raise SalesforceException(error_msg)
+                else:
+                    self.logger.error(error_msg)
+        except Exception as e:
+            if self.parsed_options.fail_on_error:
+                raise SalesforceException(
+                    f"Error updating {self.parsed_options.object} record {record_id}: {str(e)}"
+                )
+            else:
+                self.logger.error(
+                    f"Error updating {self.parsed_options.object} record {record_id}: {str(e)}"
+                )
+
+    def _update_by_query(self):
+        """Query records and update all matching records"""
+        # Parse where clause into query criteria - MappingOption already parses it
+        from cumulusci.core.utils import parse_list_of_pairs_dict_arg
+
+        where_criteria = parse_list_of_pairs_dict_arg(self.parsed_options.where)
+
+        # Build WHERE clause
+        where_parts = [
+            f"{field} = '{value}'" for field, value in where_criteria.items()
+        ]
+        where_clause = " AND ".join(where_parts)
+
+        # Build and execute query
+        query = f"SELECT Id FROM {self.parsed_options.object} WHERE {where_clause}"
+        self.logger.info(f"Querying records: {query}")
+
+        try:
+            result = self.api.query(query)
+        except Exception as e:
+            raise SalesforceException(f"Error executing query: {str(e)}")
+
+        records = result.get("records", [])
+        total_count = len(records)
+
+        if total_count == 0:
+            self.logger.warning(
+                f"No {self.parsed_options.object} records found matching criteria: {self.parsed_options.where}"
+            )
+            return
+
+        self.logger.info(
+            f"Found {total_count} {self.parsed_options.object} record(s) to update"
+        )
+
+        # Use different update strategy based on record count
+        if total_count == 1:
+            # Single record: use direct update
+            self._update_by_id(records[0]["Id"])
+        else:
+            # Multiple records: use bulk update
+            self._update_records_bulk(records)
+
+    def _update_records_bulk(self, records):
+        """Update multiple records using Bulk API"""
+        # Prepare data for bulk update
+        update_data = []
+        for record in records:
+            record_data = {"Id": record["Id"]}
+            record_data.update(self.final_values)
+            update_data.append(record_data)
+
+        self.logger.info(
+            f"Performing bulk update of {len(update_data)} {self.parsed_options.object} records"
+        )
+
+        try:
+            # Use Bulk API for update
+            results = self.bulk.update(self.parsed_options.object, update_data)
+
+            # Process results
+            success_count = 0
+            failed_records = []
+
+            for idx, result in enumerate(results):
+                record_id = update_data[idx]["Id"]
+                if result.success:
+                    success_count += 1
+                    self.logger.info(f"Updated record: {record_id}")
+                else:
+                    error_msg = f"Failed to update record {record_id}: {result.error}"
+                    failed_records.append({"id": record_id, "error": result.error})
+                    self.logger.error(error_msg)
+
+            # Summary logging
+            self.logger.info(
+                f"Bulk update complete: {success_count}/{len(update_data)} records updated successfully"
+            )
+
+            # Handle failures
+            if failed_records and self.parsed_options.fail_on_error:
+                error_summary = "\n".join(
+                    [f"  - {rec['id']}: {rec['error']}" for rec in failed_records]
+                )
+                raise SalesforceException(
+                    f"Failed to update {len(failed_records)} record(s):\n{error_summary}"
+                )
+
+        except Exception as e:
+            if self.parsed_options.fail_on_error:
+                raise SalesforceException(f"Bulk update failed: {str(e)}")
+            else:
+                self.logger.error(f"Bulk update failed: {str(e)}")

cumulusci/tasks/salesforce/users/permsets.py

@@ -2,23 +2,43 @@ import json
 
 from cumulusci.cli.ui import CliTable
 from cumulusci.core.exceptions import CumulusCIException
-from cumulusci.core.utils import process_list_arg
+from cumulusci.core.utils import (
+    determine_managed_mode,
+    process_bool_arg,
+    process_list_arg,
+)
 from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+from cumulusci.tasks.salesforce.assign_ps_psg import build_name_conditions
+from cumulusci.utils import inject_namespace
 
 
 class AssignPermissionSets(BaseSalesforceApiTask):
     task_docs = """
 Assigns Permission Sets whose Names are in ``api_names`` to either the default org user or the user whose Alias is ``user_alias``. This task skips assigning Permission Sets that are already assigned.
+
+Permission Set names can include namespace tokens that will be replaced based on the context:
+- ``%%%NAMESPACE%%%`` is replaced with the package's namespace in managed contexts (e.g., when the package is installed)
+- ``%%%NAMESPACED_ORG%%%`` is replaced with the package's namespace in namespaced orgs only (e.g., packaging orgs)
+- ``%%%NAMESPACE_OR_C%%%`` is replaced with the namespace in managed contexts, or 'c' otherwise
+- ``%%%NAMESPACED_ORG_OR_C%%%`` is replaced with the namespace in namespaced orgs, or 'c' otherwise
+
+The managed mode and namespaced org detection is automatic based on the org context.
     """
 
     task_options = {
         "api_names": {
-            "description": "API Names of desired Permission Sets, separated by commas.",
+            "description": "API Names of desired Permission Sets, separated by commas. Can include namespace tokens like %%%NAMESPACE%%%.",
             "required": True,
         },
         "user_alias": {
             "description": "Target user aliases, separated by commas. Defaults to the current running user."
         },
+        "namespace_inject": {
+            "description": "Namespace to use for Permission Set names. If not provided, the namespace from the project config will be used.",
+        },
+        "managed": {
+            "description": "Whether the deployment is managed. If not provided, the managed mode will be determined based on the org config.",
+        },
     }
 
     permission_name = "PermissionSet"
@@ -35,6 +55,38 @@ Assigns Permission Sets whose Names are in ``api_names`` to either the default o
         self.options["user_alias"] = process_list_arg(
             self.options.get("user_alias") or []
         )
+        self._init_namespace_injection()
+
+    def _init_namespace_injection(self):
+        self.options["namespace_inject"] = (
+            self.options.get("namespace_inject")
+            or self.project_config.project__package__namespace
+        )
+        self.options["managed"] = self.options.get("managed") or determine_managed_mode(
+            self.options, self.project_config, self.org_config
+        )
+        self.options["namespaced_org"] = process_bool_arg(
+            True
+            if self.options["namespace_inject"] is not None
+            and self.options["namespace_inject"]
+            == getattr(self.org_config, "namespace", None)
+            else False
+        )
+        self.options["api_names"] = [
+            self._inject_namespace(api_name) for api_name in self.options["api_names"]
+        ]
+
+    def _inject_namespace(self, text):
+        """Inject the namespace into the given text if running in managed mode."""
+        _, name_processed = inject_namespace(
+            "",
+            text,
+            namespace=self.options.get("namespace_inject"),
+            managed=self.options.get("managed"),
+            namespaced_org=self.options.get("namespaced_org"),
+            logger=self.logger,
+        )
+        return name_processed
 
     def _run_task(self):
         users = self._query_existing_assignments()
@@ -84,12 +136,17 @@ Assigns Permission Sets whose Names are in ``api_names`` to either the default o
         return assigned_perms
 
     def _get_perm_ids(self):
-        api_names = "', '".join(self.options["api_names"])
+        name_conditions, _ = build_name_conditions(
+            self.options["api_names"], field_name=self.permission_name_field
+        )
         perms = self.sf.query(
-            f"SELECT Id,{self.permission_name_field} FROM {self.permission_name} WHERE {self.permission_name_field} IN ('{api_names}')"
+            f"SELECT Id, NamespacePrefix, {self.permission_name_field} FROM {self.permission_name} WHERE ({' OR '.join(name_conditions)})"
         )
         perms_by_ids = {
-            p["Id"]: p[self.permission_name_field] for p in perms["records"]
+            p["Id"]: f"{p['NamespacePrefix']}__{p[self.permission_name_field]}"
+            if p["NamespacePrefix"]
+            else p[self.permission_name_field]
+            for p in perms["records"]
         }
 
         missing_perms = [