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 repository URL.

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

Nedanstående antaganden görs:

• ~/src är katalogen där Git-förvar 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 valfria värden.

Skapa utvecklingsgrenen¶

Från Odoo.sh¶

I vyn för grenar:

• tryck på knappen + bredvid utvecklingsstadiet,

• välj branschens mästare i Fork-urvalet,

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

  |bild1| |bild 2|

När byggnaden har skapats kan du öppna redigeraren och bläddra till mappen ~/src/user för att få tillgång till koden för 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 modulens struktur¶

Byggnadsställningar för modulen¶

Även om det inte är nödvändigt, undviker byggnadsställningar tråkigheten 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 denna modulstrukturmall där du ersätter alla förekomster av my_module till det namn du väljer.

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

Kommentera inte 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, demo-poster för ovanstående exempelmodell,

• controllers/controllers.py, ett exempel på en kontroller som implementerar några rutter,

• views/templates.xml, två exempel på qweb-vyer som används av ovanstående controller-rutter,

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

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

Manuellt¶

Om du vill skapa din modulstruktur manuellt kan du följa Getting started-handledningen för att förstå strukturen i en modul och innehållet i varje fil.

Pusha utvecklingsgrenen¶

Steg för 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ärranslutna arkiv

Från en Odoo.sh-editorterminal:

$ git push https HEAD:feature-1

Kommandot ovan 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 ange 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 måste ange -u origin feature-1 endast för den första utskicket. Från den punkten, för att pusha dina framtida ändringar från din dator, kan du helt enkelt använda

$ git push

Testa din modul¶

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

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

Här kan du se de ändringar som du just har överfört, inklusive den kommentar du angav. 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 detta steg. Du kan skapa den om du inte har den ännu.

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

Du kan antingen:

• Gör din utvecklingsfilial till en staging-filial genom att dra och släppa den på staging-avsnittsrubriken.

  

• Sammanfoga den i en befintlig staging-gren genom att dra och släppa den på den givna 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 med en server som uppdaterats med de senaste ändringarna i din gren.

När databasen är klar kan du komma åt den genom att klicka på 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 ju att testa hur dina ändringar skulle fungera i din produktion, och i din produktion 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äge

• i appmenyn klickar du på knappen Uppdatera applistan,

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

  

Din modul visas sedan 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 innebär att de senaste ändringarna i din staging-gren slås samman med produktionsgrenen och att produktionsservern uppdateras med de senaste ändringarna.

När databasen är klar kan du komma åt den genom att klicka på knappen Connect.

Installera din modul¶

Din modul kommer inte att installeras automatiskt, du måste installera den manuellt enligt vad som förklaras i avsnittet :ref:` ovan om installation av din modul i staging-databaser <odoosh-gettingstarted-firstmodule-productiondata-install>`.

Lägg till en ändring¶

I det här avsnittet förklaras 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 valfri filbläddrare för att bläddra till din modulmapp ~/src/odoo-addons/my_module,

• öppna sedan filen models/models.py med 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 modifiera en vy som lagrats i databasen.

För att dessa ändringar ska kunna tillämpas i befintliga databaser, t.ex. din produktionsdatabas, måste 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.

Ersätt

'version': '0.1',

med

'version': '0.2',

Plattformen kommer att upptäcka versionsändringen och aktivera 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/

Sätt sedan upp de ändringar som ska bekräftas

$ 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 en ny build för grenen feature-1.

När du har testat dina ändringar kan du slå samman dem i produktionsgrenen, till exempel genom att dra och släppa grenen på produktionsgrenen i Odoo.sh-gränssnittet. När du ökar 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ä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 som dina moduler är beroende av.

Plattformen kommer att använda denna fil för att automatiskt installera de Python-bibliotek som projektet behöver.

Funktionen förklaras i detta avsnitt genom att använda Unidecode library i din modul.

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

Skapa och öppna filen ~/src/user/requirements.txt från Odoo.sh-redigeraren.

Du kan också skapa och öppna filen ~/src/odoo-addons/requirements.txt från din dator.

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 att plattformen ska kunna installera det.

Redigera modulmanifestet __manifest__.py

Ersätt

'version': '0.2',

med

'version': '0.3',

Stagga 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