Security Synchronization Logic: Activating these toggles runs the underlying _sync_cancel_groups() API method. It automatically appends (or removes) the user inside native IR security groups such as group_cancel_sale_order, establishing an anti-bypass access matrix immediately.

System Param Mapping: This selection maps directly to the system config parameter key se_cancel_all_orders.sale_cancel_type. When the native cancel method is called, the backend reads this parameter to decide whether to run a simple update, state write, or an automatic database unlink command.

Security Interception Check: Clicking this triggers the inherited action_cancel() method. If the current user profile lacks the group_cancel_sale_order access right mapping, the system instantly blocks execution and raises an explicit UserError dialog box.

Backend Pipeline Flow: The core python override invokes the base super(SaleOrder, self).action_cancel() framework logic. Since the configuration matches the default fallback execution parameters, the record state is safely updated to 'cancel' directly inside the database rows.

Contextual Bulk Execution: These options invoke custom `ir.actions.server` code blocks. The code forcefully injects a unique context dictionary key from_bulk_select=True into the pipeline loop. This instructs the base model overrides to process multiple chosen row IDs synchronously without throwing context execution blockages.

Loop Processing Validation: The custom server action iterates over the browse collection using an optimized for r in records: loop structure. By passing from_bulk_select=True via context fields, it overrides standard constraints to execute secure transaction commits directly across the database layers.

State Logic Redirection: By switching this flag, the backend workflow condition checks evaluate cancel_type == 'draft' as true. Instead of stopping after the standard super call, the inherited pipeline triggers an automatic self.write({'state': 'draft'}) row update execution parameters instantly.

Advanced Process Interception: The execution pipeline validates security parameters before calling the super script layer. Since the system parameter context verifies single document handling (absence of from_bulk_select), it prepares the document rows for automated workflow state transitions.

Post-Cancellation Automation: The overridden method validates that the backend system parameter value equals draft. It seamlessly executes the database instruction self.write({'state': 'draft'}) immediately after completing native unlinking protocols, ensuring a clean automated loop.

Workflow Thread Isolation: The background database transaction confirms that the script correctly processes separate logic threads. Because it handles a standalone active row id rather than an iterative multi-select bulk context collection array, the framework safely saves transaction states directly into the system layers.

Mass Server Action Execution: This action invokes the automated code block action_sale_order_cancel_draft_bulk. It checks permissions for each selected ID, passes the data matrix via a rapid context pipeline, intercepts native stage blocks, and forcefully applies draft state overrides across the selected records.

Mass Database Updates: The background database transaction executes the server action code blocks iteratively. By safely invoking r.with_context(from_bulk_select=True).action_cancel() followed immediately by a rapid r.write({'state': 'draft'}) pipeline, the framework alters massive datasets instantly without causing memory registry leaks.

Database Deletion Logic: When this configuration evaluates to true, the model override invokes standard super cancellation steps first, executes a direct cursor save point command (self.env.cr.commit()), and immediately runs the destructive database pipeline command self.unlink() to clear data blocks safely.

Transactional Purge Interception: The core backend code validates the context values loop. Because cancel_type == 'delete' is evaluated, the server code overrides native system lifecycle parameters by setting the row to cancel state first, firing database synchronization commits, and instantly unlinking data rows.

Unlink Sync Verification: The module utilizes self.env.cr.commit() right before running self.unlink(). This ensures that the state changes are fully locked into the active transaction before Odoo's web client triggers its view synchronization protocols, avoiding system page freeze errors.

Batch Deletion Framework: This action fires the automated code block action_sale_order_cancel_delete_bulk. The script processes each selected row ID through an optimized loop context, updates their state values to cancel, applies direct database transaction commits, and instantly unlinks massive blocks of selected datasets safely.

Complete Purge Execution: The automated process successfully targeted every record ID passed in the active collection. By executing native model validations inside the batch loop, the framework purges all row entries and related internal dependencies, providing a clean database environment for testing cycles.

System Param Mapping: This selection maps directly to the system config parameter key se_cancel_all_orders.purchase_cancel_type. When the native purchase cancel method is invoked, the inherited python override reads this parameter to decide whether to execute a standard super update or advance further down custom workflow loops.

Security Interception Check: Clicking this button triggers the inherited python override method button_cancel() inside the purchase order model extensions. If the current user lacks the group_cancel_purchase_order access rights, the system blocks the execution and instantly raises a structured UserError dialog box.

Backend Pipeline Flow: The core python override invokes the base super(PurchaseOrder, self).button_cancel() framework logic. Since the configuration matches the default fallback execution parameters, the record state is safely updated to 'cancel' directly inside the database rows.

Contextual Bulk Execution: This calls the custom server action action_purchase_order_cancel_only_bulk. It checks permissions for the selected records and injects the context variable from_bulk_select=True into the pipeline, executing the cancellation logic across all targeted IDs in a secure transaction loop.

Loop Processing Validation: The underlying server action script iterates over the browse data collection matrix using an optimized loop. Because from_bulk_select=True is safely injected inside the context pool, the backend system circumvents individual document parameters to push clean transaction updates to the SQL layer.

System Param Mapping: This selection maps directly to the system config parameter key se_cancel_all_orders.picking_cancel_type. When a stock picking cancel request runs, the overridden python logic scans this key value to decide whether to stop at base execution or advance into automated draft rollback loops.

Security Interception Check: Clicking this button triggers the inherited python override method action_cancel() inside the stock.picking model extensions. If the current user profile lacks the group_cancel_stock_picking access right mapping, the system instantly blocks execution and raises an explicit UserError dialog box.

Backend Pipeline Flow: The core backend python script invokes the base super(StockPicking, self).action_cancel() framework parameters. Since the configuration parameters dictate standard termination hooks without extra structural triggers, the row updates its selection keys cleanly inside the warehouse management registries.

Workflow Thread Isolation: The background database transaction confirms that the script correctly processes separate logic threads. Because it handles a standalone active row id rather than an iterative multi-select bulk context collection array, the framework safely saves transaction states directly into the stock log layers.

Contextual Bulk Transfer Interception: This calls the custom server action action_stock_picking_cancel_only_bulk. The script validates permissions across the dataset array, iterates over each stock picking ID, forces all linked move lines inside move_ids_without_package to a cancelled status, and updates the main record state cleanly.

Transactional Stock Log Processing: The server action executes a clean iterative background commit sequence. It directly writes cancellation keys across the targeted datasets, forcing structural updates simultaneously to both the primary parent transfers and their underlying stock moves lines without breaking relational ledger balances.

Dual Param Mapping Rules: These selections write parameters directly into distinct keys: se_cancel_all_orders.invoice_cancel_type and se_cancel_all_orders.payment_cancel_type. The financial code engine reads these individual parameters synchronously whenever reversal sequences are initiated in either model.

Financial Security Validation: Clicking this triggers the inherited button_cancel() override inside the account.move model extensions. If the active user profile lacks the group_cancel_account_invoice access right mapping, the system instantly blocks execution and raises an explicit UserError dialog box.

Backend Pipeline Flow: The core backend python script invokes the base super(AccountMove, self).button_cancel() framework parameters. Since the configuration matches the default fallback execution settings, the record state updates directly within the active accounting register tables cleanly.

Workflow Thread Isolation: The background database transaction confirms that the script correctly processes separate logic threads. Because it handles a standalone active account move record row rather than an iterative multi-select bulk collection array, the framework safely saves transaction states directly into the system layers.

Contextual Bulk Invoice Interception: This triggers the custom server action action_invoice_cancel_only_bulk. The script loops over the selected account moves collection array, injects from_bulk_select=True to prevent configuration parameters loop bypasses, and safely executes native cancellation parameters across the database array rows.

Batch Ledger Sync Operations: The server script iterates over the account move collection array loop. Because from_bulk_select=True overrides individual constraints inside the model layer, the engine runs secure adjustments across the active datasets without causing balance sheet sequence out-of-sync blockages.

System Parameter Sync Check: The engine isolates payment logic via se_cancel_all_orders.payment_cancel_type. This prevents customer cash collection registry modifications from forcing unexpected states on parent invoices, keeping your ledger reports accurately aligned.

Payment Interception Validation: Clicking this button triggers the inherited python override method action_cancel() inside the account.payment model extensions. If the active user profile lacks the group_cancel_account_invoice access right mapping, the execution blocks instantly and raises an explicit UserError.

Backend State Mapping Rules: The custom payment model override triggers super(AccountPayment, self).action_cancel() directly. If single select parameters are found, it executes a clean write instruction to set the record state key value directly to 'canceled' in the underlying database tables.

Workflow Thread Isolation: The background database transaction confirms that the script correctly processes separate logic threads. Because it handles a standalone active record row rather than an iterative multi-select bulk context collection array, the framework safely saves transaction states directly into the system layers.

Contextual Bulk Payment Interception: This triggers the custom server action action_payment_cancel_only_bulk. The script loops over the selected account payments collection array, injects from_bulk_select=True to prevent configuration parameters loop bypasses, and safely executes native cancellation parameters across the database array rows.

Batch Payment Process Sync: The server script iterates over the account payment collection array loop. Because from_bulk_select=True overrides individual single form criteria, the framework safely applies cancellation updates across massive sets of collection registries without throwing unexpected balance errors.

Access Rights Validation Rules: Clicking this button immediately routes the system query through the action_cancel() extension block in the account.payment model. If the active profile lacks group access, the transaction layer blocks further operations and fires a clear exception dialogue alert instantly.

Backend State Mapping Rules: The custom payment model override triggers super(AccountPayment, self).action_cancel() directly. If single select parameters are found, it executes a clean write instruction to set the record state key value directly to 'canceled' in the underlying database tables.

Workflow Thread Isolation: The background database transaction confirms that the script correctly processes separate logic threads. Because it handles a standalone active record row rather than an iterative multi-select bulk context collection array, the framework safely saves transaction states directly into the customer payment logs.

Contextual Bulk Payment Interception: This triggers the custom server action action_payment_cancel_only_bulk. The script loops over the selected customer cash collection registry dataset, injects from_bulk_select=True to bypass standalone single configuration limits, and safely updates states across the database matrix cleanly.

Batch Payment Process Sync: The server script iterates over the account payment collection array loop. Because from_bulk_select=True overrides individual single form criteria, the framework safely applies cancellation updates across massive sets of collection registries without throwing unexpected balance errors.