Ein Modul erstellen¶

Bevor Sie Ihr erstes Modul erstellen, müssen Sie ein Odoo.sh-Projekt erstellen und die URL Ihres GitHub-Repositorys kennen.

Glossar

~/src ist das Verzeichnis, in dem sich die Git-Repositorys Ihrer Odoo-Projekte befinden.
odoo ist der GitHub-Benutzer.
odoo-addons ist das GitHub-Repository.
feature-1 ist der Name eines Entwicklungszweigs.
main ist der Name des Produktionszweigs.
my_module ist der Name des Moduls.

Ersetzen Sie diese bei Bedarf.

Den Entwicklungszweig erstellen¶

Von der Branches-Ansicht:

Im Navigationsbereich Branches klicken Sie auf die Schaltfläche ＋ (Neuer Entwicklungsbranch) neben Development.
Unter Fork wählen Sie den Branch main aus.
Unter To geben Sie feature-1 ein.

Forken des Produktionsbranchs zum Erstellen eines Entwicklungsbranchs auf Odoo.sh

Sobald der Build bereit ist, können Sie auf den Editor und den Code Ihres Entwicklungsbranchs aus dem Ordner ~/src/user zugreifen.

Klonen Sie Ihr GitHub-Repository auf Ihren Computer, indem Sie die folgenden Befehle ausführen:

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

Erstellen Sie einen neuen Branch, indem Sie Folgendes ausführen:
```
git checkout -b feature-1 main
```

Die Modulstruktur erstellen¶

Gerüst erstellen¶

Obwohl es nicht erforderlich ist, erspart das Erstellen eines Gerüsts die mühsame Einrichtung der grundlegenden Odoo-Modulstruktur. Sie können ein neues Modul mit der ausführbaren Datei odoo-bin erstellen.

Führen Sie im Editor-Terminal Folgendes aus:

odoo-bin scaffold my_module ~/src/user/

Mit Odoo auf Ihrem Computer installiert führen Sie Folgendes aus:

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

Tipp

Wenn Sie Odoo nicht auf Ihrem Computer installieren möchten, können Sie auch diese Modulstrukturvorlage herunterladen. Ersetzen Sie jedes Vorkommen von my_module durch den Namen Ihrer Wahl.

Die folgende Struktur wird generiert:

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

Warnung

Verwenden Sie beim Benennen Ihres Moduls nur alphanumerische Zeichen (a-z, 0-9) oder Unterstriche (_), da der Name für Python-Klassen verwendet wird und Klassennamen mit anderen Sonderzeichen als Unterstrichen in Python nicht gültig sind.

Entfernen Sie die Kommentarzeichen in den folgenden Dateien:

models/models.py ein Beispiel für ein Modell mit seinen Feldern
views/views.xml eine Baum- und eine Formularansicht mit den Menüs, die sie öffnen
demo/demo.xml Demodatensätze für das Beispielmodell
controllers/controllers.py ein Beispiel eines Controllers, der einige Routen implementiert
views/templates.xml zwei Beispiel-QWeb-Ansichten, die von den Controller-Routen verwendet werden
__manifest__.py das Manifest Ihres Moduls, einschließlich Titel, Beschreibung und zu ladenden Datendateien. Kommentieren Sie die Datendatei für die Zugriffskontrollliste aus:
```
# 'security/ir.model.access.csv',
```

Manuell¶

Um Ihre Modulstruktur manuell zu erstellen, folgen Sie dem Server framework 101-Tutorial, um die Struktur eines Moduls und den Inhalt jeder Datei zu verstehen.

Auf den Entwicklungszweig pushen¶

Stagen Sie die zu committenden Änderungen, indem Sie Folgendes ausführen:
```
git add my_module
```
Committen Sie Ihre Änderungen, indem Sie Folgendes ausführen:
```
git commit -m "My first module"
```
Pushen Sie Ihre Änderungen in Ihr Remote-Repository, indem Sie Folgendes ausführen:
Führen Sie im Editor-Terminal Folgendes aus:
git push https HEAD:feature-1
Siehe auch
Dokumentation zum Online-Editor: Änderungen committen und pushen
Führen Sie Folgendes aus:
git push -u origin feature-1
Es ist nur beim ersten Mal notwendig, -u origin feature-1 anzugeben, wenn Sie pushen. Danach führen Sie Folgendes aus:
git push

Das Modul testen¶

Der Zweig sollte unter dem Abschnitt Entwicklung im Navigationspanel der Zweigansicht erscheinen.

Klicken Sie auf den Zweignamen, um dessen Verlauf anzuzeigen, einschließlich der soeben gepushten Änderungen. Sobald die Datenbank bereit ist, klicken Sie auf Verbinden, um darauf zuzugreifen.

Die Verbinden-Schaltfläche für den Zugriff auf eine Datenbank

Wenn Ihr Odoo.sh-Projekt so konfiguriert ist, dass das Modul automatisch installiert wird, erscheint es direkt im Datenbank-Dashboard. Andernfalls ist es unter der App Apps zur Installation verfügbar.

Mit den Produktionsdaten testen¶

Bemerkung

Für diesen Schritt ist eine Produktionsdatenbank erforderlich. Falls Sie noch keine haben, erstellen Sie eine.

Sobald Sie das Modul in einem Entwicklungs-Build mit den Demodaten getestet haben und glauben, dass es fertig ist, können Sie es mit den Produktionsdaten in einem Staging-Zweig testen.

Sie können:

Konvertieren Sie Ihren Entwicklungszweig in einen Staging-Zweig, indem Sie ihn per Drag-and-Drop in den Abschnitt Staging ziehen.
Führen Sie ihn mit einem bestehenden Staging-Zweig zusammen, indem Sie ihn per Drag-and-Drop auf diesen Zweig ziehen.
Verwenden Sie den Befehl git merge, um Ihre Zweige zusammenzuführen.

Dadurch wird ein neuer Staging-Build erstellt, der die Produktionsdatenbank dupliziert und auf einem Server ausführt, der mit den neuesten Änderungen Ihres Zweigs aktualisiert wurde.

Sobald die Datenbank bereit ist, klicken Sie auf Verbinden, um darauf zuzugreifen.

Modul installieren¶

Installieren Sie das Modul über die App Apps. Da das Modul möglicherweise nicht direkt in der Liste der Apps angezeigt wird, aktualisieren Sie die Liste der Apps, indem Sie den Entwicklermodus aktivieren und auf Update Apps List ‣ Update klicken.

Bemerkung

Das Modul wird nicht automatisch installiert, da der Zweck des Staging-Builds darin besteht, das Verhalten Ihrer Änderungen so zu testen, wie sie in der Produktionsdatenbank wären, sodass Sie kein Modul automatisch installieren möchten.

In Produktion einsetzen¶

Nachdem Sie das Modul in einem Staging-Zweig mit den Produktionsdaten getestet haben und glauben, dass es für die Produktion bereit ist, können Sie Ihren Zweig mit dem Produktionszweig zusammenführen, indem Sie:

Den Staging-Zweig per Drag-and-Drop auf den Produktionszweig ziehen.
Den Befehl git merge verwenden, um Ihre Zweige zusammenzuführen.

Dadurch werden die neuesten Änderungen aus dem Staging-Zweig in den Produktionszweig übernommen und der Produktionsserver mit ihnen aktualisiert.

Sobald die Datenbank bereit ist, klicken Sie auf Verbinden, um darauf zuzugreifen.

Modul installieren¶

Eine Änderung hinzufügen¶

Dieser Abschnitt erklärt, wie Sie eine Änderung in Ihrem Modul hinzufügen, indem Sie ein neues Feld in einem Modell hinzufügen und es bereitstellen.

Öffnen Sie vom Editor oder von Ihrem Computer aus den Modulordner ~/src/odoo-addons/my_module und öffnen Sie dann die Datei models/models.py, um sie zu bearbeiten. Nach dem Beschreibungsfeld:
```
description = fields.Text()
```
fügen Sie ein Datetime-Feld hinzu:
```
start_datetime = fields.Datetime('Start time', default=lambda self: fields.Datetime.now())
```
Öffnen Sie die Datei views/views.xml und fügen Sie nach:
```
<field name="value2"/>
```
hinzu:
```
<field name="start_datetime"/>
```
Diese Änderungen verändern die Datenbankstruktur, indem sie eine Spalte zu einer Tabelle hinzufügen und eine Ansicht ändern. Um auf eine bestehende Datenbank wie Ihre Produktionsdatenbank angewendet zu werden, erfordern diese Änderungen eine Aktualisierung des Moduls. Wenn Sie möchten, dass die Aktualisierung automatisch von der Odoo.sh-Plattform durchgeführt wird, wenn Sie Ihre Änderungen pushen, erhöhen Sie die Version des Moduls in seinem Manifest, indem Sie __manifest__.py öffnen und ersetzen:
```
'version': '0.1',
```
mit:
```
'version': '0.2',
```
Die Plattform erkennt eine Versionsänderung und löst bei der Bereitstellung der neuen Revision die Modul-Aktualisierung aus.
Als Nächstes pushen Sie die Änderungen.
Sobald Sie Ihre Änderungen getestet haben, können Sie diese in den Produktionszweig zusammenführen, indem Sie beispielsweise den Zweig per Drag-and-Drop auf den Produktionszweig in der Odoo.sh-Oberfläche ziehen. Da Sie die Modulversion im Manifest erhöht haben, aktualisiert die Plattform das Modul automatisch und Ihr neues Feld ist sofort verfügbar. Andernfalls können Sie das Modul manuell in der App-Liste aktualisieren.

Eine externe Python-Bibliothek verwenden¶

Wenn Sie eine externe Python-Bibliothek verwenden möchten, die nicht standardmäßig installiert ist, können Sie eine requirements.txt-Datei definieren, die die externen Bibliotheken auflistet, von denen Ihre Module abhängen. Die Plattform verwendet diese Datei, um die Python-Bibliotheken, die Ihr Projekt benötigt, automatisch zu installieren.

Bemerkung

Es ist nicht möglich, Systempakete auf Odoo.sh-Datenbanken zu installieren oder zu aktualisieren (z. B. apt-Pakete). Unter bestimmten Bedingungen können jedoch Pakete zur Installation in Betracht gezogen werden. Dies gilt auch für Python-Module, die Systempakete für die Kompilierung benötigen, und für Odoo-Module von Drittanbietern.
PostgreSQL-Erweiterungen werden auf Odoo.sh nicht unterstützt, daher ist es nicht möglich, Erweiterungen (wie PostGIS, ltree usw.) in Odoo.sh-Datenbanken zu installieren.

Um beispielsweise die Unidecode-Bibliothek in Ihrem Modul zu verwenden:

Erstellen Sie eine Datei requirements.txt im Stammordner Ihres Repositorys:
- Erstellen und öffnen Sie im Odoo.sh-Editor die Datei ~/src/user/requirements.txt.
- Erstellen und öffnen Sie von Ihrem Computer aus die Datei ~/src/odoo-addons/requirements.txt.
Fügen Sie der Datei hinzu:
```
unidecode
```
Sie können die Bibliothek jetzt in Ihrem Modul verwenden, um beispielsweise Akzente aus Zeichen im Namensfeld Ihres Modells zu entfernen. Öffnen Sie dazu die Datei models/models.py und vor:
```
from odoo import models, fields, api
```
hinzu:
```
from unidecode import unidecode
```

Nach:

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

hinzu:

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

Erhöhen Sie die Modulversion, um die Python-Abhängigkeit zu installieren, indem Sie das Manifest des Moduls __manifest__.py bearbeiten.
Anschließend pushen Sie die Änderungen.

Tipp
Stagen Sie die Datei requirements.txt, indem Sie git add requirements.txt ausführen.

Auf GitHub bearbeiten