Extensibilidade Máxima no Odoo: Dominando Hooks e Callbacks em Módulos Personalizados

Odoo é uma plataforma ERP modular e altamente personalizável. Se procura ir além do básico e criar módulos verdadeiramente ajustados às necessidades do seu negócio, dominar hooks e callbacks é essencial. Neste artigo, vamos explorar técnicas avançadas em Python e JavaScript para estender o comportamento padrão do Odoo, otimizar performance e garantir a manutenção futura do seu código.

1. O que são Hooks e Callbacks no Odoo?

• Hooks: pontos de extensão do framework onde podemos inserir lógica customizada sem alterar o core.
• Callbacks: funções invocadas automaticamente em determinadas operações (criação, escrita, exclusão, cálculos…).

Em conjunto, permitem capilaridade máxima: adicionar, alterar ou interceptar processos no ORM e na interface web.

2. Hooks Python Essenciais

2.1 Sobrescrever Métodos do ORM

```python from odoo import models, api, exceptions

class SaleOrder(models.Model): _inherit = 'sale.order'

@api.model
def create(self, vals):
    # Lógica pré-criação
    if vals.get('discount') and vals['discount'] > 50:
        raise exceptions.UserError("Desconto demasiado elevado!")
    order = super().create(vals)
    # Lógica pós-criação
    order._ajustar_limites_credito()
    return order

@api.multi
def write(self, vals):
    res = super().write(vals)
    # Callback após escrever
    self.filtered(lambda o: o.amount_total > 10000)._notificar_vendas_altas()
    return res

```

2.2 Decoradores Avançados

• @api.depends('field1', 'field2'): recalcula o campo sempre que field1 ou field2 mudam.
• @api.onchange('partner_id'): atualiza campos no formulário antes de salvar.
• @api.constrains('email'): validações pós-escrita.

```python class ResPartner(models.Model): _inherit = 'res.partner'

credit_analysis = fields.Float(
    string="Análise de Crédito",
    compute='_compute_credit_analysis',
    store=True)

@api.depends('invoice_ids.amount_total')
def _compute_credit_analysis(self):
    for partner in self:
        partner.credit_analysis = sum(inv.amount_total for inv in partner.invoice_ids)

```

3. Callbacks de Campos Computados com Inverse

Um campo computado sem inverse é apenas leitura. Para permitir edição:

```python class ProductTemplate(models.Model): _inherit = 'product.template'

total_cost = fields.Float(
    string="Custo Total",
    compute='_compute_total_cost',
    inverse='_inverse_total_cost')

@api.depends('standard_price', 'bom_ids')
def _compute_total_cost(self):
    for prod in self:
        prod.total_cost = prod.standard_price * len(prod.bom_ids)

def _inverse_total_cost(self):
    for prod in self:
        prod.standard_price = prod.total_cost / max(len(prod.bom_ids), 1)

```

4. Extensibilidade na Interface (JavaScript)

Além do backend, pode usar hooks na Web Client:

```javascript odoo.define('my_module.FormController', function (require) { "use strict"; var FormController = require('web.FormController');

FormController = FormController.extend({
    _onSave: function () {
        console.log('Antes de salvar no client');
        this._super.apply(this, arguments);
    },
});
return FormController;

}); ```

• View Hooks: this.trigger_up('field_changed', { dataPointID, changes });
• Services: injetar customizações em web.core ou web.Model.

5. Boas Práticas e Performance

1. Evite laços desnecessários em callbacks: use filtered, mapped e read_group.
2. Store=True em campos computados críticos para relatórios.
3. Modularização: crie módulos pequenos e reutilizáveis.
4. Testes Automatizados: garanta que hooks não introduzam regressões.

6. Potencie o Seu Projeto com a OpenCloud

Dominar hooks e callbacks é um passo importante, mas a complexidade cresce com o tempo. Para assegurar:

• Planeamento detalhado
• Qualidade de código
• Performance e segurança

Confie nos especialistas da OpenCloud. Visite www.opencloud.pro para conhecer as nossas soluções de implementação e suporte Odoo.
Somos parceiro oficial Odoo em Portugal:
https://www.odoo.com/partners/opencloud-unipessoal-lda-12774

Conclusão
Hooks e callbacks são a chave para a extensibilidade máxima no Odoo, permitindo personalizações robustas e manuteníveis. Experimente os exemplos acima e contacte a OpenCloud para levar o seu ERP ao próximo nível!