Din första modul

Översikt

Detta kapitel hjälper dig att skapa din första Odoo-modul och distribuera den i ditt Odoo.sh-projekt.

Denna handledning kräver du har skapat ett projekt på Odoo.sh, och du vet din Github-arkivets URL.

Grundläggande användning av Git och Github förklaras.

Nedanstående antaganden har gjorts:

• ~/src är den katalog där Git-arkiv som är relaterade till dina Odoo-projekt finns,

• odoo är Github-användaren,

• odoo-addons är Github-förvaret,

• feature-1 är namnet på en utvecklingsgren,

• master är namnet på produktionsgrenen,

• my_module är namnet på modulen.

Ersätt dessa med de värden du själv väljer.

Skapa utvecklingsgrenen

Från Odoo.sh

I vyn för grenar:

• tryck på +-knappen bredvid utvecklingsstadiet,

• välj filialens master i Fork-valet,

• skriv feature-1 i To-ingången.

  |bild1| |bild2|

När build har skapats kan du öppna redigeraren och bläddra till mappen ~/src/user för att få tillgång till koden i din utvecklingsgren.

Från din dator

Klona ditt Github-arkiv på din dator:

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

Skapa en ny filial:

$ git checkout -b feature-1 master

Skapa modulstrukturen

Byggnadsställningar för modulen

Även om det inte är nödvändigt, undviker scaffolding det tråkiga arbetet med att ställa in den grundläggande Odoo-modulstrukturen. Du kan bygga upp en ny modul med hjälp av den körbara filen odoo-bin.

Från Odoo.sh-redigeraren, i en terminal:

$ odoo-bin scaffold my_module ~/src/user/

Eller från din dator, om du har en installation av Odoo:

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

Om du inte vill bry dig om att installera Odoo på din dator kan du också ladda ner den här modulstrukturmallen där du ersätter alla förekomster av my_module med det namn du vill ha.

Nedanstående struktur 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
└── views
    ├── templates.xml
    └── views.xml

Varning

Använd inte andra specialtecken än understreck ( _ ) för modulnamnet, inte ens bindestreck ( - ). Detta namn används för Python-klasserna i din modul, och att ha klassnamn med andra specialtecken än understreck är inte giltigt i Python.

Avkommentera innehållet i filerna:

• models/models.py, ett exempel på en modell med dess fält,

• views/views.xml, en träd- och en formulärvy, med menyer som öppnar dem,

• demo/demo.xml, demoposter för ovanstående exempelmodell,

• 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 ovanstående controller-vägar,

• __manifest__.py, manifestet för din modul, inklusive t.ex. dess titel, beskrivning och datafiler som ska laddas. Du behöver bara avkommentera datafilen för åtkomstkontrollistan:

  # 'security/ir.model.access.csv',
  

Manuellt

Om du vill skapa din modulstruktur manuellt kan du följa Server framework 101 för att förstå strukturen i en modul och innehållet i varje fil.

Tryck på utvecklingsgrenen

Ställa in de ändringar som ska göras

$ git add my_module

Bekräfta dina ändringar

$ git commit -m "My first module"

Skicka dina ändringar till ditt fjärrarkiv

Från en terminal med Odoo.sh-redigeraren:

$ git push https HEAD:feature-1

Ovanstående kommando förklaras i avsnittet Commit & Push your changes i kapitlet Online Editor. Det innehåller en förklaring om att du kommer att uppmanas att skriva in ditt användarnamn och lösenord, och vad du ska göra om du använder tvåfaktorsautentisering.

Eller från din datorterminal:

$ git push -u origin feature-1

Du behöver bara ange -u origin feature-1 för den första pushningen. Från och med nu kan du helt enkelt använda följande för att skicka framtida ändringar från din dator

$ git push

Testa din modul

Din gren bör visas i dina utvecklingsgrenar i ditt projekt.

I grenvyn i ditt projekt kan du klicka på grenens namn i den vänstra navigeringspanelen för att komma till dess historik.

Här kan du se de ändringar som du just har skickat, inklusive den kommentar som du har angett. När databasen är klar kan du komma åt den genom att klicka på knappen Connect.

Om ditt Odoo.sh-projekt är konfigurerat för att installera din modul automatiskt kommer du att se den direkt bland databasapparna. Annars kommer den att finnas tillgänglig i apparna som ska installeras.

Du kan sedan leka med din modul, skapa nya poster och testa dina funktioner och knappar.

Test med produktionsdata

Du måste ha en produktionsdatabas för det här steget. Du kan skapa den om du inte har den ännu.

När du har testat din modul i en utvecklingsbyggnad med demodata och anser att den är klar kan du testa den med produktionsdata med hjälp av en staging-gren.

Du kan antingen..:

• Gör din utvecklingsgren till en staginggren genom att dra och släppa den på sektionsrubriken staging.

  

• Slå samman den i en befintlig staging-gren genom att dra och släppa den på den angivna staging-grenen.

  

Du kan också använda kommandot git merge för att slå samman dina grenar.

Detta skapar en ny staging-build som duplicerar produktionsdatabasen och kör den på en server som är uppdaterad med de senaste ändringarna i din gren.

När databasen är klar kan du komma åt den med hjälp av knappen Connect.

Installera din modul

Din modul kommer inte att installeras automatiskt, du måste installera den från apps-menyn. Syftet med staging build är faktiskt att testa hur dina ändringar skulle fungera i produktionen, och i produktionen vill du inte att din modul ska installeras automatiskt utan på begäran.

Din modul kanske inte heller visas direkt i dina appar att installera, du måste uppdatera din applista först:

• Aktivera utvecklarläget <developer-mode>`

• i appmenyn klickar du på knappen Uppdatera applistan,

• i dialogrutan som visas klickar du på knappen Uppdatera.

  

Din modul kommer då att visas i listan över tillgängliga appar.

Driftsättning i produktion

När du har testat din modul i en staging-gren med dina produktionsdata och anser att den är redo för produktion kan du slå samman din gren med produktionsgrenen.

Dra och släpp din staging-gren på produktionsgrenen.

Du kan också använda kommandot git merge för att slå samman dina grenar.

Detta kommer att slå samman de senaste ändringarna i din staging-gren i produktionsgrenen och uppdatera din produktionsserver med dessa senaste ändringar.

När databasen är klar kan du komma åt den med hjälp av knappen Connect.

Installera din modul

Modulen installeras inte automatiskt, utan du måste installera den manuellt enligt beskrivningen i avsnittet :ref:` ovan om installation av modulen i staging-databaser <odoosh-gettingstarted-firstmodule-productiondata-install>`.

Lägg till en ändring

I det här avsnittet beskrivs hur du lägger till en ändring i din modul genom att lägga till ett nytt fält i en modell och distribuera den.

Från Odoo.sh-redigeraren,

• bläddra till din modulmapp ~/src/user/my_module,

• öppna sedan filen models/models.py.

Eller från din dator,

• använd den filbläddrare du väljer för att bläddra till din modulmapp ~/src/odoo-addons/my_module,

• öppna sedan filen models/models.py med en valfri editor, t.ex. Atom, Sublime Text, PyCharm, vim, …

Sedan, 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 sedan filen views/views.xml.

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 ändra en vy som lagras i databasen.

För att kunna tillämpas i befintliga databaser, t.ex. din produktionsdatabas, kräver dessa ändringar att modulen uppdateras.

Om du vill att uppdateringen ska utföras automatiskt av Odoo.sh-plattformen när du skickar dina ändringar, öka din modulversion i dess manifest.

Öppna modulmanifestet __manifest__.py.

Byt ut

'version': '0.1',

med

'version': '0.2',

Plattformen kommer att upptäcka versionsändringen och utlösa uppdateringen av modulen när den nya versionen distribueras.

Bläddra till din Git-mapp.

Sedan, från en Odoo.sh terminal:

$ cd ~/src/user/

Eller från din datorterminal:

$ cd ~/src/odoo-addons/

Lägg sedan in dina ändringar för att bli bekräftade

$ git add my_module

Bekräfta dina ändringar

$ git commit -m "[ADD] my_module: add the start_datetime field to the model my_module.my_module"

Tryck på dina ändringar:

Från en Odoo.sh terminal:

$ git push https HEAD:feature-1

Eller från din datorterminal:

$ git push

Plattformen kommer sedan att skapa ett nytt bygge för grenen feature-1.

När du har testat dina ändringar kan du slå samman dina ändringar i produktionsgrenen, till exempel genom att dra och släppa grenen på produktionsgrenen i Odoo.sh-gränssnittet. När du har ökat modulversionen i manifestet kommer plattformen att uppdatera modulen automatiskt och ditt nya fält kommer att vara direkt tillgängligt. Annars kan du uppdatera modulen manuellt i 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.

Observera

• Det är inte möjligt att installera eller uppgradera systempaket på en Odoo.sh-databas (t.ex. apt-paket). Under särskilda 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 Odoos moduler från tredje part.

• PostgreSQL-tillägg stöds inte på Odoo.sh.

• För mer information, se vår FAQ.

Plattformen kommer att använda den här filen för att automatiskt installera de Python-bibliotek som ditt projekt behöver.

Funktionen förklaras i det här avsnittet genom att använda biblioteket Unidecode i din modul.

Skapa en fil requirements.txt i rotmappen för ditt repository

Från Odoo.sh-redigeraren skapar och öppnar du filen ~/src/user/requirements.txt.

Eller, från din dator, skapa och öppna filen ~/src/odoo-addons/requirements.txt.

Lägg till

unidecode

Använd sedan biblioteket i din modul, t.ex. för att ta bort accenter från tecken i namnfältet i din modell.

Öppna filen models/models.py.

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)

För att lägga till ett Python-beroende krävs en ökning av modulversionen för den plattform som ska installera den.

Redigera modulens manifest __manifest__.py

Byt ut

'version': '0.2',

med

'version': '0.3',

Sätt upp och bekräfta dina ändringar:

$ git add requirements.txt
$ git add my_module
$ git commit -m "[IMP] my_module: automatically remove special chars in my_module.my_module name field"

Tryck sedan på dina ändringar:

I en Odoo.sh terminal:

$ git push https HEAD:feature-1

I din datorterminal:

$ git push