Skapa en modul¶

Innan du skapar din första modul är det nödvändigt att skapa ett Odoo.sh-projekt och känna till din GitHub-förvarings URL.

Ordlista

~/src är registret där Git-förvaren relaterade till dina Odoo-projekt finns.
odoo är GitHub-användaren.
odoo-addons är GitHub-förvaret.
feature-1 är namnet på en utvecklingsfilial.
main är namnet på produktionsfilialen.
my_module är namnet på modulen.

Ersätt dessa efter behov.

Skapa utvecklingsgrenen¶

Från filialer-vyn:

I navigationspanelen för filialer, klicka på knappen ＋ (Ny utvecklingsfilial) bredvid Utveckling.
Under Förgrening, välj filialen main.
Under Till, ange feature-1.

Förgrening av produktionsfilialen för att skapa en utvecklingsfilial på Odoo.sh

När bygget är klart kan du komma åt redigeraren och koden för din utvecklingsfilial från mappen ~/src/user.

Klona ditt GitHub-förråd på din dator genom att köra följande kommandon:

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

Skapa en ny filial genom att köra:
```
git checkout -b feature-1 main
```

Skapa modulens struktur¶

Byggnadsställning¶

Även om det inte är obligatoriskt undviker byggnadsställning tråkigheten med att sätta upp den grundläggande Odoo-modulstrukturen. Du kan skapa en ny modul med hjälp av den körbara filen odoo-bin.

Från redigerarens terminal, kör:

odoo-bin scaffold my_module ~/src/user/

Med Odoo installerat på din dator, kör:

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

Tips

Om du inte vill installera Odoo på din dator kan du också ladda ner denna modulstrukturmall. Ersätt varje förekomst av my_module med namnet du valt.

Strukturen nedan kommer att genereras:

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

Varning

Använd endast alfanumeriska tecken (a-z, 0-9) eller understreck (_) när du namnger din modul, eftersom dess namn används för Python-klasser, och klassnamn som innehåller specialtecken andra än understreck är inte giltiga i Python.

Avkommentera följande filer:

models/models.py ett exempel på en modell med dess fält
views/views.xml en trädvy och en formulärvy, med menyerna som öppnar dem
demo/demo.xml demoposter för exempelmodellen
controllers/controllers.py ett exempel på en controller som implementerar några rutter
views/templates.xml två exempel på qweb-vyer som används av controller-rutterna
__manifest__.py manifestet för din modul, inklusive dess rubrik, beskrivning och datafiler att ladda. Avkommentera datafilens åtkomstkontrollista:
```
# 'security/ir.model.access.csv',
```

Manuellt¶

För att skapa din modulstruktur manuellt, följ handledningen Server framework 101 för att förstå strukturen på en modul och innehållet i varje fil.

Pusha till utvecklingsfilial¶

Förbered ändringarna som ska committas genom att köra:
```
git add my_module
```
Committa dina ändringar genom att köra:
```
git commit -m "My first module"
```
Pusha dina ändringar till din fjärrrepository genom att köra:
Från redigerarens terminal, kör:
git push https HEAD:feature-1
Se även
Onlineredigerarens dokumentation: committa och pusha ändringar
Kör:
git push -u origin feature-1
Det är bara nödvändigt att ange -u origin feature-1 första gången du pushar. Därefter kör:
git push

Testa modulen¶

Filialen ska visas under sektionen Utveckling i navigeringspanelen Filialvy.

Klicka på filialnamnet för att visa dess historik, inklusive ändringarna du just pushade. När databasen är klar klickar du på Anslut för att komma åt den.

Anslutningsknappen för att komma åt en databas

Om ditt Odoo.sh-projekt är konfigurerat att automatiskt installera modulen kommer den att visas direkt på databasdashboarden. Annars kommer den att vara tillgänglig för installation under appen Appar.

Test med produktionsdata¶

Observera

En produktionsdatabas krävs för detta steg. Om du inte har en ännu, skapa en.

När du har testat modulen i en utvecklingsbygge med demodata och tror att den är klar kan du testa den med produktionsdata genom att använda en testförgrening.

Du kan:

Konvertera din utvecklingsfilial till en testförgrening genom att dra och släppa den i sektionen Staging.
Sammanfoga den med en befintlig testförgrening genom att dra och släppa den på den filialen.
Använd kommandot git merge för att sammanfoga dina filialer.

Detta skapar ett nytt testbygge som duplicerar produktionsdatabasen och kör den på en server uppdaterad med din filials senaste ändringar.

När databasen är klar klickar du på Connect för att komma åt den.

Installera modulen¶

Installera modulen från appen Appar. Eftersom modulen kanske inte visas direkt i listan över appar, uppdatera listan över appar genom att aktivera läget för systemutvecklare och klicka på Update Apps List ‣ Update.

Observera

Modulen installeras inte automatiskt, eftersom syftet med testbygget är att testa beteendet hos dina ändringar som de skulle vara på produktionsdatabasen, så du skulle inte vilja ha en modul installerad automatiskt.

Driftsättning i produktion¶

När du har testat modulen i en testförgrening med produktionsdata och tror att den är klar för produktion kan du sammanfoga din filial med produktionsfilialen genom att:

Dra och släppa testförgreningen på produktionsfilialen.
Använda kommandot git merge för att sammanfoga dina filialer.

Detta sammanfogar de senaste ändringarna från testförgreningen till produktionsfilialen och uppdaterar produktionsservern med dem.

När databasen är klar klickar du på Connect för att komma åt den.

Installera modulen¶

Lägg till en ändring¶

Detta avsnitt förklarar hur du lägger till en ändring i din modul genom att lägga till ett nytt fält i en modell och distribuera det.

Från redigeraren eller från din dator, öppna modulmappen ~/src/odoo-addons/my_module, öppna sedan filen models/models.py för att redigera den. Efter beskrivningsfältet:
```
description = fields.Text()
```
lägg till ett datetime-fält:
```
start_datetime = fields.Datetime('Start time', default=lambda self: fields.Datetime.now())
```

Öppna filen views/views.xml och efter:

<field name="value2"/>

lägg till:

<field name="start_datetime"/>

Dessa ändringar ändrar databasstrukturen genom att lägga till en kolumn i en tabell och modifiera en vy. För att tillämpas på en befintlig databas, såsom din produktionsdatabas, kräver dessa ändringar att modulen uppdateras. Om du vill att uppgraderingen ska utföras automatiskt av Odoo.sh-plattformen när du pushar dina ändringar, öka modulens version i dess manifest genom att öppna __manifest__.py och ersätta:
```
'version': '0.1',
```
med:
```
'version': '0.2',
```
Plattformen kommer att upptäcka en versionsändring och utlösa moduluppgraderingen vid distribution av den nya ändringen.
Därefter, pusha ändringarna.
När du har testat dina ändringar, kan du sammanfoga dem i produktionsfilialen, till exempel genom att dra och släppa filialen på produktionsfilialen i Odoo.sh-gränssnittet. Eftersom du ökade modulversionen i manifestet, kommer plattformen automatiskt att uppgradera modulen, och ditt nya fält kommer att vara tillgängligt omedelbart. Annars kan du manuellt uppgradera modulen i applistan.

Använda ett externt Python-bibliotek¶

Om du vill använda ett externt Python-bibliotek som inte är installerat som standard, kan du definiera en requirements.txt-fil som listar de externa bibliotek dina moduler beror på. Plattformen kommer att använda denna fil för att automatiskt installera de Python-bibliotek ditt projekt behöver.

Observera

Det är inte möjligt att installera eller uppgradera systempaket på Odoo.sh-databaser (t.ex. apt-paket). Under specifika förhållanden kan dock paket övervägas för installation. Detta gäller också för Python-moduler som kräver systempaket för kompilering och för tredjepartsmoduler i Odoo.
PostgreSQL-tillägg stöds inte på Odoo.sh, därför är det inte möjligt att installera tillägg (såsom PostGIS, ltree, …) i Odoo.sh-databaser.

Till exempel, för att använda Unidecode-biblioteket i din modul:

Skapa en fil requirements.txt i rotmappen för ditt repository:
- Från Odoo.sh-redigeraren, skapa och öppna filen ~/src/user/requirements.txt.
- Från din dator, skapa och öppna filen ~/src/odoo-addons/requirements.txt.
Lägg till i filen:
```
unidecode
```
Du kan nu använda biblioteket i din modul, till exempel för att ta bort accenter från tecken i namnfältet för din modell. För att göra detta, öppna filen models/models.py och före:
```
from odoo import models, fields, api
```
lägg till:
```
from unidecode import unidecode
```

Efter:

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

lägg till:

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

Öka modulversionen för att installera Python-beroendet genom att redigera modulens manifest __manifest__.py.
Sedan skicka ändringarna.

Tips
Förbered filen requirements.txt genom att köra git add requirements.txt.

Redigera på GitHub