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 estão localizados os repositórios Git relacionados aos seus projetos Odoo.
odoo é o usuário do GitHub.
odoo-addons é o repositório do GitHub.
feature-1 é o nome de uma branch de desenvolvimento.
main é o nome da branch de produçã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 Development.
Em Fork, selecione o branch main.
Em To, insira feature-1.

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

Assim que a compilação estiver pronta, você pode acessar o editor e o código do seu branch de desenvolvimento a partir da pasta ~/src/user.

Clone seu repositório 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¶

Scaffolding¶

Embora não seja obrigatório, o scaffolding evita o tédio de configurar a estrutura básica do módulo Odoo. Você pode criar um scaffold 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 classe 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 modelo com seus campos
views/views.xml uma visualização de árvore e um formulário, com os menus que os abrem
demo/demo.xml registros de demonstração para o modelo de exemplo
controllers/controllers.py um exemplo de controlador implementando algumas rotas
views/templates.xml duas visualizaçõ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 para serem confirmadas executando:
```
git add my_module
```
Confirme suas alterações executando:
```
git commit -m "My first module"
```
Envie suas alterações para 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 da 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 automaticamente o módulo, 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 tem 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 teste arrastando e soltando-o na seção Teste.
Mesclá-lo em um branch de teste existente arrastando e soltando-o sobre esse branch.
Usar o comando git merge para mesclar seus branches.

Isso cria uma nova compilação de teste 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 a partir do 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 objetivo da compilação de teste é testar o comportamento de 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 teste 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 teste sobre o branch de produção.
Usando o comando git merge para mesclar seus branches.

Isso mescla as últimas alterações do branch de teste 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 em 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 de descrição:
```
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 após:

<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 exigem que o módulo seja atualizado. Se você deseja que a atualização seja realizada 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 mudança de versão e acionará a atualização do módulo após a 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á este arquivo para instalar automaticamente as bibliotecas Python que seu projeto precisa.

Nota

Não é possível instalar ou atualizar pacotes de sistema em bancos de dados Odoo.sh (por exemplo, pacotes apt). No entanto, sob condições específicas, pacotes podem ser considerados para instalação. Isso também se aplica a módulos Python que requerem pacotes de 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 do 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 de nome do seu modelo. Para fazer isso, abra o arquivo models/models.py e antes:
```
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