Odoo development · Technical reference
ORM, OWL, JSON-2 API, testing and multi-company security — with the answers.
137 entries · free, no sign-up
Showing all 137 entries
Focus on a specific technical or functional gap (e.g., complex multi-step manufacturing or non-standard accounting) and explain how you researched, prototyped, and implemented the solution without breaking Odoo standards.
I use the 'Standard First' approach. I explain the long-term maintenance cost and risk. If they still insist, I document the risk and implement it as a separate, clean module with minimal overrides.
Mention specific features like Accounting, Studio, Planning, and Mobile app availability in Enterprise, and how you manage transitions or feature-gaps in Community projects.
Mention Odoo Experience talks, official GitHub commits, documentation, and the Odoo community (OCA).
Focus on readability, performance (avoiding loops in SQL/ORM), security (access rights), and adherence to Odoo's coding guidelines.
It is the metadata file for an Odoo module. It defines the name, version, dependencies, data files (XML/CSV), and category.
_name is the internal model identifier (e.g., sale.order). _description is the user-friendly name. _inherit is used for extending existing models (Classic Inheritance) or delegation.
Basic: Char, Integer, Float, Boolean, Text, Date, Datetime. Relational: Many2one, One2many, Many2many. Special: Binary, Html, Image, Selection, Monetary (requires currency_id), Reference.
Record rules are used to restrict record access at the database level. They require a name, model, domain filter (e.g., [('user_id', '=', user.id)]), and flags for Read, Write, Create, and Delete.
compute fields calculate values on the fly via a Python method. related fields fetch values from a linked record (e.g., partner_id.phone). By default, both are not stored in the DB unless store=True is set.
onchange updates the UI based on field changes before saving. Use it for dynamic UI feedback, but avoid heavy logic (use compute with depends for data integrity).
An ir.actions.act_window defines how to open a view, and a menuitem links that action to the sidebar/top menu.
Many2one is a link to a single record (foreign key). One2many is a virtual relationship showing all records that link back to the current one (requires a Many2one field on the other side).
domain is a filter for records (e.g., [('state', '=', 'draft')]). context is a dictionary used to pass data (like lang, timezone, or default values) between views and methods.
Use the <search> tag in XML. Inside, you define <field> for direct search and <filter> for predefined domain filters or group-by options.
It is a safeguard that raises an error if self contains more than one record. Essential for methods that perform actions on a single object.
It stores public assets like CSS, Javascript, Images, and XML templates for the web client (OWL).
api.depends is for stored/unstored compute fields to trigger recalculation when dependencies change. api.onchange is only for UI-driven changes.
Use proper indexing in PostgreSQL (index=True in Python), use search_fetch (v18+) for batching, avoid search().filtered(), and use direct SQL queries via self.env.cr.execute if ORM is too slow.
When you access a field on a recordset, Odoo fetches that field for all records in the recordset in one query to minimize round-trips to the DB.
It is used to call the parent implementation of a method. Essential for extending standard behavior (e.g., create, write, action_confirm) without overwriting it entirely.
Ensure models have a company_id field and use record rules with ['|', ('company_id', '=', False), ('company_id', 'in', company_ids)]. Use sudo() sparingly only when bypassing company restrictions is strictly necessary.
search_read returns a list of dictionaries for specific records. read_group returns aggregated data (SUM, AVG, COUNT) based on a groupby parameter, used in Pivot and Graph views.
Define a compute field to count related records, add a button in the oe_button_box div in XML, and link it to an action filtered by the current record ID.
The environment stores the cursor, user ID, context, and a cache of recordsets. It provides access to other models via self.env['model.name'].
Use import pdb; pdb.set_trace(), breakpoint(), or Odoo's --dev=all flag. For frontend, use browser dev tools for OWL and JS.
It defines Group-level permissions (Read, Write, Create, Delete) for every model. Without this, non-admin users cannot access the model.
mapped returns a list or recordset of attributes. filtered returns records matching a condition (lambda or string). sorted returns a new recordset ordered by a key.
Use write() on a recordset rather than looping and calling write() on individual records. Odoo will generate a single SQL UPDATE query.
You can pass default values via context using default_field_name: value. Odoo's create() method checks the context for these keys automatically.
Use 'Scheduled Actions' (Crons) for background processing, or implement a 'Queue' system if you need real-time-ish background execution (like queue_job OCA module).
Classic (_inherit): Adds fields/methods to an existing model. Delegation (_inherits): Links a model to another (like res.users inherits res.partner), where one record in the new table corresponds to one in the linked table.
Purchase Request -> RFQ -> Purchase Order -> Receive Products (Transfer) -> Create Vendor Bill -> Register Payment.
CRM Lead -> Quotation -> Sales Order -> Delivery (Picking) -> Create Invoice -> Register Payment.
It tracks the financial value of stock. Costs can be Standard, AVCO (Average Cost), or FIFO (First-In-First-Out). Methods include Manual (periodic) vs Automated (real-time journal entries).
Enable multi-currency in settings, define exchange rates for specific dates. Odoo calculates realized/unrealized exchange differences during payment and reconciliation.
Additional costs incurred when importing goods (freight, insurance, customs, handling) that are added to the product cost price to reflect true inventory value.
The process of matching bank statement lines with internal invoices or journal entries to ensure the Odoo bank balance matches the actual bank statement.
A list of components and operations required to manufacture a product. Odoo supports standard Manufacture, Kits (phantom BoMs), and Subcontracting.
When validating a transfer with fewer items than ordered, Odoo creates a 'Backorder' to track the remaining quantity and schedules a new transfer.
Storable: Full inventory tracking (stock levels, valuation). Consumable: No stock tracking; quantities are assumed to be always sufficient for orders.
Used for multi-dimensional cost accounting (e.g., tracking profitability by Project, Department, or Region) without adding hundreds of accounts to the Chart of Accounts.
A process where the vendor ships directly to the customer. A Purchase Order is triggered by a Sales Order, but the products never enter your physical warehouse.
A security check that compares the Purchase Order, the Receipt, and the Vendor Bill to ensure you only pay for what you ordered and received.
Using Attributes (e.g., Size, Color) and Values. Odoo creates unique product.product records for every combination of attributes defined on a product.template.
A mapping tool that automatically changes the taxes and accounts on a transaction based on the customer's or vendor's location (e.g., domestic vs international).
Accounting for income or expenses over a period of time (e.g., an annual insurance policy). Odoo spreads the amount across months via automated journal entries.
Reclaims disk space and updates query planner statistics from 'dead tuples' created by Odoo updates. Essential for preventing 'Database Bloat' in high-traffic environments.
Workers handle HTTP/User requests in multi-processing mode. Cron threads handle background tasks. Rule of thumb: workers = (CPU cores × 2) + 1.
Use PostgreSQL row-level locking (FOR UPDATE) via self.env.cr.execute or ORM's flush_recordset() to ensure data consistency during concurrent operations.
Use a Load Balancer (Nginx/HAProxy) -> Multiple Odoo App Servers -> Dedicated PostgreSQL Cluster (Primary/Replica) -> Shared Filestore (S3 or NFS).
A real-time messaging system (Long-polling or WebSockets) used for UI-to-UI communication, like Chat notifications or refreshing views without a page reload.
Model: Persistent DB table. TransientModel: Temporary storage (deleted periodically, used for Wizards). AbstractModel: No DB table, used as a base class for other models.
A lightweight connection pooler for PostgreSQL. It reduces the overhead of creating new DB connections, mandatory for Odoo setups with 100+ concurrent users.
By mounting a shared volume (like AWS EFS or NFS) to /var/lib/odoo across all app servers, or using a custom module to store attachments directly in Amazon S3.
A Python library used for non-blocking I/O. Odoo uses it on the Longpolling/WebSocket port (8072) to handle thousands of concurrent chat/notification connections.
The registry is a singleton mapping of all model names to their classes. It is initialized during server startup and reloaded when a module is installed or updated.
A modern, high-performance JS framework (similar to React/Vue) created by Odoo to replace the legacy jQuery/Widget architecture with a reactive component-based system.
Using the patch utility from '@web/core/utils/patch'. This allows adding or modifying methods on existing components (like the FormController) safely.
t-name defines a template's unique ID. t-inherit (with t-inherit-mode='extension') allows modifying an existing XML template using <xpath> selectors.
By returning a dictionary with type: 'ir.actions.client' and tag: 'display_notification', passing the message and title in the params.
Specialized functions that allow OWL components to access Odoo services (like 'notification' or 'rpc') and manage reactive state within the component.
Define an OWL component, extend standardFieldProps, register it in the 'fields' registry, and then use widget='your_widget_name' in the XML view.
Client Actions: Trigger JS code in the browser (e.g., opening a custom dashboard). Server Actions: Trigger Python code on the server (e.g., mass-updating a field).
Add the file path to the 'assets' section in the __manifest__.py file, specifically under 'web.assets_backend' for the main ERP interface.
A central UI component that handles the breadcrumbs, search view, and action buttons (Create, Export) across all Odoo views.
Use the useService('rpc') hook in OWL to call specific model methods via this.rpc('/web/dataset/call_kw', {...}).
Native integration of LLMs that allows users to generate Python code, summarize records, or draft emails directly from the Odoo interface.
A modern RESTful replacement for the legacy XML-RPC API. It uses 'Bearer Token' authentication and a clean /json/2/<model>/<method> URL structure.
A new ORM method that combines 'search' and 'read' into a single database operation, significantly reducing the overhead for fetching large recordsets.
New automated tools to adjust the Balance Sheet values based on real-time exchange rates, automatically posting unrealized gain/loss entries.
Users can now type queries like 'Show me all unpaid invoices for Gemini' in the search bar, and Odoo translates it into a domain filter automatically.
./odoo-bin -c odoo.conf
-u module_name
8069
8072
.sudo()
Monetary
Prevents XML override during updates
./odoo-bin shell -d db
ir.model.access
<xpath>
sudo systemctl restart odoo
__manifest__.py
odoo
./odoo-bin --version
logfile = /path/to/log
Accounts Receivable (A/R)
Accounts Payable (A/P)
Order to Cash
Procure to Pay
Bill of Materials
First In, First Out
A potential business opportunity
Removing damaged items from inventory
PO vs Receipt vs Bill
Dimension for cost tracking
Override the action_confirm method in sale.order. Check for any open invoices with state='posted' and date_due < today. Raise a UserError if found.
Add a 'post-validation' hook in the picking validation logic or use an 'Automated Action' (base_automation) triggered on the 'done' state of stock.picking.
Use an 'Inventory Adjustment' for quantities, but for prices, use a 'Server Action' with Python code: records.write({'list_price': r.list_price * 1.1}).
Enable 'Lots & Serial Numbers' in settings. Set the products as 'Track by Lots'. Use 'Component Traceability' on the Bill of Materials (BoM).
Configure 'Multi-Currency' and use the 'Consolidation' module to map accounts to a consolidated chart in a different currency.
Override the action_post method in account.payment or use a 'Reconciliation' hook to find the related partner and increment the field based on the paid amount.
When the data is temporary and doesn't need to be kept permanently (e.g., configuration wizards, report filters, or multi-step input forms).
It happens when a loop triggers a DB query for every iteration (e.g., accessing record.partner_id.name inside a loop). It can turn a 0.1s operation into a 10s operation.
Adjust the 'client_max_body_size' in Nginx and the 'limit_time_real' in odoo.conf to prevent timeouts during the upload process.
By moving the 'filestore' to a centralized storage (S3/NFS) and the 'session' data to Redis, allowing multiple app servers to handle requests interchangeably.
Odoo.sh: Managed PaaS, built-in CI/CD, automatic backups. On-Premise: Full control over hardware, Postgres tuning, and OS-level security hardening.
TransactionCase: Each test runs in a transaction that is rolled back after. SingleTransactionCase: All tests in the class run in one transaction. HttpCase: Used for UI/Web tests using a headless browser.
Use the --test-tags parameter: ./odoo-bin -d db_name -i module_name --test-tags /module_name --stop-after-init.
Use the self.assertQueryCount() helper to ensure a specific logic doesn't exceed a defined number of SQL queries (preventing N+1).
Using Python's unittest.mock to simulate external API responses or system calls (like time.now) without making actual requests.
Use HttpCase and the browser_js method to trigger an OWL tour defined in the 'tours' registry.
at_install: Runs immediately after the module is installed. post_install: Runs after ALL modules in the dependency chain are installed (preferred for cross-module logic).
A modern RESTful API that uses JSON-RPC 2.0. It supports 'Bearer Token' authentication and clean URL endpoints at /json/2/.
Generate an 'API Key' for the user in Odoo, and send it in the HTTP header: 'Authorization: bearer YOUR_KEY'.
The method must be decorated with @api.model or take record IDs as the first argument, and is called via /json/2/<model>/<method>.
Yes, the API structure is part of the core Odoo framework, though some Enterprise-only models won't be available.
JSON-2 is faster, uses standard JSON formatting, supports modern Bearer auth, and provides better error messages than the old XML-RPC protocol.
1. Define an ir.actions.report record. 2. Create a QWeb template. 3. Optionally create a custom 'Report Model' if you need complex data processing before rendering.
Use t-inherit on the 'sale.report_saleorder_document' template and use <xpath> to inject your field inside the desired <div> or <td>.
The system-level library Odoo uses to convert HTML/QWeb templates into high-quality PDF documents. Version 0.12.5 (with patched qt) is the recommended standard.
Models: dot.notation (sale.order). Fields: snake_case (partner_id). Methods: snake_case (action_confirm). Private methods: _prefix (_get_default_val).
Record IDs: model_name_purpose (sale_order_view_form). Use 'oe_highlight' for primary buttons and 'oe_link' for secondary actions.
models/, views/, data/, security/, static/, wizard/, report/, and migrations/.
Use tags like [FIX], [ADD], [IMP], [REF], [REM] followed by the module name and a concise description of the change.
It prevents Odoo from overwriting the record during module updates, allowing users to modify the data (like email templates or workflows) without losing changes.
pre-migrate (runs before code update, uses SQL), post-migrate (runs after code update, uses ORM), and end-migrate (runs after all modules are updated).
Use cr.execute('ALTER TABLE table_name RENAME COLUMN old TO new').
Use the api.Environment(cr, SUPERUSER_ID, {}) to fetch and update records safely.
It checks the 'migrations/' folder for subfolders matching the version number in the __manifest__.py (e.g., migrations/19.0.1.1/).
An OCA-led open-source project that provides migration scripts for moving between major Odoo versions (e.g., 17.0 to 18.0).
1. Add a company_id field. 2. Create an ir.rule with ['|', ('company_id', '=', False), ('company_id', 'in', company_ids)]. 3. Set a proper default company.
company_id: The field on the record. company_ids: The list of ALL companies the user has active access to in their current session.
Set the company_id field to False (NULL) and ensure the record rule allows ('company_id', '=', False).
env.company: The single active company in the header. env.companies: All companies the user has checked in the company switcher.
Create two companies and a user with access to only one. Use with_user() or with_company() to verify search results are filtered correctly.
Next
We run technical assessment for Odoo hires, and we take on the work these questions describe.