Crear un módulo¶

Antes de crear tu primer módulo, es necesario crear un proyecto de Odoo.sh y conocer la URL del 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 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) junto a Desarrollo.
En Fork, 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 computadora 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
```

Crea la estructura del módulo¶

Estructura básica¶

Si bien no es obligatorio, crear la estructura básica evita el trabajo tedioso de configurar la estructura básica de un módulo de Odoo. Puedes crear la estructura de un nuevo módulo usando 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 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

Usa 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 los 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 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 implementando algunas rutas
views/templates.xml dos vistas qweb de ejemplo usadas 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',
```

Manual¶

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.

Envía a la rama de desarrollo¶

Prepara los cambios para confirmar 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 la terminal del editor, ejecuta:
git push https HEAD:feature-1
Consulta
Documentación del editor en línea: confirmando y enviando 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 bajo la aplicación Aplicaciones.

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

Prueba 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 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 en 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 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 preparación es probar el comportamiento de tus cambios tal como serí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 en 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 agregar un cambio en tu módulo añadiendo un nuevo campo en un modelo y desplegándolo.

Desde el editor o desde tu computadora, abre la carpeta del módulo ~/src/odoo-addons/my_module, 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 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, 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 al implementar la nueva revisión.
A continuación, sube 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. Como 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 externa de Python 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 de Python que tu proyecto necesita.

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 considerarse para instalación. Esto también aplica a módulos de Python que requieren paquetes del sistema para compilación y a módulos de Odoo de terceros.
Las extensiones de PostgreSQL no son compatibles con Odoo.sh, por lo tanto, 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 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 en el campo de nombre de tu modelo. Para hacerlo, abre el archivo models/models.py y antes:
```
from odoo import models, fields, api
```
agrega:
```
from unidecode import unidecode
```

Después:

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 editando el manifiesto del módulo __manifest__.py.
Luego, sube los cambios.

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

Editar en GitHub