Crear un módulo¶

Antes de crear tu primer módulo, es necesario crear un proyecto de Odoo.sh y conocer la URL de tu repositorio de GitHub.

Glosario

~/src es el directorio donde se encuentran los repositorios de Git relacionados con tus proyectos de Odoo.
odoo es el usuario de GitHub.
odoo-addons es el repositorio de GitHub.
feature-1 es el nombre de una rama de desarrollo.
main es el nombre de la rama de producción.
my_module es el nombre del módulo.

Reemplaza estos valores según sea necesario.

Crea la rama de desarrollo¶

Desde la vista de Ramas:

En el panel de navegación de ramas, haz clic en el botón ＋ (Nueva rama de desarrollo) ubicado junto a Desarrollo.
En Bifurcar, selecciona la rama main.
En A, ingresa feature-1.

Bifurcar la rama de producción para crear una rama de desarrollo en Odoo.sh

Una vez que la compilación esté lista, puedes acceder al editor y al código de tu rama de desarrollo desde la carpeta ~/src/user.

Clona tu repositorio de GitHub en tu computadora con los siguientes comandos:

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

Crea una nueva rama con el siguiente comando:
```
git checkout -b feature-1 main
```

Crea la estructura del módulo¶

Estructura básica¶

Aunque no es obligatorio, crear la estructura básica evita el tedioso trabajo de configurar la estructura básica de un módulo de Odoo. Puedes crear la estructura de un módulo nuevo al usar el ejecutable odoo-bin.

Desde la terminal del editor, ejecuta:

odoo-bin scaffold my_module ~/src/user/

Con Odoo instalado en tu computadora, ejecuta:

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

Truco

Si no quieres instalar Odoo en tu computadora, también puedes descargar esta plantilla de estructura de módulo. Reemplaza cada aparición de my_module con el nombre de tu elección.

El sistema generará la siguiente estructura:

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

Advertencia

Usa solo caracteres alfanuméricos (a-z, 0-9) o guiones bajos (_) al nombrar tu módulo, ya que su nombre se usa para las clases de Python, y los nombres de clase que contienen caracteres especiales distintos de guiones bajos no son válidos en Python.

Descomenta los siguientes archivos:

models/models.py, un ejemplo de un modelo con sus campos
views/views.xml, una vista de árbol y una vista de formulario, con los menús que las abren
demo/demo.xml, registros de demostración para el modelo de ejemplo
controllers/controllers.py, un ejemplo de un controlador que implementa algunas rutas
views/templates.xml, dos vistas QWeb de ejemplo que usan las rutas del controlador
__manifest__.py, el manifiesto de tu módulo, que incluye su título, descripción y los archivos de datos a cargar. Descomenta el archivo de datos de la lista de control de acceso:
```
# 'security/ir.model.access.csv',
```

Manual¶

Para crear la estructura de tu módulo de forma manual, sigue el tutorial Server framework 101 para comprender la estructura de un módulo y el contenido de cada archivo.

Sube a la rama de desarrollo¶

Prepara los cambios que vas a confirmar con el siguiente comando:
```
git add my_module
```
Confirma tus cambios con el siguiente comando:
```
git commit -m "My first module"
```
Sube tus cambios a tu repositorio remoto con el siguiente comando:
Desde la terminal del editor, ejecuta:
git push https HEAD:feature-1
Consulta
Documentación del editor en línea: Confirmar y subir cambios
Ejecuta:
git push -u origin feature-1
Solo debes especificar -u origin feature-1 la primera vez que subas cambios. Después, ejecuta:
git push

Prueba el módulo¶

La rama debe aparecer en la sección Desarrollo del panel de navegación de la vista de Ramas.

Haz clic en el nombre de la rama para ver su historial, incluidos los cambios que acabas de subir. Una vez que la base de datos esté lista, haz clic en Conectar para acceder a ella.

El botón Conectar para acceder a una base de datos

Si tu proyecto de Odoo.sh está configurado para instalar el módulo de forma automática, aparecerá de forma directa en el tablero de la base de datos. De lo contrario, estará disponible para su instalación en la aplicación Aplicaciones.

El nuevo módulo en el tablero de la base de datos

Prueba con los datos de producción¶

Nota

Para este paso necesitas una base de datos de producción. Si aún no tienes una, créala.

Una vez que hayas probado el módulo en una compilación de desarrollo con los datos de demostración y consideres que está listo, puedes probarlo con los datos de producción mediante una rama de pruebas.

Puedes:

Convertir tu rama de desarrollo en una rama de pruebas al arrastrarla y soltarla en la sección Pruebas o Preparación.
Fusionarla con una rama de pruebas existente al arrastrarla y soltarla sobre esa rama.
Usar el comando git merge para fusionar tus ramas.

Esto crea una nueva compilación de pruebas que duplica la base de datos de producción y la ejecuta en un servidor actualizado con los últimos cambios de tu rama.

Cuando la base de datos esté lista, haz clic en Conectar para acceder a ella.

Instalar el módulo¶

Instala el módulo desde la aplicación Aplicaciones. Como es posible que el módulo no aparezca directamente en la lista de aplicaciones, actualiza la lista de aplicaciones al activar el modo de desarrollador y hacer clic en Actualizar lista de aplicaciones ‣ Actualizar.

Nota

El módulo no se instala de forma automática, ya que el objetivo de la compilación de pruebas es comprobar el comportamiento de tus cambios tal como estarían en la base de datos de producción, por lo que no querrás que un módulo se instale de forma automática.

Despliegue en producción¶

Una vez que hayas probado el módulo en una rama de pruebas con los datos de producción y consideres que está listo para producción, puedes fusionar tu rama con la rama de producción:

Arrastra y suelta la rama de pruebas sobre la rama de producción.
Usa el comando git merge para fusionar tus ramas.

Esto fusiona los últimos cambios de la rama de pruebas con la rama de producción y actualiza el servidor de producción con ellos.

Cuando la base de datos esté lista, haz clic en Conectar para acceder a ella.

Instalar el módulo¶

Agregar un cambio¶

Esta sección explica cómo agregar un cambio a tu módulo mediante la adición de un nuevo campo a un modelo y su implementación.

Desde el editor o desde tu computadora, abre la carpeta del módulo ~/src/odoo-addons/my_module y luego abre el archivo models/models.py para editarlo. Después del campo «description»:
```
description = fields.Text()
```
agrega un campo «datetime»:
```
start_datetime = fields.Datetime('Start time', default=lambda self: fields.Datetime.now())
```

Abre el archivo views/views.xml y después de:

<field name="value2"/>

agrega:

<field name="start_datetime"/>

Estos cambios modifican la estructura de la base de datos al agregar una columna a una tabla y modificar una vista. Para aplicarlos a una base de datos existente, como tu base de datos de producción, debes actualizar el módulo. Si quieres que la plataforma Odoo.sh realice la actualización de forma automática al subir tus cambios, aumenta la versión del módulo en su manifiesto. Para ello, abre __manifest__.py y reemplaza:
```
'version': '0.1',
```
con:
```
'version': '0.2',
```
La plataforma detectará el cambio de versión y activará la actualización del módulo al implementar la nueva revisión.
Después, sube los cambios.
Una vez que hayas probado tus cambios, puedes fusionarlos con la rama de producción, por ejemplo, al arrastrar y soltar la rama sobre la rama de producción en la interfaz de Odoo.sh. Como aumentaste la versión del módulo en el manifiesto, la plataforma actualizará el módulo de forma automática y tu nuevo campo estará disponible de inmediato. De lo contrario, puedes actualizar el módulo de forma manual desde la lista de aplicaciones.

Usar una biblioteca externa de Python¶

Si quieres usar una biblioteca externa de Python que no esté instalada de forma predeterminada, puedes definir un archivo requirements.txt que incluya las bibliotecas externas de las que dependen tus módulos. La plataforma usará este archivo para instalar de forma automática las bibliotecas de Python que tu proyecto necesita.

Nota

No es posible instalar ni actualizar paquetes del sistema en las bases de datos de Odoo.sh (por ejemplo, paquetes de apt). Sin embargo, bajo ciertas condiciones, puedes solicitar la instalación de paquetes. Esto también aplica a los módulos de Python que requieren paquetes del sistema para su compilación y a los módulos de Odoo de terceros.
Odoo.sh no admite extensiones de PostgreSQL, por lo que no es posible instalar extensiones (como PostGIS, ltree, etc.) en las bases de datos de Odoo.sh.

Por ejemplo, para usar la biblioteca Unidecode en tu módulo:

Crea un archivo requirements.txt en la carpeta raíz de tu repositorio:
- Desde el editor de Odoo.sh, crea y abre el archivo ~/src/user/requirements.txt.
- Desde tu computadora, crea y abre el archivo ~/src/odoo-addons/requirements.txt.
Agrega al archivo:
```
unidecode
```
Ahora puedes usar la biblioteca en tu módulo, por ejemplo, para eliminar acentos de los caracteres del campo de nombre de tu modelo. Para hacerlo, abre el archivo models/models.py y antes de:
```
from odoo import models, fields, api
```
agrega:
```
from unidecode import unidecode
```

Después de:

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

agrega:

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

Aumenta la versión del módulo para instalar la dependencia de Python. Para ello, edita el manifiesto del módulo __manifest__.py.
Luego, sube los cambios.

Truco
Prepara el archivo requirements.txt con el comando git add requirements.txt.

Editar en GitHub