Crear un módulo¶

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

Glosario

~/src es el directorio donde se encuentran los repositorios 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.

Reemplázalos según sea necesario.

Cree la rama de desarrollo¶

En el panel de navegación de ramas, haz clic en el botón ＋ (Nueva rama de desarrollo) 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 ordenador ejecutando los siguientes comandos:

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

Crea una nueva rama ejecutando:
```
git checkout -b feature-1 main
```

Cree una estructura de modelo¶

Estructuración¶

Aunque no es obligatorio, la estructuración evita el trabajo tedioso de configurar la estructura básica del módulo de Odoo. Puedes estructurar un nuevo módulo usando el ejecutable odoo-bin.

Desde el terminal del editor, ejecuta:

odoo-bin scaffold my_module ~/src/user/

Con Odoo instalado en tu ordenador, ejecuta:

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

Truco

Si no quieres instalar Odoo en tu ordenador, 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.

Se 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

Solo usa caracteres alfanuméricos (a-z, 0-9) o guiones bajos (_) al nombrar tu módulo, ya que su nombre se usa para 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 ejemplos de vistas qweb utilizadas por las rutas del controlador
__manifest__.py el manifiesto de tu módulo, incluyendo su título, descripción y archivos de datos a cargar. Descomenta el archivo de datos de la lista de control de acceso:
```
# 'security/ir.model.access.csv',
```

Manualmente¶

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

Envía los cambios a la rama de desarrollo¶

Prepara los cambios para confirmarlos ejecutando:
```
git add my_module
```
Confirma tus cambios ejecutando:
```
git commit -m "My first module"
```
Envía tus cambios a tu repositorio remoto ejecutando:
Desde el terminal del editor, ejecuta:
git push https HEAD:feature-1
Ver también
Documentación del editor en línea: confirmar y enviar cambios
Ejecuta:
git push -u origin feature-1
Solo es necesario especificar -u origin feature-1 la primera vez que envías. Después de eso, ejecuta:
git push

Prueba el módulo¶

La rama debería aparecer bajo la sección Desarrollo del panel de navegación Vista de ramas.

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

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

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

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

Probar con los datos de producción¶

Nota

Se requiere una base de datos de producción para este paso. 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 creas que está listo, puedes probarlo con los datos de producción usando una rama de pruebas.

Puedes:

Convertir tu rama de desarrollo en una rama de pruebas arrastrándola y soltándola en la sección Pruebas.
Fusionarla en una rama de pruebas existente arrastrándola y soltándola 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.

Una vez que 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 el módulo puede no aparecer directamente en la lista de aplicaciones, actualiza la lista de aplicaciones activando el modo de desarrollador y haciendo clic en Actualizar lista de aplicaciones ‣ Actualizar.

Nota

El módulo no se instala automáticamente, ya que el propósito de la compilación de pruebas es probar el comportamiento de tus cambios tal como estarían en la base de datos de producción, por lo que no querrías que un módulo se instalara automáticamente.

Despliegue en producción¶

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

Arrastrando y soltando la rama de pruebas sobre la rama de producción.
Usando el comando git merge para fusionar tus ramas.

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

Una vez que 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 añadir un cambio en tu módulo agregando un nuevo campo en un modelo y desplegándolo.

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

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

<field name="value2"/>

añade:

<field name="start_datetime"/>

Estos cambios alteran la estructura de la base de datos añadiendo una columna a una tabla y modificando una vista. Para aplicarse a una base de datos existente, como tu base de datos de producción, estos cambios requieren que el módulo sea actualizado. Si deseas que la actualización se realice automáticamente por la plataforma Odoo.sh cuando envíes tus cambios, aumenta la versión del módulo en su manifiesto abriendo __manifest__.py y reemplazando:
```
'version': '0.1',
```
con:
```
'version': '0.2',
```
La plataforma detectará un cambio de versión y activará la actualización del módulo tras el despliegue de la nueva revisión.
A continuación, envía los cambios.
Una vez que hayas probado tus cambios, puedes fusionarlos en la rama de producción, por ejemplo, arrastrando y soltando la rama sobre la rama de producción en la interfaz de Odoo.sh. Dado que aumentaste la versión del módulo en el manifiesto, la plataforma actualizará automáticamente el módulo y tu nuevo campo estará disponible de inmediato. De lo contrario, puedes actualizar el módulo manualmente dentro de la lista de aplicaciones.

Usar una biblioteca externa de Python¶

Si deseas usar una biblioteca Python externa que no está instalada por defecto, puedes definir un archivo requirements.txt que liste las bibliotecas externas de las que dependen tus módulos. La plataforma usará este archivo para instalar automáticamente las bibliotecas Python que necesita tu proyecto.

Nota

No es posible instalar o actualizar paquetes del sistema en bases de datos de Odoo.sh (por ejemplo, paquetes apt). Sin embargo, bajo condiciones específicas, los paquetes pueden ser considerados para instalación. Esto también se aplica a módulos Python que requieren paquetes del sistema para su compilación y a módulos de Odoo de terceros.
Las extensiones de PostgreSQL no están soportadas en Odoo.sh, por lo que no es posible instalar extensiones (como PostGIS, ltree, …) en 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 ordenador, crea y abre el archivo ~/src/odoo-addons/requirements.txt.
Añade al archivo:
```
unidecode
```
Ahora puedes usar la biblioteca en tu módulo, por ejemplo, para eliminar acentos de caracteres en el campo de nombre de tu modelo. Para ello, abre el archivo models/models.py y antes:
```
from odoo import models, fields, api
```
añade:
```
from unidecode import unidecode
```

Después:

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

añade:

@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 Python editando el manifiesto del módulo __manifest__.py.
Luego, envía los cambios.

Truco
Prepara el archivo requirements.txt ejecutando git add requirements.txt.

Editar en GitHub