Een module aanmaken¶

Voordat je je eerste module aanmaakt, is het noodzakelijk om een Odoo.sh-project aan te maken en de URL van je GitHub-repository te kennen.

Woordenlijst

~/src is de map waar de Git-repositories gerelateerd aan je Odoo-projecten zich bevinden.
odoo is de GitHub-gebruiker.
odoo-addons is de GitHub-repository.
feature-1 is de naam van een ontwikkelingstak.
main is de naam van de productietak.
my_module is de naam van de module.

Vervang deze waar nodig.

Maak de ontwikkelingstak¶

Vanuit de Filialen-weergave:

Klik in het filialennavigatiepaneel op de ＋-knop (Nieuwe ontwikkelingsfiliale) naast Ontwikkeling.
Selecteer onder Fork de main-filiale.
Voer onder Naar feature-1 in.

De productiefiliale forken om een ontwikkelingsfiliale te maken op Odoo.sh

Zodra de build klaar is, heb je toegang tot de editor en de code van je ontwikkelingsfiliale vanuit de map ~/src/user.

Kloon je GitHub-repository op je computer door de volgende commando’s uit te voeren:

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

Maak een nieuwe filiale aan door uit te voeren:
```
git checkout -b feature-1 main
```

Maak de modulestructuur¶

Scaffolding¶

Hoewel het niet verplicht is, bespaart scaffolding het vervelende werk van het opzetten van de basisstructuur voor een Odoo-module. Je kunt een nieuwe module scaffolden met het uitvoerbare bestand odoo-bin.

Voer vanuit de editor-terminal uit:

odoo-bin scaffold my_module ~/src/user/

Voer met Odoo geïnstalleerd op je computer uit:

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

Tip

Als je Odoo niet op je computer wilt installeren, kun je ook dit sjabloon voor de modulestructuur downloaden. Vervang elke vermelding van my_module door de naam van je keuze.

De onderstaande structuur wordt gegenereerd:

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

Waarschuwing

Gebruik alleen alfanumerieke tekens (a-z, 0-9) of underscores (_) bij het benoemen van je module, aangezien de naam wordt gebruikt voor Python-klassen, en klassenamen met andere speciale tekens dan underscores niet geldig zijn in Python.

Verwijder de commentaarmarkering uit de volgende bestanden:

models/models.py een voorbeeld van een model met zijn velden
views/views.xml een boomweergave en een formulierweergave, met de menu’s die ze openen
demo/demo.xml demorecords voor het voorbeeldmodel
controllers/controllers.py een voorbeeld van een controller die enkele routes implementeert
views/templates.xml twee voorbeeld-qweb-weergaven die gebruikt worden door de controllerroutes
__manifest__.py het manifest van je module, inclusief de titel, beschrijving en te laden databestanden. Verwijder de commentaartekens van het databestand met de toegangscontrolelijst:
```
# 'security/ir.model.access.csv',
```

Handmatig¶

Volg de Server framework 101-tutorial om de structuur van een module en de inhoud van elk bestand te begrijpen als je de modulestructuur handmatig wilt maken.

Push naar de ontwikkelingsbranch¶

Zet de wijzigingen klaar om te committen door het volgende uit te voeren:
```
git add my_module
```
Commit je wijzigingen door het volgende uit te voeren:
```
git commit -m "My first module"
```
Push je wijzigingen naar je externe repository door het volgende uit te voeren:
Voer vanuit de editor-terminal uit:
git push https HEAD:feature-1
Zie ook
Documentatie online editor: wijzigingen committen en pushen
Voer uit:
git push -u origin feature-1
Je hoeft -u origin feature-1 alleen de eerste keer dat je pusht op te geven. Voer daarna uit:
git push

Test de module¶

De branch verschijnt onder de sectie Ontwikkeling van het navigatiepaneel Branches-weergave.

Klik op de branchnaam om de geschiedenis te bekijken, inclusief de wijzigingen die je zojuist hebt gepusht. Zodra de database klaar is, klik je op Verbinden om er toegang toe te krijgen.

De verbindingsknop om toegang te krijgen tot een database

Als je Odoo.sh-project is geconfigureerd om de module automatisch te installeren, verschijnt deze direct op het databasedashboard. Anders is deze beschikbaar voor installatie onder de app Apps.

De nieuwe module op het databasedashboard

Test met de productiegegevens¶

Notitie

Voor deze stap is een productiedatabase vereist. Maak er een aan als je die nog niet hebt.

Zodra je de module hebt getest in een ontwikkelingsbuild met de demodata en je denkt dat deze klaar is, kun je deze testen met de productiedata door een staging-branch te gebruiken.

Je kunt:

Converteer je ontwikkelingstak naar een stagingtak door deze te slepen en neer te zetten in de sectie Staging.
Voeg het samen met een bestaande stagingtak door het naar die tak te slepen en neer te zetten.
Gebruik het commando git merge om je takken samen te voegen.

Dit creëert een nieuwe stagingbuild die de productiedatabase dupliceert en deze draait op een server die is bijgewerkt met de laatste wijzigingen van je tak.

Zodra de database klaar is, klik je op Verbinden om toegang te krijgen.

Installeer de module¶

Installeer de module vanuit de app Apps. Omdat de module mogelijk niet direct in de lijst met apps verschijnt, werk je de lijst met apps bij door de ontwikkelaarsmodus te activeren en te klikken op Update Apps List ‣ Update.

Notitie

De module wordt niet automatisch geïnstalleerd, omdat het doel van de stagingbuild is om het gedrag van je wijzigingen te testen zoals ze op de productiedatabase zouden zijn, dus je wilt niet dat een module automatisch wordt geïnstalleerd.

Implementeren in productie¶

Zodra je de module hebt getest in een stagingtak met de productiegegevens en je denkt dat deze klaar is voor productie, kun je je tak samenvoegen met de productietak door:

De stagingtak naar de productietak te slepen en neer te zetten.
Het commando git merge te gebruiken om je takken samen te voegen.

Dit voegt de laatste wijzigingen van de stagingtak samen met de productietak en werkt de productieserver ermee bij.

Zodra de database klaar is, klik je op Verbinden om toegang te krijgen.

Installeer de module¶

Voeg een wijziging toe¶

Deze sectie legt uit hoe je een wijziging toevoegt aan je module door een nieuw veld in een model toe te voegen en dit te implementeren.

Open vanuit de editor of vanaf je computer de modulemap ~/src/odoo-addons/my_module, open vervolgens het bestand models/models.py om het te bewerken. Na het beschrijvingsveld:
```
description = fields.Text()
```
Voeg een datetime-veld toe:
```
start_datetime = fields.Datetime('Start time', default=lambda self: fields.Datetime.now())
```

Open het bestand views/views.xml en voeg na:

<field name="value2"/>

Voeg toe:

<field name="start_datetime"/>

Deze wijzigingen veranderen de databasestructuur door een kolom aan een tabel toe te voegen en een weergave te wijzigen. Om toegepast te worden op een bestaande database, zoals je productiedatabase, vereisen deze wijzigingen dat de module wordt bijgewerkt. Als je wilt dat de update automatisch wordt uitgevoerd door het Odoo.sh-platform wanneer je je wijzigingen pusht, verhoog je de versie van de module in het manifest door __manifest__.py te openen en te vervangen:
```
'version': '0.1',
```
met:
```
'version': '0.2',
```
Het platform detecteert een versiewijziging en activeert de module-update bij het deployen van de nieuwe revisie.
Vervolgens push je de wijzigingen.
Zodra je je wijzigingen hebt getest, kun je ze samenvoegen in de productiebranch, bijvoorbeeld door de branch te slepen en neer te zetten op de productiebranch in de Odoo.sh-interface. Omdat je de moduleversie in het manifest hebt verhoogd, zal het platform de module automatisch updaten en is je nieuwe veld direct beschikbaar. Anders kun je de module handmatig updaten in de lijst met apps.

Gebruik een externe Python-bibliotheek¶

Als je een externe Python-bibliotheek wilt gebruiken die niet standaard is geïnstalleerd, kun je een requirements.txt-bestand definiëren met een lijst van de externe bibliotheken waarvan je modules afhankelijk zijn. Het platform gebruikt dit bestand om automatisch de Python-bibliotheken te installeren die je project nodig heeft.

Notitie

Het is niet mogelijk om systeempakketten te installeren of upgraden op Odoo.sh-databases (bv. apt-pakketten). Onder specifieke voorwaarden kunnen `pakketten echter wel worden overwogen voor installatie<https://www.odoo.sh/faq#install_dependencies>`_. Dit geldt ook voor Python-modules die systeempakketten nodig hebben voor compilatie en voor Odoo-modules van derden.
PostgreSQL-extensies worden niet ondersteund op Odoo.sh, daarom is het niet mogelijk om extensies (zoals PostGIS, ltree, …) te installeren in Odoo.sh-databases.

Bijvoorbeeld, om de `Unidecode-bibliotheek<https://pypi.org/project/Unidecode>`_ in je module te gebruiken:

Maak een bestand requirements.txt aan in de hoofdmap van je repository:
- Maak en open vanuit de Odoo.sh-editor het bestand ~/src/user/requirements.txt.
- Maak en open vanaf je computer het bestand ~/src/odoo-addons/requirements.txt.
Voeg toe aan het bestand:
```
unidecode
```
Je kunt de bibliotheek nu in je module gebruiken, bijvoorbeeld om accenten te verwijderen uit tekens in het naamveld van je model. Open hiervoor het bestand models/models.py en vóór:
```
from odoo import models, fields, api
```
Voeg toe:
```
from unidecode import unidecode
```

Na:

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

Voeg toe:

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

Verhoog de moduleversie om de Python-afhankelijkheid te installeren door het manifest van de module __manifest__.py te bewerken.
Vervolgens push je de wijzigingen.

Tip
Stage het bestand requirements.txt door git add requirements.txt uit te voeren.

Bewerken op GitHub