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

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

### Install Upgrade Utils with Odoo-bin

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

Use this command to start Odoo with the `upgrade-util` repository prepended to the `--upgrade-path` option for local development.

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

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

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

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

### Import Upgrade Script and Get Module Object

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

This example demonstrates importing an upgrade script and shows the Python module object returned by `util.import_script`.

```python
>>> util.import_script("base/0.0.0/end-moved0.py", name="my-moved0")
<module 'my-moved0' from '/home/odoo/src/upgrade-util/src/base/0.0.0/end-moved0.py'>
```

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

### start()

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

This operation requests a new test database from `https://demo.odoo.com/start` and returns connection details.

```APIDOC
## XML-RPC Call: start()

### Description
This operation requests a new test database from `https://demo.odoo.com/start` and returns connection details.

### Method
XML-RPC Call

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

### Parameters
None

### Response
#### Success Response
- **host** (string) - The hostname or IP address of the Odoo instance.
- **database** (string) - The name of the newly created database.
- **user** (string) - The username for accessing the database.
- **password** (string) - The password for the specified user.

#### Response Example
```
{
    "host": "https://your-odoo-instance.com",
    "database": "your_db_name",
    "user": "admin",
    "password": "your_password"
}
```
```

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

### 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()

```

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

### Example Predefined and Custom Tour Steps in JavaScript

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

Shows examples of both predefined utility steps and custom steps with a trigger, isActive condition, and run action. Steps define the sequence of actions in a tour.

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

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

### Odoo Configuration File Example

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

Demonstrates a sample '[options]' section in an Odoo configuration file, setting database user and filter.

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

```

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

### 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;
}
```

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

### Registering a Web Tour in JavaScript

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

Registers a new web tour with a unique name and an optional starting URL. This is the initial setup for defining a user journey.

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

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

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

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

### Clone Odoo Petstore Module

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

Use this command to download the example `petstore` module from GitHub, which contains the necessary files for this tutorial.

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

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

### Launch Odoo Server with odoo-bin

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

Use this command to start the Odoo server, specifying the addons path and the database to use. Ensure you are in the Odoo source directory.

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

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

### Install Upgrade Utils via Pip

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

Install the `upgrade-util` library using pip on platforms where you do not manage Odoo yourself.

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

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

### 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 values for ensure_xmlid_match_record in Python

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

These examples show dictionary structures for the `values` parameter when using `ensure_xmlid_match_record` to specify criteria for matching records.

```Python
values = {"id": 123}
values = {"name": "INV/2024/0001", "company_id": 1}
```

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

### Configuring Test Case Execution Timing

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

This snippet illustrates how test cases can be configured to run at different stages, either right after module installation or after all modules have been installed.

```python

```

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

### Expand Braces in String

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

This example shows how to use `expand_braces` to generate a list of strings by expanding a single pair of braces within the input string.

```python
>>> util.expand_braces("a_{this,that}_b")
['a_this_b', 'a_that_b']
```

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

### Define Odoo Onboarding Tour in XML

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

Example of an XML record definition for `web_tour.tour`, linking it to a JavaScript tour and configuring its behavior like sequence and completion message.

```xml
<?xml version="1.0" encoding="utf-8"?>
<odoo>
    <record id="your_tour" model="web_tour.tour">
        <field name="name">your_tour</field>
        <field name="sequence">10</field>
        <field name="rainbow_man_message">Congrats, that was a great tour</field>
    </record>
</odoo>

```

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

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

```

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

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

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

### Get a Widget's Parent Element in JavaScript

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

Overrides the `start` method to log the root element (`$el`) of the widget's parent to the console.

```JavaScript
local.GreetingsWidget = instance.Widget.extend({
    start: function() {
        console.log(this.getParent().$el );
        // will print "div.oe_petstore_homepage" in the console
    },
});
```

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

### Define a Basic Odoo Widget (JavaScript)

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

Extends the base `Widget()` class to create a new component, overriding the `start()` method for initial setup and logging a message.

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

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

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

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

### Accessing DOM Elements with useRef and onMounted in Owl

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

The `useRef` hook is called in `setup` to get a reference to a DOM element. Access to the element (`.el`) is only available after the component is mounted, typically within an `onMounted` callback.

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

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

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

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

### Selecting DOM elements within a widget using the $() shortcut

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

Widgets provide a `$()` shortcut method that is equivalent to `this.$el.find()`, scoping selections to the widget's DOM root. This example demonstrates its usage within a widget's `start` method.

```javascript
local.MyWidget = instance.Widget.extend({
    start: function() {
        this.$("input.my_input")...
    },
});
```

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

### Example Odoo Settings View Structure

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

Demonstrates an Odoo settings view using `<app>`, `<setting>`, and `<block>` elements to organize configuration options with help and documentation links.

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

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

### Bind DOM Events with jQuery in Odoo Widget

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

This example shows how to bind DOM events using traditional jQuery event handlers within an Odoo widget's `start` method. This approach can be verbose and has limitations with dynamic root elements or `this`-binding.

```javascript
local.MyWidget = instance.Widget.extend({
    start: function() {
        var self = this;
        this.$(".my_button").click(function() {
            self.button_clicked();
        });
    },
    button_clicked: function() {
        ..
    },
});
```

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

### Starting a Web Tour from a Python Test

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

Demonstrates how to initiate a web tour from a Python test by inheriting from HTTPCase and calling start_tour. This is used for backend-driven tour execution.

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

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

### Define a sub-template for t-call example

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

Example definition of a sub-template named 'other-template' used in `t-call` demonstrations.

```XML/QWeb
<p><t t-value="var"/></p>
```

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

### 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"));

```

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

### Create and Query Custom Model (Ruby)

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

Illustrates creating a custom model and then querying for its fields using Ruby. Custom model names must start with 'x_' and the state must be 'manual'.

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

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

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

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

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

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

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

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

### 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");
```
```

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

### Install ipdb Python Debugger

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

Installs the `ipdb` library, a common Python debugger, using pip. This makes the debugger available for use in your development environment.

```bash
pip install ipdb

```

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

### 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'}" />
```

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

### Deploy Odoo Module to Remote Server

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

Upload and install an Odoo module to a remote server using administrative credentials. The target server must have `base_import_module` installed.

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

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

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

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

### Rendered Output of t-cache Scoping Example

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

This is the expected HTML output from the `t-cache` scoping example, demonstrating how `t-set` values behave differently inside and outside a `t-cache` block.

```xml
<div>
    <inside>2</inside>
    <outside>2</outside>

    <inside>2</inside>
    <outside>1</outside>
</div>
```

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

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

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

### Map View Example with Partner and Routing

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

This snippet demonstrates a basic Map view configuration, linking to a `partner_id` field, setting a default order, enabling routing, and hiding the partner name in the pin popup. It also defines a field to display 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>
```

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

### Odoo Shell ORM Interaction Example

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

Example of modifying records in the Odoo shell and committing changes. Note that changes are rolled back by default unless 'env.cr.commit()' is used.

```Python
In [1]: records = env["res.partner"].search([])

In [2]: records
Out[2]: res.partner(14, 26, 33, 21, 10)

In [3]: for partner in records:
   ...:     partner.name = "%s !" % partner.name
   ...:

In [4]: env.cr.commit()

```

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

### Create and Query Custom Model (Python)

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

Demonstrates creating a custom model and then retrieving its field information using the execute_kw method. Ensure custom model names start with 'x_' and the state is set to 'manual'.

```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']})
```

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

### 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;
  },
});
```

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

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

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

### Implement Upgrade Test with `UpgradeCase` (Python)

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

Extend `UpgradeCase` to define `prepare` for data setup before upgrade and `check` for assertions after. The return value of `prepare` 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)

```

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

### Example Custom SCSS for Odoo Theme

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

This SCSS example demonstrates how to style a `blockquote` element using Bootstrap variables and Odoo-specific color and font functions. It should be placed in the `theme.scss` file.

```SCSS
 blockquote {
   border-radius: $rounded-pill;
   color: o-color('o-color-3');
   font-family: o-website-value('headings-font');
 }
```

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

### Create and Query Custom Model (PHP)

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

Shows how to create a custom model and fetch its field details using PHP. Custom model names must begin with 'x_' and the state must be 'manual'.

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

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

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

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

### Create and Query Custom Model (Go)

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

Shows Go code for creating a custom model and fetching its field details. Custom model names must start with 'x_' and the state must be 'manual'.

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

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

### Rendered Output of t-nocache Scoping Example

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

This is the expected HTML output from the `t-nocache` scoping example, showing how `t-set` inside `t-nocache` does not alter the `counter` variable's value outside that block.

```xml
<section>
    <header>
        (views: 6)
    </header>
    <article>
        <title>The record name <i>(views: 1)</i></titlle>
        <content>Record description</content>
    </article>
    <footer>(views: 10)</footer>
</section>
```

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

### Rendered Output of Basic t-nocache Example

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

This is the expected HTML output from the basic `t-nocache` example, illustrating that the `t-nocache` part (e.g., the counter) is dynamically rendered even when the parent `article` is cached.

```xml
<section>
    <article>
        <title>The record name <i>(views: 1)</i></titlle>
        <content>Record description</content>
    </article>
</section>
```

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

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

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

### 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" });
```

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

### Creating a Menu Item for a Client Action (XML)

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

Creates a menu item that, when clicked, triggers the previously defined `ir.actions.client` action.

```xml
<menuitem id="home_page_petstore_menu" parent="petstore_menu"
          name="Home Page" action="action_home_page"/>
```

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

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

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

### Odoo Module Directory Structure for Onboarding Tour

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

Illustrates the required file structure for integrating an onboarding tour into an Odoo module, including data and static assets.

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

```

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

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

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

### Add Upgrade Utils to Odoo.sh Requirements

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

Include this line in your `requirements.txt` file to install the `odoo_upgrade` library on Odoo.sh.

```text
odoo_upgrade @ git+https://github.com/odoo/upgrade-util@master
```

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

### Clone Odoo Tutorials Repository

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

Clones the `odoo/tutorials` repository from GitHub to your local machine, preparing it for tutorial content.

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

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

### 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
    },
});

```

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

### 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)]"
```

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

### odoo.tests.SingleTransactionCase

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

TestCase in which all test methods are run in the same transaction, the transaction is started with the first test method and rolled back at the end of the last.

```APIDOC
## Class: `odoo.tests.SingleTransactionCase`\n\n### Description\nTestCase in which all test methods are run in the same transaction, the transaction is started with the first test method and rolled back at the end of the last.
```

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

### Prepare Upgrade Test Data

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

Use this command to prepare test data before upgrading custom modules, specifying the database, test tags, upgrade path, and addons path.

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