Creare un modulo¶

Prima di creare il tuo primo modulo, è necessario creare un progetto Odoo.sh e conoscere l’URL del tuo repository GitHub.

Glossario

~/src è la directory in cui si trovano i repository Git relativi ai tuoi progetti Odoo.
odoo è l’utente GitHub.
odoo-addons è il repository GitHub.
feature-1 è il nome di un branch di sviluppo.
main è il nome del branch di produzione.
my_module è il nome del modulo.

Sostituiscili secondo necessità.

Creare il ramo di sviluppo¶

Dalla vista Branches:

Nel pannello di navigazione dei rami, fare clic sul pulsante ＋ (Nuovo ramo di sviluppo) accanto a Development.
In Fork, selezionare il ramo main.
In To, inserire feature-1.

Biforcazione del ramo di produzione per creare un ramo di sviluppo su Odoo.sh

Una volta che la build è pronta, è possibile accedere all”editor e al codice del ramo di sviluppo dalla cartella ~/src/user.

Clonare il repository GitHub sul computer eseguendo i seguenti comandi:

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

Creare un nuovo ramo eseguendo:
```
git checkout -b feature-1 main
```

Creare la struttura del modulo¶

Scaffolding¶

Sebbene non sia obbligatorio, lo scaffolding evita la noia di impostare la struttura di base del modulo Odoo. È possibile creare lo scaffold di un nuovo modulo utilizzando l’eseguibile odoo-bin.

Dal terminale dell”editor, eseguire:

odoo-bin scaffold my_module ~/src/user/

Con Odoo installato sul computer, eseguire:

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

Suggerimento

Se non si desidera installare Odoo sul computer, è anche possibile scaricare questo modello di struttura del modulo. Sostituire ogni occorrenza di my_module con il nome scelto.

Verrà generata la seguente struttura:

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

Avvertimento

Utilizzare solo caratteri alfanumerici (a-z, 0-9) o trattini bassi (_) quando si nomina il modulo, poiché il suo nome viene utilizzato per le classi Python e i nomi di classe contenenti caratteri speciali diversi dai trattini bassi non sono validi in Python.

Rimuovere il commento dai seguenti file:

models/models.py un esempio di modello con i suoi campi
views/views.xml una vista ad albero e una vista modulo, con i menu che le aprono
demo/demo.xml record demo per il modello di esempio
controllers/controllers.py un esempio di controller che implementa alcune rotte
views/templates.xml due esempi di viste qweb utilizzate dalle rotte del controller
__manifest__.py il manifest del modulo, che include il titolo, la descrizione e i file di dati da caricare. Rimuovere il commento dal file di dati della lista di controllo accessi:
```
# 'security/ir.model.access.csv',
```

Manuale¶

Per creare manualmente la struttura del modulo, seguire il tutorial Server framework 101 per comprendere la struttura di un modulo e il contenuto di ciascun file.

Pubblicare sul ramo di sviluppo¶

Preparare le modifiche da committare eseguendo:
```
git add my_module
```
Committare le modifiche eseguendo:
```
git commit -m "My first module"
```
Pubblicare le modifiche sul repository remoto eseguendo:
Dal terminale dell”editor, eseguire:
git push https HEAD:feature-1
Vedi anche
Documentazione dell’editor online: committare e pubblicare le modifiche
Eseguire:
git push -u origin feature-1
È necessario specificare -u origin feature-1 solo la prima volta che si pubblica. Successivamente, eseguire:
git push

Testare il modulo¶

Il ramo dovrebbe apparire nella sezione Sviluppo del pannello di navigazione della vista Rami.

Fare clic sul nome del ramo per visualizzare la cronologia, incluse le modifiche appena pubblicate. Una volta che il database è pronto, fare clic su Connetti per accedervi.

Il pulsante di connessione per accedere a un database

Se il progetto Odoo.sh è configurato per installare automaticamente il modulo, apparirà direttamente sulla dashboard del database. In caso contrario, sarà disponibile per l’installazione nell’app Applicazioni.

Il nuovo modulo sulla dashboard del database

Testare con i dati di produzione¶

Nota

Per questo passaggio è necessario un database di produzione. Se non ne hai ancora uno, crealo.

Dopo aver testato il modulo in una build di sviluppo con i dati demo e ritenere che sia pronto, è possibile testarlo con i dati di produzione utilizzando un ramo di staging.

Puoi:

Convertire il tuo ramo di sviluppo in un ramo di staging trascinandolo nella sezione Staging.
Unirlo in un ramo di staging esistente trascinandolo su quel ramo.
Usare il comando git merge per unire i tuoi rami.

Questo crea una nuova build di staging che duplica il database di produzione e lo esegue su un server aggiornato con le ultime modifiche del tuo ramo.

Una volta che il database è pronto, fai clic su Connetti per accedervi.

Installare il modulo¶

Installa il modulo dall’app Applicazioni. Poiché il modulo potrebbe non apparire direttamente nell’elenco delle applicazioni, aggiorna l’elenco delle applicazioni attivando la modalità sviluppatore e facendo clic su Aggiorna lista applicazioni ‣ Aggiorna.

Nota

Il modulo non viene installato automaticamente, poiché lo scopo della build di staging è testare il comportamento delle tue modifiche come sarebbero sul database di produzione, quindi non vorresti che un modulo venga installato automaticamente.

Distribuire in produzione¶

Dopo aver testato il modulo in un ramo di staging con i dati di produzione e aver verificato che sia pronto per la produzione, puoi unire il tuo ramo nel ramo di produzione:

Trascinando il ramo di staging sul ramo di produzione.
Usando il comando git merge per unire i tuoi rami.

Questo unisce le ultime modifiche dal ramo di staging nel ramo di produzione e aggiorna il server di produzione con esse.

Una volta che il database è pronto, fai clic su Connetti per accedervi.

Installare il modulo¶

Aggiungere una modifica¶

Questa sezione spiega come aggiungere una modifica nel tuo modulo aggiungendo un nuovo campo in un modello e distribuendolo.

Dall”editor o dal tuo computer, apri la cartella del modulo ~/src/odoo-addons/my_module, quindi apri il file models/models.py per modificarlo. Dopo il campo description:
```
description = fields.Text()
```
aggiungi un campo datetime:
```
start_datetime = fields.Datetime('Start time', default=lambda self: fields.Datetime.now())
```

Apri il file views/views.xml e dopo:

<field name="value2"/>

aggiungi:

<field name="start_datetime"/>

Queste modifiche alterano la struttura del database aggiungendo una colonna a una tabella e modificando una vista. Per essere applicate a un database esistente, come il tuo database di produzione, queste modifiche richiedono l’aggiornamento del modulo. Se desideri che l’aggiornamento venga eseguito automaticamente dalla piattaforma Odoo.sh quando invii le tue modifiche, aumenta la versione del modulo nel suo manifest aprendo __manifest__.py e sostituendo:
```
'version': '0.1',
```
con:
```
'version': '0.2',
```
La piattaforma rileverà una modifica della versione e attiverà l’aggiornamento del modulo al momento del deployment della nuova revisione.
Successivamente, invia le modifiche.
Una volta testate le modifiche, puoi unirle al ramo di produzione, ad esempio trascinando e rilasciando il ramo sul ramo di produzione nell’interfaccia di Odoo.sh. Poiché hai aumentato la versione del modulo nel manifest, la piattaforma aggiornerà automaticamente il modulo e il tuo nuovo campo sarà immediatamente disponibile. Altrimenti, puoi aggiornare manualmente il modulo dall’elenco delle applicazioni.

Utilizzare una libreria Python esterna¶

Se desideri utilizzare una libreria Python esterna che non è installata per impostazione predefinita, puoi definire un file requirements.txt che elenca le librerie esterne da cui dipendono i tuoi moduli. La piattaforma utilizzerà questo file per installare automaticamente le librerie Python necessarie per il tuo progetto.

Nota

Non è possibile installare o aggiornare pacchetti di sistema sui database Odoo.sh (ad esempio, pacchetti apt). Tuttavia, in condizioni specifiche, i pacchetti possono essere presi in considerazione per l’installazione. Questo vale anche per i moduli Python che richiedono pacchetti di sistema per la compilazione e per i moduli Odoo di terze parti.
Le estensioni PostgreSQL non sono supportate su Odoo.sh, pertanto non è possibile installare estensioni (come PostGIS, ltree, …) nei database Odoo.sh.

Ad esempio, per utilizzare la libreria Unidecode nel tuo modulo:

Crea un file requirements.txt nella cartella principale del tuo repository:
- Dall’editor di Odoo.sh, crea e apri il file ~/src/user/requirements.txt.
- Dal tuo computer, crea e apri il file ~/src/odoo-addons/requirements.txt.
Aggiungi al file:
```
unidecode
```
Ora puoi utilizzare la libreria nel tuo modulo, ad esempio, per rimuovere gli accenti dai caratteri nel campo nome del tuo modello. Per farlo, apri il file models/models.py e prima:
```
from odoo import models, fields, api
```
aggiungi:
```
from unidecode import unidecode
```

Dopo:

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

aggiungi:

@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 versione del modulo per installare la dipendenza Python modificando il manifest del modulo __manifest__.py.
Quindi, invia le modifiche.

Suggerimento
Aggiungi il file requirements.txt allo stage eseguendo git add requirements.txt.

Modificare su GitHub