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 URL:en till ditt GitHub-register.

Ordlista

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

Ersätt dessa vid behov.

Skapa utvecklingsgrenen¶

Från grenvy:

I grennavigeringspanelen, klicka på knappen ＋ (Ny utvecklingsgren) bredvid Utveckling.
Under Förgrening, välj grenen main.
Under Till, ange feature-1.

Förgrening av produktionsgrenen för att skapa en utvecklingsgren på Odoo.sh

När bygget är klart kan du nå redigeraren och koden för din utvecklingsgren 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 gren genom att köra:
```
git checkout -b feature-1 main
```

Skapa modulstrukturen¶

Byggnadsställning¶

Även om det inte är obligatoriskt, undviker byggnadsställning det tråkiga arbetet med att sätta upp den grundläggande Odoo-modulstrukturen. Du kan bygga upp en ny modul med 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 det namn du väljer.

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 utöver understreck är inte giltiga i Python.

Avkommentera följande filer:

models/models.py ett exempel på en modell med sina fält
views/views.xml en trädvy och en formulärvy, med menyer som öppnar dem
demo/demo.xml demohandlingar 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 åtkomstkontrollistans datafil:
```
# '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 för en modul och innehållet i varje fil.

Skicka till utvecklingsgrenen¶

Lägg till ändringarna som ska commitas genom att köra:
```
git add my_module
```
Committa dina ändringar genom att köra:
```
git commit -m "My first module"
```
Skicka dina ändringar till ditt fjärrarkiv genom att köra:
Från redigerarens terminal, kör:
git push https HEAD:feature-1
Se även
Dokumentation för online-redigerare: committa och skicka ä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 skickar. Efter det, kör:
git push

Testa modulen¶

Grenen ska visas under sektionen Utveckling i navigeringspanelen Grenvy.

Klicka på grennamnet för att visa dess historik, inklusive ändringarna du just skickat. När databasen är klar, klicka på Anslut för att få åtkomst till 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å databasens dashboard. 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 demodatan och tror att den är klar, kan du testa den med produktionsdatan genom att använda en testförgrening.

Du kan:

Konvertera din utvecklingsförgrening 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 förgreningen.
Använd kommandot git merge för att sammanfoga dina förgreningar.

Detta skapar en ny testbygge som duplicerar produktionsdatabasen och kör den på en server uppdaterad med din förgrenings 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 systemutvecklarläget 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 att en modul installeras automatiskt.

Driftsättning i produktion¶

När du har testat modulen i en testförgrening med produktionsdata och anser att den är redo för produktion kan du sammanfoga din förgrening med produktionsförgreningen genom att:

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

Detta sammanfogar de senaste ändringarna från testförgreningen till produktionsförgreningen 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¶

Denna sektion förklarar hur man 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 uppgraderas. 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 upptäcker en versionsändring och utlöser modul-uppgraderingen vid driftsättning av den nya ändringen.
Därefter skicka ändringarna.
När du har testat dina ändringar kan du sammanfoga dem i produktionsgrenen, t.ex. genom att dra och släppa grenen på produktionsgrenen i Odoo.sh-gränssnittet. Eftersom du ökade modulversionen i manifestet kommer plattformen automatiskt att uppgradera modulen och ditt nya fält blir omedelbart tillgängligt. Annars kan du manuellt uppgradera modulen inom applistan.

Använd 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 som dina moduler är beroende av. Plattformen använder denna fil för att automatiskt installera de Python-bibliotek som 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 även Python-moduler som kräver systempaket för kompilering och tredjeparts-Odoo-moduler.
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 repositorium:
- 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, t.ex. 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.
Därefter skicka ändringarna.

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

Redigera på GitHub