Odoo 19.0 Developer

https://www.odoo.com/documentation/19.0/developer
Admin
Odoo 19.0 Developer provides comprehensive documentation and resources for developers to extend,...
Tokens:302,229
Snippets:3,999
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install Custom Module via Script

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

This command installs your custom theme module and ensures it's applied to the specified database. Adjust the --addons-path and --db-filter as needed for your setup.

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

```

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

### Install Debugging Library

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

Install the ipdb library for interactive debugging.

```bash
pip install ipdb
```

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

### Install via pip

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

Install the library directly from the Git repository using pip.

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

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

### Patch Owl Component Setup Method

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

Illustrates patching the `setup` method of an Owl component to integrate custom hooks or logic. This follows the best practice of using `setup` for patchable extensions.

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

```

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

### Correct vs. Incorrect Component Setup Method

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

Illustrates the correct way to initialize an Owl component using the `setup` method, and warns against using the `constructor` 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
    }
}

```

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

### Describe Block Example

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

Demonstrates how to group tests within a suite using the `describe` function, allowing for setup and organization.

```javascript
import { describe, expect, test } from "@odoo/hoot";

describe("My first suite", () => {
    test("My first test", () => {
        expect(2 + 2).toBe(4);
    });
});
```

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

### Initialize a Database

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

Creates a new database and installs the base module.

```bash
$ odoo-bin db init <database>
```

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

### Start the Odoo Server

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

Invoke the odoo-bin command in the shell to start the Odoo server. Ensure the full path to the file is provided if necessary.

```bash
odoo-bin

```

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

### Querying Other Models via Environment

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

You can use the environment to query other models. This example shows how to get an empty recordset for 'res.partner' and then search for companies that are also customers.

```python
>>> self.env['res.partner']
res.partner()
>>> self.env['res.partner'].search([('is_company', '=', True), ('customer', '=', True)])
res.partner(7, 18, 12, 14, 17, 19, 8, 31, 26, 16, 13, 20, 30, 22, 29, 15, 23, 28, 74)
```

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

### Defining Post-Install and At-Install Tests

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

Demonstrates how to use the `tagged` decorator to specify when tests should run. 'post_install' tests run after all modules are installed, while 'at_install' (the default) run during module installation.

```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):
        ...
```

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

### Sample Odoo Configuration File

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

Example of the [options] section in an Odoo configuration file.

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

```

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

### Initialize class instances

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

Define an init method to perform setup logic when a class is instantiated.

```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
```

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

### Dashboard Component Setup

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

Initializes the `items` property within the dashboard component's setup method.

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

```

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

### Basic Test Example

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

A simple example demonstrating how to write a basic test case using the `test` function and the `expect` assertion.

```javascript
import { expect, test } from "@odoo/hoot";

test("My first test", () => {
    expect(2 + 2).toBe(4);
});
```

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

### Clone the Odoo Petstore Module

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

Use this command to download the example module for testing the web framework.

```bash
$ git clone http://github.com/odoo/petstore
```

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

### Complex group structure examples

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

Examples demonstrating nested groups, custom titles, and column span configurations.

```xml
<group>
    <field name="a" string="custom"/>
    <field name="b"/>
</group>
<group string="title 1">
    <group string="title 2">
        <field name="c"/>
        <field name="d"/>
    </group>
    <group>
        <field name="e"/>
        <field name="f"/>
        <field name="g"/>
    </group>
</group>
<group col="12">
    <group colspan="8">
        <field name="h"/>
    </group>
    <group colspan="4">
        <field name="i"/>
    </group>
</group>
```

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

### Configure a progressbar with colors and sum_field

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

Example of a fully configured progress bar with color mapping and a summary field.

```xml
<kanban>
    <progressbar field="activity_state"
                 colors="{'planned': 'success', 'today': 'warning', 'overdue': 'danger'}"
                 sum_field="expected_revenue"/>
    <templates>
        ...
    </templates>
</kanban>
```

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

### Patch Class Setup Method with Super

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

Provides a workaround for patching constructors by patching a method called within the constructor. Uses `super` to call the original `setup` method and extends its functionality.

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

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

```

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

### Run tests by tag

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

Command-line examples for filtering tests using the --test-tags option.

```bash
$ odoo-bin --test-tags nice
```

```bash
$ odoo-bin --test-tags nice,standard
```

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

### Start Tour in Python Test

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

Initiate a tour from a Python test class inheriting from HTTPCase.

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

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

### Field Widget Configuration

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

Example of configuring a field widget using the options attribute.

```xml
<field name="tag_ids" widget="many2many_tags" options="{'color_field': 'FIELD_NAME', 'no_quick_create': True}"/>
```

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

### Classical Inheritance: Usage Example

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

Demonstrates creating records from 'inheritance.0' and 'inheritance.1' and calling their respective 'call' methods.

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

a.call()
b.call()

```

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

### Example Debugger Usage

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

Demonstrates placing a breakpoint within a method to inspect execution flow.

```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)
```

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

### Run module-specific and complex tag combinations

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

Examples of running tests for specific modules or combined tag logic.

```bash
$ odoo-bin --test-tags /sale
```

```bash
$ odoo-bin --test-tags '/sale,-slow'
```

```bash
$ odoo-bin --test-tags '-standard, slow, /stock'
```

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

### Inspect Widget DOM Structure

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

Example of the resulting HTML structure after nesting widgets with custom classes.

```html
<div class="oe_petstore_homepage">
    <div>Hello dear Odoo user!</div>
    <div class="oe_petstore_greetings">
        <div>We are so happy to see you again in this menu!</div>
    </div>
</div>
```

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

### Define Tour Steps

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

Examples of defining tour steps using triggers, active conditions, and run actions.

```javascript
// First step
tour.stepUtils.showAppsMenuItem(),
// Second step
{
   trigger: '.o_app[data-menu-xmlid="your_module.maybe_your_module_menu_root"]',
   isActive: ['community'],  // Optional
   run: "click",
}, {
    // Third step
},
```

```javascript
{
    trigger: '.js_product:has(strong:contains(Chair floor protection)) .js_add',
    run: "click",
},
```

```javascript
{
    isActive: ["mobile", "enterprise"],
    content: "Click on Add a product link",
    trigger: 'a:contains("Add a product")',
    tooltipPosition: "bottom",
    async run(helpers) { //Exactly the same as run: "click"
      helpers.click();
    }
},
```

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

### Multiple Create Actions in Control

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

Example of adding multiple create buttons with specific contexts to a list view.

```xml
<list>
    <field name="name"/>
    <field name="amount"/>
    <field name="currency"/>
    <field name="tax_id"/>
    <control>
        <create string="Add an item"/>
        <create string="Add a section" context="{'default_type': 'section'}"/>
        <create string="Add a note" context="{'default_type': 'note'}"/>
    </control>
</list>
```

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

### Display Odoo command line help and demo data installation

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

Use the help flag to view available options and the --with-demo flag to include demonstration data when initializing a new database.

```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:
  [...]
  --with-demo         install demo data in new databases
[...]

$ ./odoo-bin --addons-path=... -d new-db -i base --with-demo
```

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

### Get Partner IDs (Python ORM)

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

Example of retrieving partner IDs using Odoo's internal Python ORM with context.

```python
Model = self.env["res.partner"].with_context({"lang": "en_US"})
records = Model.search([("name", "ilike", "%deco%"), ("is_company", "=", True)])
return json.dumps(records.ids)


```

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

### Business Trip Model with Alias Integration

Source: https://www.odoo.com/documentation/19.0/developer/reference/backend/mixins.html

Example of a Business Trip model inheriting 'mail.thread' and 'mail.alias.mixin', demonstrating the setup for alias integration.

```python
class BusinessTrip(models.Model):
    _name = 'business.trip'
    _inherit = ['mail.thread', 'mail.alias.mixin']
    _description = 'Business Trip'

    name = fields.Char(tracking=True)
    partner_id = fields.Many2one('res.partner', 'Responsible',
                                 tracking=True)
    guest_ids = fields.Many2many('res.partner', 'Participants')
    state = fields.Selection([('draft', 'New'), ('confirmed', 'Confirmed')],
                             tracking=True)
    expense_ids = fields.One2many('business.expense', 'trip_id', 'Expenses')
    alias_id = fields.Many2one('mail.alias', string='Alias', ondelete="restrict",
                               required=True)

    def _get_alias_model_name(self, vals):
    """ Specify the model that will get created when the alias receives a message """
        return 'business.expense'

    def _get_alias_values(self):
    """ Specify some default values that will be set in the alias at its creation """
        values = super(BusinessTrip, self)._get_alias_values()
        # alias_defaults holds a dictionary that will be written
        # to all records created by this alias
        #
        # in this case, we want all expense records sent to a trip alias
        # to be linked to the corresponding business trip

```

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

### Basic Owl Component Definition

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

Defines a simple Owl component with inline template, state management, and an event handler. This is useful for getting started with Owl.

```javascript
import { Component, xml, useState } from "@odoo/owl";

class MyComponent extends Component {
    static template = xml`
        <div t-on-click="increment">
            <t t-esc="state.value">
        </div>
    `;

    setup() {
        this.state = useState({ value: 1 });
    }

    increment() {
        this.state.value++;
    }
}

```

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

### Initialize and Render ColumnList

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

Demonstrates how to encapsulate column names and render them with aliases or formatting.

```python
>>> columns = ColumnList(["id", "field_Yx"], ["id", '"field_Yx"'])
```

```python
>>> list(columns)
['id', '"field_Yx"']
```

```python
>>> columns.using(alias="t").as_string(cr._obj)
'"t"."id", "t"."field_Yx"'
```

```python
>>> columns.using(leading_comma=True).as_string(cr._obj)
', "id", "field_Yx"'
```

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

### Get Start of Time Period

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

The `fields.Date.start_of()` method calculates the beginning of a specified period (year, month, week, etc.) from a given date or datetime object.

```python
fields.Date.start_of(value, granularity='month')
```

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

### Defining Constraints and Indexes in Odoo Models

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

Example of defining a CHECK constraint and a database index on model fields. The attribute names must start with an underscore to avoid clashes with field names.

```python
class AModel(models.Model):
    _name = 'a.model'
    _my_check = models.Constraint("CHECK (x > y)", "x > y is not true")
    _name_idx = models.Index("(last_name, first_name)")
```

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

### Get Odoo Version (HTTP GET)

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

Demonstrates how to retrieve the Odoo version using an HTTP GET request to the /web/version endpoint.

```http
GET /web/version HTTP/1.1


```

```json
HTTP/1.1 200 OK
Content-Type: application/json

{"version_info": [19, 0, 0, "final", 0, ""], "version": "19.0"}


```

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

### Application Mount Setup

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

Set up the JavaScript code to mount the root component when the application is ready. This file handles the initialization and rendering of the Owl application into the document body.

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

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

```

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

### JSON-RPC Request Example

Source: https://www.odoo.com/documentation/19.0/developer/reference/backend/http.html

Example of a JSON-RPC request being sent to the server.

```json
--> {"jsonrpc": "2.0", "method": "call", "params": {"arg1": "val1" }, "id": null}
```

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

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

Source: https://www.odoo.com/documentation/19.0/developer/reference/external_rpc_api.html

Initializes a test database and returns connection details including host, database name, username, and password.

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

### Description
Requests a new test database instance from the Odoo demo server.

### Method
POST

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

### Response
#### Success Response (200)
- **host** (string) - The host URL for the new database.
- **database** (string) - The name of the created database.
- **user** (string) - The username for authentication.
- **password** (string) - The password for authentication.
```

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

### Install Odoo modules via CLI

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

Installs specified modules into an initialized Odoo database.

```bash
$ odoo-bin module install <modules>
```

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

### Onboarding Tour File Structure

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

Standard directory layout for an onboarding tour module.

```text
your_module
├── ...
├── data
|   └── your_tour.xml
├── static/src/js/tours/your_tour.js
└── __manifest__.py
```

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

### Importing core utilities

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

Use the @web prefix to import modules from the web/static/src directory.

```javascript
import { memoize } from "@web/core/utils/functions";
```

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

### Get Current Datetime

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

Use `fields.Datetime.now()` to get the current date and time in the format expected by the Odoo ORM.

```python
fields.Datetime.now()
```

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

### Creating and Using a Basic Registry

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

Demonstrates how to create a new registry, add an entry, and retrieve it. This is useful for managing custom configurations or data within the web client.

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

const myRegistry = new Registry();

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

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

```

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

### Define a complete settings view structure

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

Example of a full settings view layout using 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>
```

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

### Configure Date Range Start Date Field

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

Specify the 'start_date_field' option to link a daterange widget to a specific field for the start date.

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

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

### Run a tour with watch mode

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

Use the watch=True parameter in start_tour to automatically open a Chrome window and execute the tour locally.

```python
self.start_tour("/web", "your_tour_name", watch=True)
```

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

### Get Current Date for ORM

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

Use `fields.Date._today()` to get the current day in the format expected by the Odoo ORM, often used for default values.

```python
fields.Date._today()
```

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

### Complete SVG Image Shape Example

Source: https://www.odoo.com/documentation/19.0/developer/howtos/website_themes/shapes.html

This is a complete example of an SVG file used for an image shape, including definitions for masks and decorative elements.

```svg
<svg xmlns="http://www.w3.org/2000/svg"
   xmlns:xlink="http://www.w3.org/1999/xlink"
   width="800"
   height="800">
   <defs>
      <!-- Mask -->
      <clipPath id="clip-path" clipPathUnits="objectBoundingBox">
         <use xlink:href="#filterPath" fill="none" />
      </clipPath>
      <!-- Vector used in the mask definition (Clip-path) -->
      <path id="filterPath" d="M0.325,0.75H0.125c-0.069,0-0.125-0.056-0.125-0.125V0.125C0,0.056,
      0.056,0,0.125,0h0.2c0.069,0,0.125,0.056,0.125,0.125v0.5c0,0.069-0.056,0.125-0.125,0.125ZM1,
      0.875v-0.5c0-0.069-0.056-0.125-0.125-0.125h-0.2c-0.069,0-0.125,0.056-0.125,0.125v0.5c0,
      0.069,0.056,0.125,0.125,0.125h0.2c0.069,0,0.125-0.056,0.125-0.125Z" />
   </defs>

   <!-- Other decorative element around (not used as a mask) -->
   <svg viewBox="0 0 1 1" preserveAspectRatio="none">
      <rect x="0.494"
         y="0.325"
         width="0.0125"
         height="0.35"
         rx="0.00625"
         ry="0.00625"
         fill="#7C6576" />
   </svg>

   <!-- Preview of the Path declared in the <defs> -->
   <svg viewBox="0 0 1 1" id="preview" preserveAspectRatio="none">
      <use xlink:href="#filterPath" fill="darkgrey" />
   </svg>

   <!-- Future image that on wich the mask is applied -->
   <image xlink:href="" clip-path="url(#clip-path)">
      <!-- Compatibility hack (Safari, Firefox) for non-animated shapes -->
      <animateMotion dur="1ms" repeatCount="indefinite" />
   </image>
</svg>
```

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

### Directory Structure Example for Upgrade Script

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

Illustrates the expected directory layout for an upgrade script within a custom Odoo module.

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

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

### Widget Initialization with Template

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

Setting up widget state in init() to be consumed by a template.

```javascript
local.HomePage = instance.Widget.extend({
    template: "HomePageTemplate",
    init: function(parent) {
        this._super(parent);
        this.name = "Mordecai";
    },
    start: function() {
    },
});
```

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

### Native Javascript Module Example

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

Example of a native Javascript module using import and export syntax. Files in /static/src and /static/tests are transpiled into Odoo modules by default.

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

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

```

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

### Odoo Unit Test Class Setup

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

Demonstrates setting up a test class that extends Odoo's TransactionCase. It shows how to use setUpClass to create common test data for multiple test methods, improving efficiency.

```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([...])

```

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

### Clone the Odoo tutorials repository

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

Download the tutorials repository to your local machine to begin working on training modules.

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

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

### XPath Position Attribute Examples

Source: https://www.odoo.com/documentation/19.0/developer/tutorials/server_framework_101/12_inheritance.html

Demonstrates different `position` attributes within an `xpath` expression for view inheritance. These examples show how to insert elements relative to a matched element.

```xml
<xpath expr="//field[@name='description']" position="after">
    <field name="idea_ids" />
</xpath>

<field name="description" position="after">
    <field name="idea_ids" />
</field>

```

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

### Configure upgrade path

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

Start the Odoo binary with the upgrade utility source directory included in the upgrade path.

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

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

### Element Replacement Example: Replacing a Field

Source: https://www.odoo.com/documentation/19.0/developer/reference/user_interface/view_records.html

This example shows how to replace an existing element (a div with a specific name) with new content ('<field name="name2"/>') using the 'replace' position attribute.

```xml
<div name="name" position="replace">
    <field name="name2"/>
</div>
```

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

### Upgrade test directory structure

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

Example directory layout for organizing upgrade scripts and their corresponding tests within a module.

```text
myupgrades/
└── mymodule1/
    ├── 18.0.1.1.2/
    │   └── pre-myupgrade.py
    └── tests/
        ├── __init__.py
        └── test_myupgrade.py
```

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

### Start a tour via browser console

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

Launch a tour manually by executing this command in the browser's JavaScript console.

```javascript
odoo.startTour("tour_name");
```

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

### Configure Git remotes for tutorials

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

Set up remote repositories to push changes to personal or shared forks instead of the main codebase.

```bash
$ cd /TutorialsPath
$ git remote add dev git@github.com:<your_github_account>/tutorials.git
```

```bash
$ cd /tutorials
$ git remote add dev git@github.com:odoo-dev/tutorials.git
$ git remote set-url --push origin you_should_not_push_on_this_repository
```

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

### Rendered Output

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

The resulting HTML output from the widget context example.

```html
<div>Hello Mordecai</div>
```

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

### Basic SelectMenu with Choices and Groups

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

This example demonstrates the basic usage of the SelectMenu component, displaying predefined choices and organizing them into groups.

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

class MyComponent extends Component {
  static template = xml`
    <SelectMenu
      choices="choices"
      groups="groups"
      value="'value_2'"
    />
  `;

  get choices() {
    return [
        {
          value: "value_1",
          label: "First value"
        }
    ]
  }
  get groups() {
    return [
      {
          label: "Group A",
          choices: [
              {
                value: "value_2",
                label: "Second value"
              },
              {
                value: "value_3",
                label: "Third value"
              }
          ]
      },
      {
          label: "Group B",
          choices: [
              {
                value: "value_4",
                label: "Fourth value"
              }
          ]
      }
    ]
  }
}

```

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

### Define a sub-template

Source: https://www.odoo.com/documentation/19.0/developer/reference/frontend/qweb.html

Example of a sub-template that consumes a variable from the execution context.

```xml
<p><t t-value="var"/></p>
```

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

### Using RPC Service in a Component

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

This example shows how to use the `rpc` service within a component's `onWillStart` lifecycle hook to perform an asynchronous operation.

```javascript
import { rpc } from "@web/core/network/rpc";

class MyComponent extends Component {
  setup() {
    onWillStart(async () => {
      const result = await rpc(...);
    })
  }
}

```

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

### JSON-RPC Error Response

Source: https://www.odoo.com/documentation/19.0/developer/reference/backend/http.html

Example of a JSON-RPC error response from the server.

```json
<-- {"jsonrpc": "2.0", "error": {"code": 1, "message": "End user error message.", "data": {"code": "codestring", "debug": "traceback" } }, "id": null}
```

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

### JSON-RPC Success Response

Source: https://www.odoo.com/documentation/19.0/developer/reference/backend/http.html

Example of a successful JSON-RPC response from the server.

```json
<-- {"jsonrpc": "2.0", "result": { "res1": "val1" }, "id": null}
```

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

### Importing and using upgrade utils

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

Import the utility module and use it within the migrate function, passing the database cursor.

```python
from odoo.upgrade import util


def migrate(cr, version):
   # Rest of the script
```

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

### Get Web Version

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

Retrieves the current version information of the Odoo instance.

```APIDOC
## GET /web/version

### Description
Retrieves the version information of the Odoo instance.

### Method
GET

### Endpoint
/web/version

### Response
#### Success Response (200)
- **version_info** (array) - Detailed version information.
- **version** (string) - The main version string.

### Response Example
```json
{
  "version_info": [19, 0, 0, "final", 0, ""],
  "version": "19.0"
}
```
```

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

### Configure Google fonts

Source: https://www.odoo.com/documentation/19.0/developer/howtos/website_themes/theming.html

Example of adding a Google font to the theme configuration.

```scss
$o-theme-font-configs: (
   'Poppins': (
      'family':                         ('Poppins', sans-serif),
      'url':                            'Poppins:400,500',
      'properties' : (
         'base': (
            'font-size-base':           1rem,
         ),
      ),
   ),
);
```

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

### Specify button types

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

Examples of buttons configured for object methods or action records.

```xml
<button type="object" name="action_create_new" string="Create document"/>
<button type="action" name="addon.action_create_view" string="Create and Edit"/>
```

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

### Initialize and Evaluate Domains

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

Use the Domain class to instantiate domains and check if records match the defined criteria.

```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();
```

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

### Define an Odoo Model

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

Example of a Python model definition with a sample method and fields.

```python
class message_of_the_day(models.Model):
    _name = "oepetstore.message_of_the_day"

    @api.model
    def my_method(self):
        return {"hello": "world"}

    message = fields.Text(),
    color = fields.Char(size=20),
```

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

### Http Service API

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

Provides a lower-level interface for sending HTTP GET and POST requests.

```APIDOC
## Http Service API

### Description
Provides a lower-level interface for sending HTTP GET and POST requests when more control than standard RPCs is needed.

### Overview

*   Technical name: `http`
*   Dependencies: None
```

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

### Create and Inspect Custom Models via RPC

Source: https://www.odoo.com/documentation/19.0/developer/reference/external_rpc_api.html

Demonstrates creating a custom model with the 'manual' state and retrieving its field definitions across multiple programming languages.

```python
models.execute_kw(db, uid, password, 'ir.model', 'create', [{
    'name': "Custom Model",
    'model': "x_custom_model",
    'state': 'manual',
}])
models.execute_kw(db, uid, password, 'x_custom_model', 'fields_get', [], {'attributes': ['string', 'help', 'type']})
```

```php
$models->execute_kw($db, $uid, $password, 'ir.model', 'create', array(array(
    'name' => "Custom Model",
    'model' => 'x_custom_model',
    'state' => 'manual'
)));
$models->execute_kw($db, $uid, $password, 'x_custom_model', 'fields_get', array(), array('attributes' => array('string', 'help', 'type')));
```

```ruby
models.execute_kw(db, uid, password, 'ir.model', 'create', [{
    name: "Custom Model",
    model: 'x_custom_model',
    state: 'manual'
}])
fields = models.execute_kw(db, uid, password, 'x_custom_model', 'fields_get', [], {attributes: %w(string help type)})
```

```java
models.execute(
    "execute_kw", asList(
        db, uid, password,
        "ir.model", "create",
        asList(new HashMap<String, Object>() {{
            put("name", "Custom Model");
            put("model", "x_custom_model");
            put("state", "manual");
        }})
));
final Object fields = models.execute(
    "execute_kw", asList(
        db, uid, password,
        "x_custom_model", "fields_get",
        emptyList(),
        new HashMap<String, Object> () {{
            put("attributes", asList(
                    "string",
                    "help",
                    "type"));
        }}
));
```

```go
var id int64
if err := models.Call("execute_kw", []any{
    db, uid, password,
    "ir.model", "create",
    []map[string]string{
        {
            "name":  "Custom Model",
            "model": "x_custom_model",
            "state": "manual",
        },
    },
}, &id); err != nil {
    log.Fatal(err)
}
recordFields := map[string]string{}
if err := models.Call("execute_kw", []any{
    db, uid, password,
    "x_custom_model", "fields_get",
    []any{},
    map[string][]string{
        "attributes": {"string", "help", "type"},
    },
}, &recordFields); err != nil {
    log.Fatal(err)
}
```

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

### Access snippet demo page

Source: https://www.odoo.com/documentation/19.0/developer/howtos/website_themes/building_blocks.html

The URL pattern to access the demo page for installed snippets.

```text
https://your-database.com/website/demo/snippets
```

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

### Configure Multiple Log Handlers via CLI

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

Example of using the --log-handler option multiple times to set specific logging levels for different components.

```bash
$ odoo-bin --log-handler :DEBUG --log-handler werkzeug:CRITICAL --log-handler odoo.fields:WARNING
```

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

### Define a List View Structure

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

Example of a basic list view definition with fields and aggregation.

```xml
<list>
    <field name="name" string="My Custom Name"/>
    <field name="amount" sum="Total"/>
    <field name="currency_id"/>
    <field name="tax_id"/>
</list>
```
Tokens:
Raw