Crear un módulo¶

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

Glosario

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

Bifurcación de 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 equipo 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¶

Estructura básica¶

Aunque no es obligatorio, la estructura básica evita la tediosa tarea de configurar la estructura básica del módulo de Odoo. Puedes crear la estructura básica de un nuevo módulo utilizando el ejecutable odoo-bin.

Desde la terminal del editor, ejecuta:

odoo-bin scaffold my_module ~/src/user/

Con Odoo instalado en tu equipo, ejecuta:

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

Truco

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

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

Utiliza solo caracteres alfanuméricos (a-z, 0-9) o guiones bajos (_) al nombrar tu módulo, ya que su nombre se utiliza 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 controlador que implementa algunas rutas
views/templates.xml dos vistas qweb de ejemplo 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 lista de control de acceso:
```
# 'security/ir.model.access.csv',
```

Manualmente¶

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

Subir 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"
```
Sube tus cambios a tu repositorio remoto ejecutando:
Desde la terminal del editor, ejecuta:
git push https HEAD:feature-1
Ver también
Documentación del editor en línea: confirmar y subir cambios
Ejecuta:
git push -u origin feature-1
Solo es necesario especificar -u origin feature-1 la primera vez que subes. Después de eso, ejecuta:
git push

Probar el módulo¶

La rama debería aparecer en la sección Development 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 subir. Una vez que la base de datos esté lista, haz clic en Connect para acceder a ella.

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

Si tu proyecto 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 su 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 utilizando una rama de preparación.

Puedes:

Convierte tu rama de desarrollo en una rama de preparación arrastrándola y soltándola en la sección Preparación.
Combínala con una rama de preparación existente arrastrándola y soltándola sobre esa rama.
Usa el comando git merge para combinar tus ramas.

Esto crea una nueva compilación de preparación 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.

Instala el módulo¶

Instala el módulo desde la aplicación Apps. Como es posible que el módulo no aparezca directamente en la lista de aplicaciones, actualiza la lista de aplicaciones activando el modo 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 preparación 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 preparación con los datos de producción y creas que está listo para producción, puedes combinar tu rama con la rama de producción mediante:

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

Esto combina los últimos cambios de la rama de preparación 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.

Instala 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 y 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 de:

<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 se actualice. Si deseas que la actualización se realice automáticamente por la plataforma Odoo.sh cuando envíes tus cambios, incrementa 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 al implementar 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 desde la lista de aplicaciones.

Usar una biblioteca externa de Python¶

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

Nota

No es posible instalar o actualizar paquetes del sistema en las bases de datos de Odoo.sh (por ejemplo, paquetes apt). Sin embargo, bajo condiciones específicas, los paquetes pueden considerarse para su instalación. Esto también se aplica a los módulos de Python que requieren paquetes del sistema para su compilación y a los módulos de terceros de Odoo.
Las extensiones de PostgreSQL no son compatibles con Odoo.sh, 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 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 name de tu modelo. Para ello, abre el archivo models/models.py y antes de:
```
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 de Python editando el manifiesto del módulo __manifest__.py.
A continuación, envía los cambios.

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

Editar en GitHub