Criar um módulo¶

Antes de criar seu primeiro módulo, é necessário criar um projeto Odoo.sh e conhecer a URL do seu repositório GitHub.

Glossário

~/src é o diretório onde os repositórios Git relacionados aos seus projetos Odoo estão localizados.
odoo é o usuário do GitHub.
odoo-addons é o repositório do GitHub.
feature-1 é o nome de um branch de desenvolvimento.
O main é o nome do branch de produção.
O my_module é o nome do módulo.

Substitua-os conforme necessário.

Criar a ramificação de desenvolvimento¶

No painel de navegação de branches, clique no botão ＋ (Novo branch de desenvolvimento) ao lado de Desenvolvimento.
Em Fork, selecione o branch main.
Em Para, digite feature-1.

Bifurcando o branch de produção para criar um branch de desenvolvimento no Odoo.sh

Assim que a build estiver pronta, você pode acessar o editor e o código do seu branch de desenvolvimento na pasta ~/src/user.

Clone seu repositório do GitHub em seu computador executando os seguintes comandos:

mkdir ~/src
cd ~/src
git clone https://github.com/odoo/odoo-addons.git
cd ~/src/odoo-addons

Crie um novo branch executando:
```
git checkout -b feature-1 main
```

Criar a estrutura do módulo¶

Estrutura básica¶

Embora não seja obrigatório, criar a estrutura básica evita o tédio de configurar a estrutura básica do módulo Odoo. Você pode criar a estrutura de um novo módulo usando o executável odoo-bin.

No terminal do editor, execute:

odoo-bin scaffold my_module ~/src/user/

Com o Odoo instalado em seu computador, execute:

./odoo-bin scaffold my_module ~/src/odoo-addons/

Dica

Se você não quiser instalar o Odoo em seu computador, também pode baixar este modelo de estrutura de módulo. Substitua todas as ocorrências de my_module pelo nome de sua escolha.

A estrutura abaixo será gerada:

my_module
├── __init__.py
├── __manifest__.py
├── controllers
│   ├── __init__.py
│   └── controllers.py
├── demo
│   └── demo.xml
├── models
│   ├── __init__.py
│   └── models.py
├── security
│   ├── ir.model.access.csv
│   └── models.py
└── views
    ├── templates.xml
    └── views.xml

Aviso

Use apenas caracteres alfanuméricos (a-z, 0-9) ou sublinhados (_) ao nomear seu módulo, pois seu nome é usado para classes Python, e nomes de classes contendo caracteres especiais além de sublinhados não são válidos em Python.

Descomente os seguintes arquivos:

models/models.py um exemplo de um modelo com seus campos
views/views.xml uma visão de árvore e uma visão de formulário, com os menus que as abrem
demo/demo.xml registros de demonstração para o modelo de exemplo
controllers/controllers.py um exemplo de um controlador implementando algumas rotas
views/templates.xml duas visões qweb de exemplo usadas pelas rotas do controlador
__manifest__.py o manifesto do seu módulo, incluindo seu título, descrição e arquivos de dados a serem carregados. Descomente o arquivo de dados da lista de controle de acesso:
```
# 'security/ir.model.access.csv',
```

Manualmente¶

Para criar a estrutura do seu módulo manualmente, siga o tutorial Server framework 101 para entender a estrutura de um módulo e o conteúdo de cada arquivo.

Enviar para o branch de desenvolvimento¶

Prepare as alterações a serem confirmadas executando:
```
git add my_module
```
Confirme suas alterações executando:
```
git commit -m "My first module"
```
Envie suas alterações para o seu repositório remoto executando:
No terminal do editor, execute:
git push https HEAD:feature-1
Veja também
Documentação do editor online: confirmando e enviando alterações
Execute:
git push -u origin feature-1
É necessário especificar -u origin feature-1 apenas na primeira vez que você enviar. Depois disso, execute:
git push

Testar o módulo¶

O branch deve aparecer na seção Desenvolvimento do painel de navegação Visualização de branches.

Clique no nome do branch para visualizar seu histórico, incluindo as alterações que você acabou de enviar. Quando o banco de dados estiver pronto, clique em Conectar para acessá-lo.

O botão conectar para acessar um banco de dados

Se o seu projeto Odoo.sh estiver configurado para instalar o módulo automaticamente, ele aparecerá diretamente no painel do banco de dados. Caso contrário, estará disponível para instalação no aplicativo Aplicativos.

O novo módulo no painel do banco de dados

Testar com os dados de produção¶

Nota

Um banco de dados de produção é necessário para esta etapa. Se você ainda não tiver um, crie-o.

Depois de testar o módulo em uma compilação de desenvolvimento com os dados de demonstração e acreditar que está pronto, você pode testá-lo com os dados de produção usando um branch de preparação.

Você pode:

Converter seu branch de desenvolvimento em um branch de preparação arrastando e soltando-o na seção Preparação.
Mesclá-lo em um branch de preparação existente arrastando e soltando-o sobre esse branch.
Use o comando git merge para mesclar seus branches.

Isso cria uma nova compilação de preparação que duplica o banco de dados de produção e o executa em um servidor atualizado com as últimas alterações do seu branch.

Quando o banco de dados estiver pronto, clique em Conectar para acessá-lo.

Instalar o módulo¶

Instale o módulo no aplicativo Aplicativos. Como o módulo pode não aparecer diretamente na lista de aplicativos, atualize a lista de aplicativos ativando o modo de desenvolvedor e clicando em Atualizar Lista de Aplicativos ‣ Atualizar.

Nota

O módulo não é instalado automaticamente, pois o propósito da compilação de preparação é testar o comportamento das suas alterações como elas estariam no banco de dados de produção, então você não gostaria que um módulo fosse instalado automaticamente.

Implementar em produção¶

Depois de testar o módulo em um branch de preparação com os dados de produção e acreditar que está pronto para produção, você pode mesclar seu branch no branch de produção:

Arrastando e soltando o branch de preparação sobre o branch de produção.
Usando o comando git merge para mesclar seus branches.

Isso mescla as últimas alterações do branch de preparação no branch de produção e atualiza o servidor de produção com elas.

Quando o banco de dados estiver pronto, clique em Conectar para acessá-lo.

Instalar o módulo¶

Adicionar uma alteração¶

Esta seção explica como adicionar uma alteração no seu módulo adicionando um novo campo em um modelo e implantando-o.

No editor ou no seu computador, abra a pasta do módulo ~/src/odoo-addons/my_module, depois abra o arquivo models/models.py para editá-lo. Após o campo description:
```
description = fields.Text()
```
adicione um campo datetime:
```
start_datetime = fields.Datetime('Start time', default=lambda self: fields.Datetime.now())
```

Abra o arquivo views/views.xml e depois de:

<field name="value2"/>

adicione:

<field name="start_datetime"/>

Essas alterações modificam a estrutura do banco de dados adicionando uma coluna a uma tabela e modificando uma visualização. Para serem aplicadas a um banco de dados existente, como seu banco de dados de produção, essas alterações requerem que o módulo seja atualizado. Se você deseja que a atualização seja executada automaticamente pela plataforma Odoo.sh quando você enviar suas alterações, aumente a versão do módulo em seu manifesto abrindo __manifest__.py e substituindo:
```
'version': '0.1',
```
com:
```
'version': '0.2',
```
A plataforma detectará uma alteração de versão e acionará a atualização do módulo na implantação da nova revisão.
Em seguida, envie as alterações.
Depois de testar suas alterações, você pode mesclá-las no branch de produção, por exemplo, arrastando e soltando o branch no branch de produção na interface do Odoo.sh. Como você aumentou a versão do módulo no manifesto, a plataforma atualizará automaticamente o módulo e seu novo campo estará disponível imediatamente. Caso contrário, você pode atualizar o módulo manualmente na lista de aplicativos.

Usar uma biblioteca Python externa¶

Se você deseja usar uma biblioteca Python externa que não está instalada por padrão, pode definir um arquivo requirements.txt listando as bibliotecas externas das quais seus módulos dependem. A plataforma usará esse arquivo para instalar automaticamente as bibliotecas Python que seu projeto precisa.

Nota

Não é possível instalar ou atualizar pacotes do sistema em bancos de dados Odoo.sh (por exemplo, pacotes apt). No entanto, sob condições específicas, os pacotes podem ser considerados para instalação. Isso também se aplica a módulos Python que requerem pacotes do sistema para compilação e a módulos Odoo de terceiros.
Extensões PostgreSQL não são suportadas no Odoo.sh, portanto, não é possível instalar extensões (como PostGIS, ltree, …) em bancos de dados Odoo.sh.

Por exemplo, para usar a biblioteca Unidecode em seu módulo:

Crie um arquivo requirements.txt na pasta raiz do seu repositório:
- No editor Odoo.sh, crie e abra o arquivo ~/src/user/requirements.txt.
- No seu computador, crie e abra o arquivo ~/src/odoo-addons/requirements.txt.
Adicione ao arquivo:
```
unidecode
```
Agora você pode usar a biblioteca em seu módulo, por exemplo, para remover acentos de caracteres no campo nome do seu modelo. Para fazer isso, abra o arquivo models/models.py e antes de:
```
from odoo import models, fields, api
```
adicione:
```
from unidecode import unidecode
```

Depois:

start_datetime = fields.Datetime('Start time', default=lambda self: fields.Datetime.now())

adicione:

@api.model
def create(self, values):
    if 'name' in values:
        values['name'] = unidecode(values['name'])
    return super(my_module, self).create(values)

def write(self, values):
    if 'name' in values:
        values['name'] = unidecode(values['name'])
    return super(my_module, self).write(values)

Aumente a versão do módulo para instalar a dependência Python editando o manifesto do módulo __manifest__.py.
Em seguida, envie as alterações.

Dica
Prepare o arquivo requirements.txt executando git add requirements.txt.

Editar no GitHub