Odoo 18.0 Developer

https://www.odoo.com/documentation/18.0/developer
Admin
Odoo is an open-source enterprise resource planning (ERP) platform that provides integrated business...
Tokens:286,368
Snippets:3,409
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Run Odoo with Custom Theme Module Installation

Source: https://www.odoo.com/documentation/18.0/developer/tutorials/website_theme/01_theming.html

Use this command to start the Odoo server, specifying addon paths, database filter, and installing a custom theme module like 'website_airproof' with development XML enabled.

```bash
./odoo-bin --addons-path=../enterprise,addons,../myprojects --db-filter=theming -d theming
--without-demo=all -i website_airproof --dev=xml
```

--------------------------------

### Run Odoo Server with Configuration

Source: https://www.odoo.com/documentation/18.0/developer/howtos/website_themes/setup.html

Example shell script command to launch the Odoo server with specified addon paths, database filters, initial module installation, and development features.

```bash
./odoo-bin --addons-path=../enterprise,addons --db-filter=<database> -d <database> --without-demo=all -i website --dev=xml
```

--------------------------------

### Install Upgrade Utils via pip

Source: https://www.odoo.com/documentation/18.0/developer/reference/upgrades/upgrade_utils.html

Install the upgrade-util library directly from the GitHub repository using pip.

```bash
$ python3 -m pip install git+https://github.com/odoo/upgrade-util@master
```

--------------------------------

### Example Odoo Unit Test Class with setUpClass

Source: https://www.odoo.com/documentation/18.0/developer/tutorials/unit_tests.html

Defines an Odoo unit test class inheriting from `TransactionCase`, demonstrating `setUpClass` for shared data setup and example test methods for property actions and computations.

```python
from odoo.tests.common import TransactionCase
from odoo.exceptions import UserError
from odoo.tests import tagged

# The CI will run these tests after all the modules are installed,
# not right after installing the one defining it.
@tagged('post_install', '-at_install')
class EstateTestCase(TransactionCase):

    @classmethod
    def setUpClass(cls):
        # add env on cls and many other things
        super(EstateTestCase, cls).setUpClass()

        # create the data for each tests. By doing it in the setUpClass instead
        # of in a setUp or in each test case, we reduce the testing time and
        # the duplication of code.
        cls.properties = cls.env['estate.property'].create([...])

    def test_creation_area(self):
        """Test that the total_area is computed like it should."""
        self.properties.living_area = 20
        self.assertRecordValues(self.properties, [
           {'name': ..., 'total_area': ...},
           {'name': ..., 'total_area': ...}
        ])


    def test_action_sell(self):
        """Test that everything behaves like it should when selling a property."""
        self.properties.action_sold()
        self.assertRecordValues(self.properties, [
           {'name': ..., 'state': ...},
           {'name': ..., 'state': ...}
        ])

        with self.assertRaises(UserError):
            self.properties.forbidden_action_on_sold_property()

```

--------------------------------

### Initialize Dashboard Items in Setup Method

Source: https://www.odoo.com/documentation/18.0/developer/tutorials/discover_js_framework/02_build_a_dashboard.html

Assigns a list of dashboard items to the component's `this.items` property within the `setup` method, making them available for rendering in the template.

```javascript
setup() {
   this.items = items;
}
```

--------------------------------

### Start Odoo with Upgrade Path

Source: https://www.odoo.com/documentation/18.0/developer/reference/upgrades/upgrade_utils.html

Prepend the upgrade-util source directory to the Odoo upgrade path when running locally.

```bash
$ ./odoo-bin --upgrade-path=/path/to/upgrade-util/src,/path/to/other/upgrade/script/directory [...]
```

--------------------------------

### Example ir.model.access.csv Entry

Source: https://www.odoo.com/documentation/18.0/developer/tutorials/server_framework_101/04_securityintro.html

This example shows how to define an access right in `ir.model.access.csv` for `test_model`, granting read permission to `base.group_user`.

```csv
id,name,model_id/id,group_id/id,perm_read,perm_write,perm_create,perm_unlink
access_test_model,access_test_model,model_test_model,base.group_user,1,0,0,0
```

--------------------------------

### Patching an Owl Component's `setup` Method

Source: https://www.odoo.com/documentation/18.0/developer/reference/frontend/patching_code.html

For Owl components, patch the `setup` method on the component's prototype to add custom hooks or initialization logic, leveraging the recommended best practice.

```javascript
patch(MyComponent.prototype, {
  setup() {
    useMyHook();
  },
});
```

--------------------------------

### Registering a test tour in Javascript

Source: https://www.odoo.com/documentation/18.0/developer/reference/backend/testing.html

Set up an integration test tour by registering it with a starting URL and a sequence of steps.

```javascript
import tour from 'web_tour.tour';
tour.register('rental_product_configurator_tour', {
    url: '/web',  // Here, you can specify any other starting url
}, [
    // Your sequence of steps
]);

```

--------------------------------

### Define Odoo Unit Tests with `at_install` and `post_install` Tags

Source: https://www.odoo.com/documentation/18.0/developer/tutorials/unit_tests.html

Use `at_install` for tests whose behavior might be affected by the installation of other modules. Employ `post_install` to run tests after all modules are installed, which can optimize CI execution time.

```python
from odoo.tests.common import TransactionCase
from odoo.tests import tagged

# The CI will run these tests after all the modules are installed,
# not right after installing the one defining it.
@tagged('post_install', '-at_install')  # add `post_install` and remove `at_install`
class PostInstallTestCase(TransactionCase):
    def test_01(self):
        ...

@tagged('at_install')  # this is the default
class AtInstallTestCase(TransactionCase):
    def test_01(self):
        ...
```

--------------------------------

### Example Upgrade Script Execution Order

Source: https://www.odoo.com/documentation/18.0/developer/reference/upgrades/upgrade_scripts.html

This list illustrates the lexical order in which upgrade scripts are executed within each phase (pre, post, end) for a given module and version.

```text
pre-10-do_something.py
pre-20-something_else.py
post-do_something.py
post-something.py
end-01-migrate.py
end-migrate.py
```

--------------------------------

### Defining a Class Initializer

Source: https://www.odoo.com/documentation/18.0/developer/tutorials/web.html

Use the `init` method as a constructor to perform setup tasks and assign instance variables when instantiating with `new`.

```javascript
var MyClass = instance.web.Class.extend({
    init: function(name) {
        this.name = name;
    },
    say_hello: function() {
        console.log("hello", this.name);
    },
});

var my_object = new MyClass("Bob");
my_object.say_hello();
// print "hello Bob" in the console
```

--------------------------------

### Server version response

Source: https://www.odoo.com/documentation/18.0/developer/reference/external_api.html

Example JSON response returned by the version endpoint.

```json
{
    "server_version": "13.0",
    "server_version_info": [13, 0, 0, "final", 0],
    "server_serie": "13.0",
    "protocol_version": 1,
}

```

--------------------------------

### Native JavaScript Module with Import/Export

Source: https://www.odoo.com/documentation/18.0/developer/reference/frontend/javascript_modules.html

This example demonstrates a native JavaScript module using standard `import` and `export` syntax, typically located in `web/static/src`.

```javascript
import { someFunction } from "./file_b";

export function otherFunction(val) {
    return someFunction(val + 3);
}
```

--------------------------------

### Combining Domains with Static Methods

Source: https://www.odoo.com/documentation/18.0/developer/reference/frontend/framework_overview.html

Examples of using the `Domain` class's static methods (`and`, `or`, `not`, `combine`) to logically combine multiple domain representations.

```javascript
// ["&", ("a", "=", 1), ("uid", "<=", uid)]
Domain.and([[["a", "=", 1]], "[('uid', '<=', uid)]"]).toString();

// ["|", ("a", "=", 1), ("uid", "<=", uid)]
Domain.or([[["a", "=", 1]], "[('uid', '<=', uid)]"]).toString();

// ["!", ("a", "=", 1)]
Domain.not([["a", "=", 1]]).toString();

// ["&", ("a", "=", 1), ("uid", "<=", uid)]
Domain.combine([[["a", "=", 1]], "[('uid', '<=', uid)]"], "AND").toString();
```

--------------------------------

### Interact with Odoo using XML-RPC in Python

Source: https://www.odoo.com/documentation/18.0/developer/howtos/web_services.html

This Python 3 example demonstrates how to log in to an Odoo server and create a new note record using the `xmlrpc.client` library.

```python
import xmlrpc.client

root = 'http://%s:%d/xmlrpc/' % (HOST, PORT)

uid = xmlrpc.client.ServerProxy(root + 'common').login(DB, USER, PASS)
print("Logged in as %s (uid: %d)" % (USER, uid))

# Create a new note
sock = xmlrpc.client.ServerProxy(root + 'object')
args = {
    'color' : 8,
    'memo' : 'This is a note',
    'create_uid': uid,
}
note_id = sock.execute(DB, uid, PASS, 'note.note', 'create', args)

```

--------------------------------

### Configure Default Record Ordering

Source: https://www.odoo.com/documentation/18.0/developer/reference/user_interface/view_architectures.html

Example of using the default_order attribute to sort records by sequence and name in descending order.

```xml
<list default_order="sequence,name desc">
    ...
</list>
```

--------------------------------

### Verbose Utility Classes in Qweb

Source: https://www.odoo.com/documentation/18.0/developer/howtos/scss_tips.html

This example demonstrates a common issue where utility classes, especially when combined with conditional logic, can lead to reduced readability in Qweb templates.

```xml
<myComponent t-attf-class="d-flex border px-lg-2 card
{{props.readonly ? 'o_myComponent_disabled' : ''}}
card d-lg-block position-absolute {{props.active ?
'o_myComponent_active' : ''}}  myComponent px-3"/>
```

--------------------------------

### Defining and Registering a Custom Sepia Effect

Source: https://www.odoo.com/documentation/18.0/developer/reference/frontend/services.html

This example demonstrates how to create an Owl component for a custom visual effect and register it with the effect service, making it available for use.

```javascript
import { registry } from "@web/core/registry";
import { Component, xml } from "@odoo/owl";

class SepiaEffect extends Component {
  static template = xml`
    <div style="
        position: absolute;
        left: 0;
        top: 0;
        width: 100%;
        height: 100%;
        pointer-events: none;
        background: rgba(124,87,0, 0.4);
    "></div>
  `;
}

export function sepiaEffectProvider(env, params = {}) {
    return {
        Component: SepiaEffect,
    };
}

const effectRegistry = registry.category("effects");
effectRegistry.add("sepia", sepiaEffectProvider);
```

--------------------------------

### Verify `estate_property` Table Creation with psql

Source: https://www.odoo.com/documentation/18.0/developer/tutorials/getting_started/04_basicmodel.html

Use this psql command to connect to the `rd-demo` database and verify if the `estate_property` table has been created and is currently empty after a module installation or upgrade.

```bash
$ psql -d rd-demo
rd-demo=# SELECT COUNT(*) FROM estate_property;
count
-------
    0
(1 row)

```

--------------------------------

### Registering a Custom Service with Dependencies in Odoo

Source: https://www.odoo.com/documentation/18.0/developer/reference/frontend/framework_overview.html

This example shows how to define and register a new service that depends on the 'notification' service, periodically displaying a message.

```javascript
import { registry } from "./core/registry";

const serviceRegistry = registry.category("services");

const myService = {
    dependencies: ["notification"],
    start(env, { notification }) {
        let counter = 1;
        setInterval(() => {
            notification.add(`Tick Tock ${counter++}`);
        }, 5000);
    }
};

serviceRegistry.add("myService", myService);
```

--------------------------------

### Defining a Settings View in Odoo XML

Source: https://www.odoo.com/documentation/18.0/developer/reference/user_interface/view_architectures.html

An example of a settings view customization of the form view, featuring app, block, and setting elements.

```xml
<app string="CRM" name="crm">
    <setting type="header" string="Foo">
        <field name="foo" title="Foo?."/>
        <button name="nameAction" type="object" string="Button"/>
    </setting>
    <block title="Title of group Bar">
        <setting help="this is bar" documentation="/applications/technical/web/settings/this_is_a_test.html">
            <field name="bar"/>
        </setting>
        <setting string="This is Big BAR" company_specific="1">
            <field name="bar"/>
        </setting>
    </block>
    <block title="Title of group Foo">
        <setting string="Personalize setting" help="this is full personalize setting">
            <div>This is a different setting</div>
        </setting>
    </block>
</app>
```

--------------------------------

### Verify upgrade flow using UpgradeCase

Source: https://www.odoo.com/documentation/18.0/developer/reference/upgrades/upgrade_utils.html

Implement prepare to set up data and check to assert expectations after the upgrade. The return value of prepare must be JSON-serializable and is passed to check.

```python
from odoo.upgrade.testing import UpgradeCase, change_version


class DeactivateBobUsers(UpgradeCase):

    def prepare(self):
        u = self.env["res.users"].create({"login": "bob", "name": "Bob"})
        return u.id  # will be passed to check

    def check(self, uid):  # uid is the value returned by prepare
        self.env.cr.execute(
            "SELECT * FROM res_users WHERE id=%s AND NOT active", [uid]
        )
        self.assertEqual(self.env.cr.rowcount, 1)
```

--------------------------------

### Conditional Field Attributes

Source: https://www.odoo.com/documentation/18.0/developer/reference/user_interface/view_architectures.html

Examples of applying conditional logic to field attributes such as readonly, required, and invisible using Python expressions.

```xml
<field name="fname_a" readonly="True"/>
<field name="fname_b" readonly="name_a in [fname_b, parent.fname_d]"/>
```

```xml
<field name="fname_a" required="True"/>
<field name="fname_b" required="fname_c != 3"/>
```

```xml
<field name="fname_b" invisible="fname_c != 3 and fname_a == parent.fname_d"/>
<group invisible="fname_c != 4">
    <field name="fname_c"/>
    <field name="fname_d"/>
<group>
```

--------------------------------

### Tagging Odoo Tests with @tagged

Source: https://www.odoo.com/documentation/18.0/developer/reference/backend/testing.html

Use the @tagged decorator to control when tests run. For example, use '-at_install' and 'post_install' to run tests only after all modules are installed.

```python
# coding: utf-8
from odoo.tests import HttpCase, tagged

# This test should only be executed after all modules have been installed.
@tagged('-at_install', 'post_install')
class WebsiteVisitorTests(HttpCase):
  def test_create_visitor_on_tracked_page(self):
      Page = self.env['website.page']
```

--------------------------------

### Writing a TransactionCase Test

Source: https://www.odoo.com/documentation/18.0/developer/reference/backend/testing.html

The most common test setup in Odoo. Test methods must start with 'test_' and run inside a single transaction that is rolled back after each test.

```python
class TestModelA(TransactionCase):
    def test_some_action(self):
        record = self.env['model.a'].create({'field': 'value'})
        record.some_action()
        self.assertEqual(
            record.field,
            expected_field_value)

    # other tests...
```

--------------------------------

### Disable demo data loading via command line

Source: https://www.odoo.com/documentation/18.0/developer/tutorials/define_module_data.html

Use the --without-demo option when starting the Odoo server to prevent demo data from being loaded during module installation.

```bash
$ ./odoo-bin -h
Usage: odoo-bin [options]

Options:
--version             show program's version number and exit
-h, --help            show this help message and exit

Common options:
  [...]
  --without-demo=WITHOUT_DEMO
                      disable loading demo data for modules to be installed
                      (comma-separated, use "all" for all modules). Requires
                      -d and -i. Default is none
[...]

$ ./odoo-bin --addons-path=... -d db -i account --without-demo=all

```

--------------------------------

### Display Odoo-bin Help Options

Source: https://www.odoo.com/documentation/18.0/developer/tutorials/unit_tests.html

Use this command to view all available options for the `odoo-bin` command-line tool, including testing configurations.

```bash
$ odoo-bin -h
Usage: odoo-bin [options]

Options:
--version             show program's version number and exit
-h, --help            show this help message and exit

[...]

Testing Configuration:
  --test-file=TEST_FILE
                      Launch a python test file.
  --test-enable       Enable unit tests.
  --test-tags=TEST_TAGS
                      Comma-separated list of specs to filter which tests to
                      execute. Enable unit tests if set. A filter spec has
                      the format: [-][tag][/module][:class][.method] The '-'
                      specifies if we want to include or exclude tests
                      matching this spec. The tag will match tags added on a
                      class with a @tagged decorator (all Test classes have
                      'standard' and 'at_install' tags until explicitly
                      removed, see the decorator documentation). '*' will
                      match all tags. If tag is omitted on include mode, its
                      value is 'standard'. If tag is omitted on exclude
                      mode, its value is '*'. The module, class, and method
                      will respectively match the module name, test class
                      name and test method name. Example: --test-tags
                      :TestClass.test_func,/test_module,external  Filtering
                      and executing the tests happens twice: right after
                      each module installation/update and at the end of the
                      modules loading. At each stage tests are filtered by
                      --test-tags specs and additionally by dynamic specs
                      'at_install' and 'post_install' correspondingly.
  --screencasts=DIR   Screencasts will go in DIR/{db_name}/screencasts.
  --screenshots=DIR   Screenshots will go in DIR/{db_name}/screenshots.
                      Defaults to /tmp/odoo_tests.
```

--------------------------------

### Accessing DOM elements with useRef and onMounted

Source: https://www.odoo.com/documentation/18.0/developer/tutorials/discover_js_framework/01_owl_components.html

Call useRef in the setup method to get a reference object. The actual DOM element is accessible via the 'el' property once the component is mounted.

```javascript
setup() {
   this.myRef = useRef('some_name');
   onMounted(() => {
      console.log(this.myRef.el);
   });
}
```

--------------------------------

### Launch Odoo Server with odoo-bin

Source: https://www.odoo.com/documentation/18.0/developer/tutorials/setup_guide.html

Run the Odoo server from the command line specifying the addons path and target database.

```bash
$ cd $HOME/src/odoo/
$ ./odoo-bin --addons-path="addons/,../enterprise/,../tutorials" -d rd-demo

```

--------------------------------

### Basic Registry Initialization and Usage in JavaScript

Source: https://www.odoo.com/documentation/18.0/developer/reference/frontend/registries.html

This snippet demonstrates how to create a new registry instance, add a key-value pair, and retrieve a value using its key.

```javascript
import { Registry } from "@web/core/registry";

const myRegistry = new Registry();

myRegistry.add("hello", "odoo");

console.log(myRegistry.get("hello"));

```

--------------------------------

### Deploy a module remotely

Source: https://www.odoo.com/documentation/18.0/developer/reference/cli.html

Uploads and installs a local module to a remote Odoo instance. Requires the base_import_module to be installed on the target server.

```bash
$ odoo-bin deploy <path> <url> --db <dbname> --login <login> --password <password>

```

--------------------------------

### Correct and Incorrect Owl Component Initialization

Source: https://www.odoo.com/documentation/18.0/developer/reference/frontend/owl_components.html

This snippet illustrates the best practice for initializing Owl components in Odoo by using the `setup` method, and explicitly warns against using the `constructor` method directly.

```javascript
// correct:
class MyComponent extends Component {
    setup() {
        // initialize component here
    }
}

// incorrect. Do not do that!
class IncorrectComponent extends Component {
    constructor(parent, props) {
        // initialize component here
    }
}
```

--------------------------------

### async get(route, [readMethod = "json"])

Source: https://www.odoo.com/documentation/18.0/developer/reference/frontend/services.html

Sends a GET request to the specified URL. The response content type can be customized.

```APIDOC
## get(route, [readMethod = "json"])

### Description
Sends a GET request to the specified URL. The response content type can be customized.

### Parameters
#### Method Parameters
- **route** (string) - Required - The URL to send the request to.
- **readMethod** (string) - Optional - The response content type. Can be "text", "json", "formData", "blob", "arrayBuffer". Defaults to "json".

### Returns
The result of the request with the format defined by the `readMethod` argument.

### Request Example
```javascript
const httpService = useService("http");
const data = await httpService.get("https://something.com/posts/1");
```
```

--------------------------------

### Define Date Range with Start Date Field

Source: https://www.odoo.com/documentation/18.0/developer/reference/frontend/javascript_reference.html

Configure a `daterange` widget to use a separate field for its start date value. This option cannot be used with `end_date_field`.

```xml
<field name="end_date" widget="daterange" options="{'start_date_field': 'start_date'}" />
```

--------------------------------

### Define a basic Owl component template in XML

Source: https://www.odoo.com/documentation/18.0/developer/howtos/standalone_owl_application.html

This XML snippet defines a simple QWeb template for the root component, rendering a 'Hello, World!' message. It should be placed in `your_module/static/src/standalone_app/root.xml`.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<templates xml:space="preserve">
    <t t-name="your_module.Root">
        Hello, World!
    </t>
</templates>
```

--------------------------------

### Define a Map View in Odoo XML

Source: https://www.odoo.com/documentation/18.0/developer/reference/user_interface/view_architectures.html

Configure a map view to display records on a map using a partner field for localization. This example enables routing and hides the partner name in the popup.

```xml
<map res_partner="partner_id" default_order="date_begin" routing="1" hide_name="1">
    <field name="partner_id" string="Customer Name"/>
</map>

```

--------------------------------

### Differentiating Public and Private Methods in Odoo Models

Source: https://www.odoo.com/documentation/18.0/developer/reference/backend/security.html

Public methods (not starting with '_') can be called via RPC and their arguments cannot be trusted. Private methods (starting with '_') are only callable from other Python methods.

```python
# this method is public and its arguments can not be trusted
def action_done(self):
    if self.state == "draft" and self.env.user.has_group('base.manager'):
        self._set_state("done")

# this method is private and can only be called from other python methods
def _set_state(self, new_state):
    self.sudo().write({"state": new_state})
```

--------------------------------

### Running Upgrade Tests via Command Line

Source: https://www.odoo.com/documentation/18.0/developer/reference/upgrades/upgrade_utils.html

Execute the three-step process to prepare test data, upgrade modules, and verify the upgraded data using `odoo-bin`.

```bash
$ ~/odoo/$version/odoo-bin -d DB --test-tags=$prepare_test_tag \
  --upgrade-path=~/upgrade-util/src,~/myupgrades \
  --addons=~/odoo/$version/addons,~/enterprise/$version,~/mymodules --stop
```

```bash
$ ~/odoo/$version/odoo-bin -d DB -u mymodule1,mymodule2 \
  --upgrade-path=~/upgrade-util/src,~/myupgrades \
  --addons=~/odoo/$version/addons,~/enterprise/$version,~/mymodules --stop
```

```bash
$ ~/odoo/$version/odoo-bin -d DB --test-tags=$check_test_tag \
  --upgrade-path=~/upgrade-util/src,~/myupgrades \
  --addons=~/odoo/$version/addons,~/enterprise/$version,~/mymodules --stop
```

--------------------------------

### Workaround for Patching Class Constructors

Source: https://www.odoo.com/documentation/18.0/developer/reference/frontend/patching_code.html

Since class constructors cannot be directly patched, define a `setup` method in the constructor and patch `setup` on the prototype instead to extend initialization logic.

```javascript
class MyClass {
  constructor() {
    this.setup();
  }
  setup() {
    this.number = 1;
  }
}

patch(MyClass.prototype, {
  setup() {
    super.setup(...arguments);
    this.doubleNumber = this.number * 2;
  },
});
```

--------------------------------

### Force new rows in group layouts using newline elements

Source: https://www.odoo.com/documentation/18.0/developer/reference/user_interface/view_architectures.html

Use newline within group elements to end the current row early and start a new row immediately.

```xml
<form>
    <group>
        ...
        <newline/>
        ...
    </group>
</form>

```

```xml
<form>
    <group string="Title 1">
        <group string="Title 1.1">...</group>
        <newline/>
        <group string="Title 1.2">...</group>
        <group string="Title 1.3">...</group>
    </group>
</form>

```

--------------------------------

### XPath Example: Adding Content Before Header in Odoo

Source: https://www.odoo.com/documentation/18.0/developer/howtos/website_themes/layout.html

This example demonstrates how to use XPath to insert content immediately before the `<header>` element of the `website.layout` template, effectively adding a welcome message.

```xml
<template id="layout" inherit_id="website.layout" name="Welcome Message">
   <xpath expr="//header" position="before">
      <!-- Content -->
   </xpath>
</template>
```

--------------------------------

### Mount the standalone Owl application to the DOM

Source: https://www.odoo.com/documentation/18.0/developer/howtos/standalone_owl_application.html

This JavaScript file handles the application's startup, ensuring the `Root` component is mounted to the document body once Owl is ready. Place this code in `your_module/static/src/standalone_app/app.js`.

```javascript
import { whenReady } from "@odoo/owl";
import { mountComponent } from "@web/env";
import { Root } from "./root";

whenReady(() => mountComponent(Root, document.body));
```

--------------------------------

### Instantiate and Use Inherited Models (Python)

Source: https://www.odoo.com/documentation/18.0/developer/reference/backend/orm.html

Shows how to create records for both the base and inherited models and call their methods, illustrating method overriding behavior.

```python
a = env['inheritance.0'].create({'name': 'A'})
b = env['inheritance.1'].create({'name': 'B'})

a.call()
b.call()
```

--------------------------------

### HTTP Service: Making GET and POST Requests

Source: https://www.odoo.com/documentation/18.0/developer/reference/frontend/services.html

Use this snippet to perform asynchronous GET and POST requests using the `http` service. It demonstrates fetching data and sending new data to an endpoint.

```javascript
const httpService = useService("http");
const data = await httpService.get("https://something.com/posts/1");
// ...
await httpService.post("https://something.com/posts/1", { title: "new title", content: "new content" });
```

--------------------------------

### Configure Odoo using a configuration file

Source: https://www.odoo.com/documentation/18.0/developer/reference/cli.html

Sample configuration file options under the [options] section. Use this file to persist command-line options.

```ini
[options]
db_user=odoo
dbfilter=odoo

```

--------------------------------

### Implementing and Registering an Odoo Service in JavaScript

Source: https://www.odoo.com/documentation/18.0/developer/reference/frontend/javascript_reference.html

This example shows how to define and register a new service, like the ORM service, making it available throughout the application. Services are created at startup and persist for the application's lifetime.

```javascript
import { registry } from "@web/core/registry";
export const OrmService = {
    start() {
        return {
            read(...) { ... },
            write(...) { ... },
            unlink(...) { ... },
            ...
        }
    },
};
registry.category("services").add("orm", OrmService);
```

--------------------------------

### force_upgrade_of_fresh_module

Source: https://www.odoo.com/documentation/18.0/developer/reference/upgrades/upgrade_utils.html

Force the execution of upgrade scripts for a module that is being installed.

```APIDOC
## force_upgrade_of_fresh_module

### Description
Force the execution of upgrade scripts for a module that is being installed. Standard Odoo doesn’t run upgrade scripts when a module is being installed. This is useful when a (new) module needs to perform some operations for it to be correctly installed, like grabbing data from another module.

### Signature
```python
force_upgrade_of_fresh_module(cr, module, init=True)
```

### Parameters
- **cr** - Database cursor
- **module** (str) - Name of the module for which to force the execution of upgrade scripts.
- **init** (bool) - Whether to set the module to be in *init* mode. Being in init mode has the side effect of not respecting noupdate flags, in XML file nor in `ir_model_data`.
```

--------------------------------

### Configure Form to Create Customer (HTML)

Source: https://www.odoo.com/documentation/18.0/developer/howtos/website_themes/forms.html

Configure the form to create a new customer record by setting `data-model_name` to `res.partner`.

```HTML
<form data-model_name="res.partner">
```

--------------------------------

### Define a Minimal Property Offers Report Template (XML/QWeb)

Source: https://www.odoo.com/documentation/18.0/developer/tutorials/pdf_reports.html

Use this QWeb template to create a basic PDF report for property offers, displaying property name, expected price, and a table of offers. It leverages Bootstrap classes for styling and QWeb directives for data iteration.

```xml
<?xml version="1.0" encoding="UTF-8" ?>
<odoo>
    <template id="report_property_offers">
        <t t-foreach="docs" t-as="property">
            <t t-call="web.html_container">
                <t t-call="web.external_layout">
                    <div class="page">
                        <h2>
                            <span t-field="property.name"/>
                        </h2>
                        <div>
                            <strong>Expected Price: </strong>
                            <span t-field="property.expected_price"/>
                        </div>
                        <table class="table">
                            <thead>
                                <tr>
                                    <th>Price</th>
                                </tr>
                            </thead>
                            <tbody>
                                <t t-set="offers" t-value="property.mapped('offer_ids')"/>
                                <tr t-foreach="offers" t-as="offer">
                                    <td>
                                        <span t-field="offer.price"/>
                                    </td>
                                </tr>
                            </tbody>
                        </table>
                    </div>
                </t>
            </t>
        </t>
    </template>
</odoo>
```

--------------------------------

### module_installed(cr, module)

Source: https://www.odoo.com/documentation/18.0/developer/reference/upgrades/upgrade_utils.html

Checks whether a single specified module is installed.

```APIDOC
## module_installed(cr, module)

### Description
Return whether a single module is installed. In the context of upgrades, a module is considered installed if it is marked for upgrade or installation, even if not yet fully installed.

### Signature
```python
module_installed(cr, module)
```

### Parameters
- **cr** (cursor) - The database cursor.
- **module** (str) - Name of the module to check.

### Returns
- **bool** - `True` if the module is installed, `False` otherwise.
```

--------------------------------

### modules_installed(cr, *modules)

Source: https://www.odoo.com/documentation/18.0/developer/reference/upgrades/upgrade_utils.html

Checks whether all of the specified modules are installed (or marked for upgrade/installation).

```APIDOC
## modules_installed(cr, *modules)

### Description
Return whether *all* given modules are installed. In the context of upgrades, a module is considered installed if it is marked for upgrade or installation, even if not yet fully installed.

### Signature
```python
modules_installed(cr, *modules)
```

### Parameters
- **cr** (cursor) - The database cursor.
- ***modules** (str) - One or more module names to check (variadic).

### Returns
- **bool** - `True` if all specified modules are installed, `False` otherwise.
```

--------------------------------

### force_install_module(cr, module, if_installed=None, reason='it has been explicitly asked for')

Source: https://www.odoo.com/documentation/18.0/developer/reference/upgrades/upgrade_utils.html

Forces the ORM to install a specified module.

```APIDOC
## force_install_module(cr, module, if_installed=None, reason='it has been explicitly asked for')

### Description
Force the ORM to install a module.

### Signature
```python
force_install_module(cr, module, if_installed=None, reason='it has been explicitly asked for')
```

### Parameters
- **cr** (cursor) - The database cursor.
- **module** (str) - Name of the module to install.
- **if_installed** (list of str or None) - Optional. Only force the install when these modules are already installed.
- **reason** (str) - Optional. Reason for forcing installation. Defaults to `'it has been explicitly asked for'`.

### Returns
- **str** - The *new* state of the module.
```

--------------------------------

### Define Custom Kanban View Template in XML

Source: https://www.odoo.com/documentation/18.0/developer/howtos/javascript_view.html

This XML snippet defines a new QWeb template `my_module.CustomKanbanView` that inherits from `web.KanbanView` and inserts a 'Hello world !' div before the `Layout` component.

```xml
<?xml version="1.0" encoding="UTF-8" ?>
<templates>
    <t t-name="my_module.CustomKanbanView" t-inherit="web.KanbanView">
        <xpath expr="//Layout" position="before">
            <div>
                Hello world !
            </div>
        </xpath>
    </t>
</templates>
```

--------------------------------

### Launch the Odoo interactive shell

Source: https://www.odoo.com/documentation/18.0/developer/reference/cli.html

Start Odoo in a Python console environment to interact directly with the ORM.

```bash
$ odoo-bin shell

```

--------------------------------

### Start Odoo Server

Source: https://www.odoo.com/documentation/18.0/developer/tutorials/backend.html

Invokes the Odoo server from the shell. The server can be stopped by hitting Ctrl-C twice.

```bash
odoo-bin
```

--------------------------------

### click(_target_[, _options_])

Source: https://www.odoo.com/documentation/18.0/developer/reference/frontend/unit_testing/hoot.html

Performs a click sequence on the given `Target`. The event sequence is as follows: `pointerdown`, [desktop] `mousedown`, [touch] `touchstart`, [target is not active element] `blur`, [target is focusable] `focus`, `pointerup`, [desktop] `mouseup`, [touch] `touchend`, `click`, `dblclick` if click is not prevented & current click count is even.

```APIDOC
## Function: `click(_target_[, _options_])`

### Description
Performs a click sequence on the given `Target`. The event sequence is as follows: `pointerdown`, [desktop] `mousedown`, [touch] `touchstart`, [target is not active element] `blur`, [target is focusable] `focus`, `pointerup`, [desktop] `mouseup`, [touch] `touchend`, `click`, `dblclick` if click is not prevented & current click count is even.

### Parameters
- **_target_** (Target) - Required - The element to click.
- **_options_** (Object) - Optional - Additional options for the click operation.

### Returns
`Promise<Event[]>` - A promise that resolves to an array of events triggered during the operation.

### Example
```javascript
click("button"); // Clicks on the first <button> element
```
```

--------------------------------

### POST https://demo.odoo.com/start

Source: https://www.odoo.com/documentation/18.0/developer/reference/external_api.html

Requests a test database from the Odoo demo service, returning connection details.

```APIDOC
## POST https://demo.odoo.com/start

### Description
Requests a test database from the Odoo demo service, returning connection details.

### Method
POST

### Endpoint
https://demo.odoo.com/start

### Parameters
None

### Response
#### Success Response (200)
- **host** (string) - The URL of the test database.
- **database** (string) - The name of the database.
- **user** (string) - The username.
- **password** (string) - The password.

#### Response Example
{
  "host": "https://demo.odoo.com",
  "database": "demo_db",
  "user": "admin",
  "password": "password"
}
```

--------------------------------

### is_changed(cr, xmlid, interval='1 minute')

Source: https://www.odoo.com/documentation/18.0/developer/reference/upgrades/upgrade_utils.html

Return whether a record was changed before the current upgrade start time.

```APIDOC
## is_changed(cr, xmlid, interval='1 minute')

### Description
Return whether a record was changed before the current upgrade start time. If the `xmlid` doesn't exist in the DB, this function returns `None`.

### Parameters
- **cr** - Database cursor
- **xmlid** (str) - `xmlid` of the record to check
- **interval** (str) - SQL interval, a record is considered as changed if `write_date > create_date + interval`

### Returns
- **bool or None** - True if changed, False if not, None if the record does not exist.
```

--------------------------------

### Mounting a Component with mountWithCleanup

Source: https://www.odoo.com/documentation/18.0/developer/reference/frontend/unit_testing/web_helpers.html

Use `mountWithCleanup` to easily instantiate and append components to the DOM. It internally prepares an `env` and ensures a `MockServer` is running.

```javascript
await mountWithCleanup(Checkbox, {
    props: {
        value: false
    },
});

```

--------------------------------

### Clone the Odoo Tutorials Repository

Source: https://www.odoo.com/documentation/18.0/developer/tutorials/setup_guide.html

Clones the official Odoo tutorials repository to your local machine.

```bash
$ git clone git@github.com:odoo/tutorials.git

```

--------------------------------

### Debug Python Code using ipdb

Source: https://www.odoo.com/documentation/18.0/developer/tutorials/setup_guide.html

Install ipdb and insert breakpoints into your Python code to inspect execution flow and state.

```bash
pip install ipdb

```

```python
import ipdb; ipdb.set_trace()

```

```python
def copy(self, default=None):
    import ipdb; ipdb.set_trace()
    self.ensure_one()
    chosen_name = default.get('name') if default else ''
    new_name = chosen_name or _('%s (copy)') % self.name
    default = dict(default or {}, name=new_name)
    return super(Partner, self).copy(default)

```

--------------------------------

### Prefetch Relational Fields and Secondary Records (Python)

Source: https://www.odoo.com/documentation/18.0/developer/reference/backend/orm.html

This example demonstrates how prefetching extends to relational fields, optimizing queries for related records (secondary records) by fetching them in bulk, reducing database calls for linked data.

```python
countries = set()
for partner in partners:
    country = partner.country_id        # first pass prefetches all partners
    countries.add(country.name)         # first pass prefetches all countries

```

--------------------------------

### Odoo Domain List and String Expressions

Source: https://www.odoo.com/documentation/18.0/developer/reference/frontend/framework_overview.html

Examples of how Odoo domains are represented in JavaScript, using both list-based conditions and string expressions.

```javascript
// list of conditions
[]
[["a", "=", 3]]
[["a", "=", 1], ["b", "=", 2], ["c", "=", 3]]
["&", "&", ["a", "=", 1], ["b", "=", 2], ["c", "=", 3]]
["&", "!", ["a", "=", 1], "|", ["a", "=", 2], ["a", "=", 3]]

// string expressions
"[('some_file', '>', a)]"
"[('date','>=', (context_today() - datetime.timedelta(days=30)).strftime('%Y-%m-%d'))]"
"[('date', '!=', False)]"
```

--------------------------------

### Creating a Nested File Dropdown Menu (OWL)

Source: https://www.odoo.com/documentation/18.0/developer/reference/frontend/owl_components.html

This example demonstrates how to create a nested dropdown menu, specifically a 'File' menu with 'New' sub-elements, by embedding Dropdown components within each other's content slots.

```xml
<Dropdown>
  <button>File</button>
  <t t-set-slot="content">
    <DropdownItem onSelected="() => this.onItemSelected('file-save')">Save</DropdownItem>
    <DropdownItem onSelected="() => this.onItemSelected('file-open')">Open</DropdownItem>

    <Dropdown>
      <button>New</button>
      <t t-set-slot="content">
        <DropdownItem onSelected="() => this.onItemSelected('file-new-document')">Document</DropdownItem>
        <DropdownItem onSelected="() => this.onItemSelected('file-new-spreadsheet')">Spreadsheet</DropdownItem>
      </t>
    </Dropdown>
  </t>
</Dropdown>
```

--------------------------------

### Using Widget Properties and Change Events

Source: https://www.odoo.com/documentation/18.0/developer/tutorials/web.html

Set and get widget properties, which automatically trigger change events that other widgets can observe.

```javascript
start: function() {
    this.widget = ...
    this.widget.on("change:name", this, this.name_changed);
    this.widget.set("name", "Nicolas");
},
name_changed: function() {
    console.log("The new value of the property 'name' is", this.widget.get("name"));
}
```

--------------------------------

### Example Upgrade Script Directory Structure

Source: https://www.odoo.com/documentation/18.0/developer/reference/upgrades/upgrade_scripts.html

This snippet illustrates the required directory structure for an Odoo upgrade script, showing a custom module `awesome_partner` with a migration script for version `17.0.2.0`.

```text
awesome_partner/
|-- migrations/
|   |-- 17.0.2.0/
|   |   |-- pre-exclamation.py
```

--------------------------------

### Creating a basic widget in Odoo

Source: https://www.odoo.com/documentation/18.0/developer/tutorials/web.html

Extend the base Widget class and override the start method to execute code when the widget is initialized.

```javascript
local.HomePage = instance.Widget.extend({
    start: function() {
        console.log("pet store home page loaded");
    },
});
```

--------------------------------

### Starting a Tour from a Python Test

Source: https://www.odoo.com/documentation/18.0/developer/reference/backend/testing.html

Use the HTTPCase class to programmatically trigger and run an Odoo tour from a Python test case.

```python
def test_your_test(self):
    # Optional Setup
    self.start_tour("/web", "your_tour_name", login="admin")
    # Optional verifications
```

--------------------------------

### Create and Read Records from Extended Model (Python)

Source: https://www.odoo.com/documentation/18.0/developer/reference/backend/orm.html

Demonstrates creating a record for an extended model and reading its fields, showing that new fields added via extension are present.

```python
record = env['extension.0'].create({})
record.read()[0]
```

--------------------------------

### Domain Class Instantiation and Record Matching

Source: https://www.odoo.com/documentation/18.0/developer/reference/frontend/framework_overview.html

Illustrates creating a `Domain` object, checking if a record satisfies its conditions using `contains()`, and converting a combined domain to a string.

```javascript
new Domain([["a", "=", 3]]).contains({ a: 3 }) // true

const domain = new Domain(["&", "&", ["a", "=", 1], ["b", "=", 2], ["c", "=", 3]]);
domain.contains({ a: 1, b: 2, c: 3 }); // true
domain.contains({ a: -1, b: 2, c: 3 }); // false

// next expression returns ["|", ("a", "=", 1), ("b", "<=", 3)]
Domain.or([[["a", "=", 1]], "[('b', '<=', 3)]"]).toString();
```
Tokens:
Raw