DEV Community: Jeevachaithanyan Sivanandan

How to find the current page template/view ID from the dev tools?

Jeevachaithanyan Sivanandan — Sun, 06 Jul 2025 18:04:13 +0000

Often in Odoo development, we need to customize the current template view. In order to do that, we need to find the template ID of the current page and then customize it. It's easy to find information about the current template using debug mode; we can use the metadata option or edit form view. However, these are not available on website portal pages. If you want to edit such pages, you'll have to dive through the portal templates and trace up to the correct template ID, which can often take some time. There's an easier way to find the template from the browser dev tools.

Let's say we need to edit the product template view page in the website portal. Just open your browser dev tools and highlight the HTML tag . You'll then see the tag data-viewID; it will have the ID of the template view. Copying this value, you can go to Settings > Technical > Views and search for this ID. You'll be able to see the template there.

How to Add Custom Translations in Odoo Using .po Files

Jeevachaithanyan Sivanandan — Fri, 04 Jul 2025 15:27:02 +0000

Step 1: Create a .po File
File Location
Place your .po file in:

/your_module/i18n/es.po # choose the correst lang code

File Structure
A basic .po file should include:

Header (metadata)

Translation entries (msgid = original text, msgstr = translated text)

Example: es.po (Espanol Translations)

`
msgid ""
msgstr ""
"Project-Id-Version: Your Module 16.0\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-07-10 12:00+0000\n"
"PO-Revision-Date: 2025-07-10 12:00+0000\n"
"Last-Translator: Your Name email@example.com\n"
"Language-Team: Espanolteam@example.com\n"
"Language: es_ES\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"

. module: your_module

: model_terms:ir.ui.view,arch_db:your_module.your_view_id

msgid "Customer"
msgstr "cliente"
`

**Step 2: Ensure Your Template Uses Translatable Text
**Option 1: Simple Text (Auto-translated)

Customer

**Step 3: Update & Load Translations
**1. Update Your Module

./odoo-bin -d your_db -u your_module --stop-after-init

Force Reload Translations (If Needed) ./odoo-bin -d your_db -u your_module --i18n-overwrite --stop-after-init

**Common Issues & Fixes
**Issue Solution
Translations not loading Ensure .po file is in /i18n/ and module is updated
Case mismatch (e.g., Amount vs. AMOUNT) Make sure msgid matches exactly
Missing view reference Add model_terms:ir.ui.view in .po file

git clone only particular branch

Jeevachaithanyan Sivanandan — Fri, 20 Jun 2025 12:55:48 +0000

Just use the command to clone only a particular branch not all branches from a repo

git clone --branch <branch_name> --single-branch <repository_url>

Odoo check if a module is installed or not

Jeevachaithanyan Sivanandan — Fri, 30 May 2025 08:23:01 +0000

If you need to check if a website is installed or not in the database for odoo

SELECT name,state FROM ir_module_module WHERE name = 'module_name';

Odoo Database Table Naming Quirk

Jeevachaithanyan Sivanandan — Fri, 30 May 2025 08:20:22 +0000

In Odoo, database table names typically follow a straightforward convention: they are the underscored (_) version of the model name as seen in the user interface. For example, the sale.order model corresponds to the sale_order table. However, this pattern isn't always consistent. For instance, you might expect the ir.action.server model to map to the ir_action_server table, but the actual table name is ir_act_server.

This subtle naming quirk can be easy to overlook and may cause confusion when working with Odoo's database. I hope sharing this saves you time if you encounter a similar situation!

Inheritance Vs composition

Jeevachaithanyan Sivanandan — Fri, 11 Apr 2025 06:51:59 +0000

Inheritance

Inheritance is a mechanism in object-oriented programming (OOP) where a new class (the child class or subclass) inherits properties and methods from an existing class (the parent class or superclass).

"Is-a" relationship: Inheritance models an "is-a" relationship. For example, a Dog is an Animal. The Dog class would inherit general characteristics and behaviors from the Animal class and can also have its own specific attributes and methods (like bark()).
Code Reusability: Inheritance promotes code reusability. Common functionalities can be defined in the parent class and reused by multiple child classes, reducing code duplication.
Extensibility: Child classes can extend or override the functionality inherited from the parent class to suit their specific needs.
Example in Python:

Python

class Animal:
def init(self, name):
self.name = name

def speak(self):
    print("Generic animal sound")

class Dog(Animal):
def speak(self): # Overrides the parent's speak method
print("Woof!")

class Cat(Animal):
def speak(self): # Overrides the parent's speak method
print("Meow!")

dog = Dog("Buddy")
cat = Cat("Whiskers")

dog.speak() # Output: Woof!
cat.speak() # Output: Meow!
print(dog.name) # Output: Buddy (inherited from Animal)
Composition

Composition is a design principle in OOP where a class contains objects of other classes. Instead of inheriting behavior, the class achieves its functionality by delegating tasks to its constituent objects.

"Has-a" relationship: Composition models a "has-a" relationship. For example, a Car has an Engine and Wheels. The Car class would contain instances of the Engine and Wheel classes and use their functionalities.
Flexibility: Composition offers more flexibility than inheritance. You can easily change the behavior of a class at runtime by replacing its component objects.
Loose Coupling: Composition leads to looser coupling between classes. Changes in one component class are less likely to affect the classes that use it (as long as the component's interface remains the same).
Example in Python:

Python

class Engine:
def start(self):
print("Engine started")

def stop(self):
    print("Engine stopped")

class Wheels:
def rotate(self):
print("Wheels are rotating")

class Car:
def init(self):
self.engine = Engine()
self.wheels = Wheels()

def drive(self):
    self.engine.start()
    self.wheels.rotate()
    print("Car is moving")

def park(self):
    self.engine.stop()
    print("Car parked")

my_car = Car()
my_car.drive()
my_car.park()
How Inheritance and Composition are Related

Both inheritance and composition are mechanisms for achieving code reuse and building complex objects in OOP. However, they differ in their approach and the type of relationship they model:

Inheritance focuses on creating a hierarchy of classes where subclasses inherit and extend the behavior of their superclasses ("is-a").
Composition focuses on building objects by combining instances of other classes, leveraging their functionalities ("has-a").
In many situations, you might need to choose between inheritance and composition. The principle "favor composition over inheritance" is often recommended because composition tends to lead to more flexible, maintainable, and less coupled code.

However, inheritance is still valuable when there is a clear "is-a" relationship and you want to reuse and extend a well-defined base class. Sometimes, a combination of both inheritance and composition can be used effectively to model complex systems. For instance, a base class might define a general structure (inheritance), while its instances contain specialized component objects (composition) to perform specific tasks.

How to Import Packages in Go

Jeevachaithanyan Sivanandan — Sun, 02 Mar 2025 21:31:41 +0000

When a Go project grows larger, it becomes necessary to access functions and variables from different packages. In Go, we can do this using the import statement.

Project Structure Example

Consider we have a project structure as below:

MainFolder/ │── FolderA/ │── FolderB/ │── FolderC/ │── main.go │── go.mod │── go.sum

FolderA has a function → FunctionA

FolderB has a function → FunctionB

FolderC has a function → FunctionC

Importing a Package in main.go

If we need to use FunctionA inside main.go, we import the package as follows:

package main

import (
    "MainFolder/FolderA" // Importing FolderA package
)

func main() {
    // Now we can access functions from FolderA
    FolderA.SampleFunction2() // ✅ This works because it starts with an uppercase letter
    FolderA.sampleFunction1() // ❌ Error: Unexported function (starts with lowercase)
}

This rule also applies to struct fields:

type User struct {
    Name  string  // Exported
    age   int     // Unexported
}

*Exported vs Unexported Functions
*
Functions that start with an uppercase letter (SampleFunction2()) are exported and can be accessed from other packages.

Functions that start with a lowercase letter (sampleFunction1()) are unexported and can only be accessed within the same package.

*Example: Correct Function Declarations in FolderA/a.go
*

package FolderA // Package name should match the folder name

// Exported function (accessible from other packages)
func SampleFunction2() {
    // Function logic
}

// Unexported function (only accessible within the same package)
func sampleFunction1() {
    // Function logic
}

Accessing Another Package from FolderA (Using FolderB's Function in FolderA)

Now, let's say we need to call FunctionB from FolderB inside FolderA/a.go:

Correct way to import and use FunctionB in FolderA/a.go

package FolderA

import "MainFolder/FolderB"

func sampleFunction1() {
    FolderB.FunctionB() // ✅ Correct usage
}

*Accessing Global Variables from Another Package
*
If FolderC contains a global variable like DbPass, we can access it from FolderA as follows:

Example: Using Global Variables from FolderC in FolderA/a.go

package FolderA

import (
    "MainFolder/FolderB"
    "MainFolder/FolderC"
)

func sampleFunction1() {
    FolderB.FunctionB() // ✅ Function call

    // Accessing a global variable from FolderC
    if FolderC.DbPass == "some value" { // ✅ Variable must start with an uppercase letter
        // Do something
    }
}

Key Takeaways

Package Naming Conventions: The package name should match the folder name (e.g., package FolderA inside FolderA/).
Exported Functions and Variables: Functions and variables that need to be accessed from other packages must start with an uppercase letter.
Lowercase Functions and Variables: Functions and variables that start with lowercase letters are private to the package.
Importing a Package: Use import "MainFolder/FolderX" to access other packages in the project.
Calling a Function from Another Package: Use PackageName.FunctionName() syntax.

odoo redirect /shop page

Jeevachaithanyan Sivanandan — Fri, 28 Feb 2025 08:54:45 +0000

if you want to redirect Odoo /shop page to /products

<template id="redirect_shop_to_products" inherit_id="website_sale.product"> <xpath expr="//li[@class='breadcrumb-item o_not_editable']/a" position="attributes"> <attribute name="t-att-href">keep('/products', category=0)</attribute> </xpath> </template>
`

Python Program for a Turing Machine Simulator python Copy code

Jeevachaithanyan Sivanandan — Sun, 22 Dec 2024 11:51:50 +0000

class TuringMachine:
def init(self, tape, transitions, initial_state, accept_state, reject_state):
self.tape = list(tape) # The tape is a list of characters
self.head = 0 # Head position starts at the beginning
self.state = initial_state
self.transitions = transitions
self.accept_state = accept_state
self.reject_state = reject_state

def step(self):
    """Perform one step of the Turing machine."""
    symbol = self.tape[self.head] if self.head < len(self.tape) else ' '  # Read the current symbol (blank if out of bounds)

    if (self.state, symbol) in self.transitions:
        new_state, write_symbol, move = self.transitions[(self.state, symbol)]

        # Write the new symbol on the tape
        if self.head < len(self.tape):
            self.tape[self.head] = write_symbol
        else:
            self.tape.append(write_symbol)

        # Move the head
        if move == 'R':
            self.head += 1
        elif move == 'L':
            self.head -= 1
            if self.head < 0:
                self.tape.insert(0, ' ')  # Extend tape on the left

        # Update the state
        self.state = new_state
    else:
        # Transition not defined for current state and symbol
        self.state = self.reject_state

def run(self):
    """Run the Turing machine until it reaches an accept or reject state."""
    while self.state != self.accept_state and self.state != self.reject_state:
        self.step()
    return self.state == self.accept_state

def display_tape(self):
    """Display the tape and head position."""
    tape_view = ''.join(self.tape).rstrip()  # Remove trailing blanks
    print("Tape:", tape_view)
    print("Head:", ' ' * self.head + '^')

Define the Turing machine configuration

tape = list("1011") # Initial tape
transitions = {
# (current_state, current_symbol): (new_state, write_symbol, move_direction)
('q0', '1'): ('q0', '1', 'R'),
('q0', '0'): ('q0', '0', 'R'),
('q0', ' '): ('q_accept', ' ', 'N'), # N: No move
}
initial_state = 'q0'
accept_state = 'q_accept'
reject_state = 'q_reject'

Create and run the Turing machine

tm = TuringMachine(tape, transitions, initial_state, accept_state, reject_state)
tm.display_tape()

if tm.run():
print("Turing machine accepted the input.")
else:
print("Turing machine rejected the input.")

tm.display_tape()

draft article below
Simulating a Turing Machine in Python
A Turing machine is a fundamental concept in computer science, representing a theoretical model of computation that defines what it means for a system to be "computable." While it's an abstract idea, we can simulate a Turing machine using Python, showcasing the language's Turing completeness.

In this article, we’ll explore the basics of a Turing machine, implement a Python simulator, and test it with various examples.

What is a Turing Machine?
A Turing machine consists of:

Tape: An infinitely long sequence of cells that can hold symbols. The tape serves as both input and memory.
Head: A pointer that can read and write symbols on the tape and move left or right.
States: The machine can be in one of many states, including an initial state, accept state, and reject state.
Transition Rules: A set of instructions dictating what the machine does based on its current state and the symbol under the head.
Why Simulate a Turing Machine in Python?
Python, being a Turing-complete language, can simulate any computational process. By implementing a Turing machine in Python:

You can better understand how computation works at a fundamental level.
It serves as a practical example of Python’s computational power.
Python Implementation of a Turing Machine
Below is the Python code for a Turing machine simulator:

python
Copy code
class TuringMachine:
def init(self, tape, transitions, initial_state, accept_state, reject_state):
self.tape = list(tape) # The tape is a list of characters
self.head = 0 # Head position starts at the beginning
self.state = initial_state
self.transitions = transitions
self.accept_state = accept_state
self.reject_state = reject_state

def step(self):
    """Perform one step of the Turing machine."""
    symbol = self.tape[self.head] if self.head < len(self.tape) else ' '  # Read the current symbol (blank if out of bounds)

    if (self.state, symbol) in self.transitions:
        new_state, write_symbol, move = self.transitions[(self.state, symbol)]

        # Write the new symbol on the tape
        if self.head < len(self.tape):
            self.tape[self.head] = write_symbol
        else:
            self.tape.append(write_symbol)

        # Move the head
        if move == 'R':
            self.head += 1
        elif move == 'L':
            self.head -= 1
            if self.head < 0:
                self.tape.insert(0, ' ')  # Extend tape on the left

        # Update the state
        self.state = new_state
    else:
        # Transition not defined for current state and symbol
        self.state = self.reject_state

def run(self):
    """Run the Turing machine until it reaches an accept or reject state."""
    while self.state != self.accept_state and self.state != self.reject_state:
        self.step()
    return self.state == self.accept_state

def display_tape(self):
    """Display the tape and head position."""
    tape_view = ''.join(self.tape).rstrip()  # Remove trailing blanks
    print("Tape:", tape_view)
    print("Head:", ' ' * self.head + '^')

Example: Testing the Turing Machine
Configuration
Let’s configure the Turing machine to read a binary string and accept it if it reaches the end without errors.

python
Copy code

Define the Turing machine configuration

Create and run the Turing machine

tm = TuringMachine(tape, transitions, initial_state, accept_state, reject_state)
tm.display_tape()

if tm.run():
print("Turing machine accepted the input.")
else:
print("Turing machine rejected the input.")

tm.display_tape()
Expected Output
For the input 1011, the output will be:

yaml
Copy code
Tape: 1011
Head: ^
Turing machine accepted the input.
Tape: 1011
Head: ^
How It Works
The machine starts at the first position and reads the tape.
It moves right until it encounters a blank space (' ').
It transitions to the accept state (q_accept) and halts.
Extending the Example
You can extend this example to handle more complex operations. For example:

Replace Symbols on the Tape
python
Copy code
transitions = {
('q0', '1'): ('q1', 'X', 'R'), # Replace 1 with X
('q1', '0'): ('q0', 'Y', 'R'), # Replace 0 with Y
('q1', ' '): ('q_accept', ' ', 'N'),
}
For tape = list("1011"), this will produce:

makefile
Copy code
Tape: XYX1
Head: ^
Turing machine accepted the input.
Add a Reject State
To handle invalid input, define a reject_state:

python
Copy code
transitions = {
('q0', '1'): ('q0', '1', 'R'),
('q0', '2'): ('q_reject', '2', 'N'), # Reject if symbol 2 is encountered
}
For tape = list("12"), this will produce:

makefile
Copy code
Tape: 12
Head: ^
Turing machine rejected the input.
Key Takeaways
Simulating a Turing Machine: Python can simulate a Turing machine effectively, demonstrating its computational power.
Understanding Computation: This program offers insights into how fundamental computation models work.
Customization: By modifying the transition rules and tape, you can simulate various computational tasks.
Conclusion
This simple Turing machine simulator in Python is a great way to explore computational theory. It demonstrates how complex operations can emerge from simple rules, and it provides a platform to experiment with theoretical computer science concepts.

If you want to delve deeper, consider building visualizations or extending the simulator for more advanced computations. The possibilities are endless!

Install Odoo v 17 with Python 3.12 in MSWindows 11

Jeevachaithanyan Sivanandan — Sat, 21 Dec 2024 15:09:47 +0000

If you're looking to set up Odoo 17 on a Windows 11 system with Python 3.12, you might face a few compatibility challenges with dependencies. This guide provides a custom requirements.txt tailored specifically for this configuration, along with solutions for common issues during installation.

Custom requirements.txt for Windows 11 with Python 3.12

Below is the custom requirements.txt file that ensures Odoo 17 works seamlessly on Windows 11 with Python 3.12. This file includes compatible versions of required packages and handles Windows-specific dependencies.

`# Windows 11 Compatible Requirements for Python 3.12

Babel==2.10.3

chardet==5.2.0

cryptography==42.0.8

decorator==5.1.1

docutils==0.20.1

ebaysdk==2.1.5

freezegun==1.2.1

geoip2==2.9.0

gevent==24.2.1 ; sys_platform == 'win32'

greenlet==3.0.3 ; sys_platform == 'win32'

idna==3.6

Jinja2==3.1.2

libsass==0.22.0 ; sys_platform == 'win32' # Prebuilt wheel available

lxml==5.2.1

lxml-html-clean ; python_version >= '3.12' # Required for HTML clean in Windows

MarkupSafe==2.1.5

num2words==0.5.13

ofxparse==0.21

passlib==1.7.4

Pillow==10.2.0

polib==1.1.1

psutil==5.9.8

psycopg2==2.9.9 ; sys_platform == 'win32'

pydot==1.4.2

pyopenssl==24.1.0

PyPDF2==2.12.1

pypiwin32 ; sys_platform == 'win32'

pyserial==3.5

python-dateutil==2.8.2

python-ldap==3.4.4 ; sys_platform == 'win32' # Prebuilt wheel required

python-stdnum==1.19

pytz

pyusb==1.2.1

qrcode==7.4.2

reportlab==4.1.0

requests==2.31.0

rjsmin==1.2.0

rl-renderPM==4.0.3 ; sys_platform == 'win32' # Needed by reportlab

urllib3==2.0.7

vobject==0.9.6.1

Werkzeug==3.0.1

xlrd==2.0.1

XlsxWriter==3.1.9

xlwt==1.3.0

zeep==4.2.1
`

Handling Common Installation Issues

When installing the dependencies in the requirements.txt, you might encounter the following error :

running build_ext building '_ldap' extension creating build\temp.win-amd64-cpython-312\Release\Modules "C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools\VC\Tools\MSVC\14.42.34433\bin\HostX86\x64\cl.exe" /c /nologo /O2 /W3 /GL /DNDEBUG /MD -DHAVE_SASL -DHAVE_TLS -DL

This error typically occurs due to missing precompiled wheels for certain dependencies, such as python-ldap. Building these dependencies from source requires additional setup, but you can bypass the issue by downloading prebuilt wheels.

Solution: Install Prebuilt Wheels

For Windows, prebuilt wheels can simplify the installation process significantly. Use the following steps to resolve the issue:

Download Prebuilt Wheel:

Go to the GitHub repository https://github.com/mymy47/python-builds-for-windows/releases.

Download the appropriate wheel file for python-ldap or any other dependency causing the issue.

Install the Wheel:

Use pip to install the wheel manually:

pip install path_to_downloaded_wheel.whl
Continue Installing Dependencies:

Once the problematic dependency is resolved, install the remaining packages:

pip install -r requirements.txt

Boosting Code Quality in Odoo with Type Hints: Benefits Beyond Performance

Jeevachaithanyan Sivanandan — Mon, 11 Nov 2024 21:13:04 +0000

As Odoo evolves, developers gain access to powerful tools like type hinting that improve code quality, readability, and maintainability. Type hints, while often mistaken as performance enhancers, primarily serve to make code easier to understand and more resilient to future changes. This article explores how type hints bring substantial benefits to Odoo development and why they are worth the effort.

What Are Type Hints?
Type hints in Python are annotations that describe the expected data type of a variable, parameter, or return value. For example, in Odoo, type hints can clarify model relationships, as shown below:

product_category_id: 'ProductCategory' = fields.Many2one(
    'product.category',
    string='Product Category',
    help='Link to the product category associated with this partner category'
)

This tells developers (and analysis tools) that product_category_id references a ProductCategory model.

Key Benefits of Type Hints in Odoo
Type hints significantly enhance the quality of Odoo codebases, even without affecting runtime performance. Here’s how they improve development:

Improved Readability and Self-Documentation
Type hints make code more readable and act as self-documentation. In large Odoo projects, models can have extensive relationships, making it valuable to explicitly show the expected types. The type hint in product_category_id: 'ProductCategory' clarifies its purpose, which helps new or unfamiliar developers understand relationships faster.
Enhanced Developer Experience
Type hints provide better IDE support, with features like autocomplete, tooltip explanations, and safer refactoring. IDEs can recognize the type of product_category_id as a ProductCategory and offer relevant methods and attributes, making development faster and more accurate.
Early Error Detection
Type hints enable static type checkers like mypy or Pyright to detect type errors before runtime, reducing bugs. For example, if a non-ProductCategory value is mistakenly assigned to product_category_id, type checkers will raise a warning, ensuring data consistency early.
Improved Maintainability
Odoo code often involves complex model relationships, and type hints help clarify these links, reducing ambiguity. By showing exactly what each field references, type hints make code easier to maintain and extend, which is essential as models evolve.

No Direct Performance Boost, But Indirect Gains
Type hints do not directly impact runtime speed, as Python ignores them at runtime. However, they can indirectly improve efficiency by:

Reducing Downtime: Early error detection reduces runtime crashes.
Speeding Development: Enhanced IDE support and fewer bugs make development smoother.

Here’s an example where product_category_id references the ProductCategory model, with type hints to aid clarity:

import typing
from odoo import fields, models

if typing.TYPE_CHECKING:
    from odoo.addons.product.models.product_category import ProductCategory

class PartnerCategory(models.Model):
    _inherit = "res.partner.category"
    _description = "Customized Partner Tag"

    product_category_id: 'ProductCategory' = fields.Many2one(
        'product.category',
        string='Product Category',
        help='Link to the product category associated with this partner category'
    )

This type hint clarifies product_category_id's expected type without affecting runtime.

Odoo: Import CSV file and write into sale order lines

Jeevachaithanyan Sivanandan — Mon, 28 Oct 2024 16:38:53 +0000

Odoo: Import CSV file and write into sale order lines

The method features:

read an imported csv file
check some validations
write the values from the csv file into the sale order line and sale order

    def action_import_csv(self):

        if not self.file_name or not self.file_name.lower().endswith('.csv'):
            raise UserError("Invalid file format! Please upload a CSV file.")

        try:
            csv_data = base64.b64decode(self.csv_file_upload).decode('utf-8')
            csv_reader = csv.DictReader(StringIO(csv_data))
        except Exception:
            raise UserError("Failed to read CSV file. Ensure the file is properly formatted.")

        sale_order = self.get_current_sale_order()

        partner_id = None  
        updated_lines = {}  

        for i, row in enumerate(csv_reader):

            if i == 0:
                row_partner_id = int(row.get("Partner ID", 0) or 0)
                partner_id = row_partner_id

                if sale_order.partner_id.id != partner_id:
                    raise UserError("The Partner ID in the CSV does not match the Sale Order's Partner.")
            elif row.get("Partner ID"):
                raise UserError("Only the first row should contain a Partner ID. Subsequent rows should leave this field empty.")

            sku = row.get("Product ID", "").strip()
            quantity = float(row.get("Product Quantity", 0))

            if not sku:
                raise UserError("Product ID (SKU) is missing in one of the rows.")

            product = self.env['product.product'].search([('default_code', '=', sku)], limit=1)
            if not product:
                raise UserError(f"Product with SKU {sku} not found in the system.")


            sale_order_line = self.env['sale.order.line'].create({
                'order_id': sale_order.id,
                'product_id': product.id,
                'product_uom_qty': quantity,
            })
            updated_lines[sku] = quantity

        sale_order.write({
            'partner_invoice_id': sale_order.partner_id.address_get(['invoice'])['invoice'],
            'partner_shipping_id': sale_order.partner_id.address_get(['delivery'])['delivery'],
        })

        return {
            'type': 'ir.actions.client',
            'tag': 'reload',
        }