Creează un modul¶

Înainte de a crea primul modul, este necesar să creați un proiect Odoo.sh și să cunoașteți URL-ul depozitului GitHub.

Glosar

~/src este directorul unde sunt localizate depozitele Git legate de proiectele dumneavoastră Odoo.
odoo este utilizatorul GitHub.
odoo-addons este depozitul GitHub.
feature-1 este numele unei ramuri de dezvoltare.
main este numele ramurii de producție.
my_module este numele modulului.

Înlocuiți acestea după cum este necesar.

Creați ramura de dezvoltare¶

Din vizualizarea Ramuri:

În panoul de navigare al ramurilor, faceți clic pe butonul ＋ (Ramură de dezvoltare nouă) de lângă Dezvoltare.
Sub Bifurcare, selectați ramura main.
Sub Către, introduceți feature-1.

Bifurcarea ramurii de producție pentru a crea o ramură de dezvoltare pe Odoo.sh

Odată ce compilarea este gata, puteți accesa editorul și codul ramurii de dezvoltare din dosarul ~/src/user.

Clonați depozitul GitHub pe calculatorul dumneavoastră rulând următoarele comenzi:

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

Creați o ramură nouă rulând:
```
git checkout -b feature-1 main
```

Creați structura modulului¶

Scheletizare¶

Deși nu este obligatorie, scheletizarea evită plictiseala de a configura structura de bază a modulului Odoo. Puteți scheletiza un modul nou folosind executabilul odoo-bin.

Din terminalul editorului, rulați:

odoo-bin scaffold my_module ~/src/user/

Cu Odoo instalat pe calculatorul dumneavoastră, rulați:

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

Sfat

Dacă nu doriți să instalați Odoo pe calculatorul dumneavoastră, puteți de asemenea descărca acest șablon de structură de modul. Înlocuiți fiecare apariție a my_module cu numele ales de dumneavoastră.

Structura de mai jos va fi generată:

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

Atenționare

Folosiți doar caractere alfanumerice (a-z, 0-9) sau underscore (_) când denumiți modulul, deoarece numele său este folosit pentru clase Python, iar numele de clase care conțin caractere speciale altele decât underscore nu sunt valide în Python.

Decomentați următoarele fișiere:

models/models.py un exemplu de model cu câmpurile sale
views/views.xml o vizualizare arbore și una formular, cu meniurile care le deschid
demo/demo.xml înregistrări demo pentru modelul exemplu
controllers/controllers.py un exemplu de controler care implementează câteva rute
views/templates.xml două exemple de vizualizări qweb folosite de rutele controlerului
__manifest__.py manifestul modulului dvs., incluzând titlul, descrierea și fișierele de date de încărcat. Decomentați fișierul de date cu lista de control al accesului:
```
# 'security/ir.model.access.csv',
```

Manual¶

Pentru a crea manual structura modulului, urmați tutorialul Server framework 101 pentru a înțelege structura unui modul și conținutul fiecărui fișier.

Trimitere pe ramura de dezvoltare¶

Pregătiți modificările pentru a fi înregistrate rulând:
```
git add my_module
```
Înregistrați modificările rulând:
```
git commit -m "My first module"
```
Trimiteți modificările către depozitul la distanță rulând:
Din terminalul editorului, rulați:
git push https HEAD:feature-1
Vedeți și
Documentația editorului online: înregistrarea și trimiterea modificărilor
Rulați:
git push -u origin feature-1
Este necesar să specificați -u origin feature-1 doar prima dată când trimiteți. Apoi, rulați:
git push

Testați modulul¶

Ramura ar trebui să apară în secțiunea Development a panoului de navigare Branches view.

Faceți clic pe numele ramurii pentru a-i vizualiza istoricul, incluzând modificările pe care tocmai le-ați trimis. Odată ce baza de date este gata, faceți clic pe Connect pentru a accesa.

Butonul de conectare pentru a accesa o bază de date

Dacă proiectul dvs. Odoo.sh este configurat să instaleze automat modulul, acesta va apărea direct pe tabloul de bord al bazei de date. În caz contrar, va fi disponibil pentru instalare în aplicația Apps.

Noul modul pe tabloul de bord al bazei de date

Testați cu datele de producție¶

Notă

Pentru acest pas este necesară o bază de date de producție. Dacă nu aveți încă una, creați-o.

Odată ce ați testat modulul într-o versiune de dezvoltare cu datele demo și considerați că este gata, îl puteți testa cu datele de producție folosind o ramură de staging.

Puteți:

Convertiți ramura de dezvoltare într-o ramură de staging prin glisare și plasare în secțiunea Staging.
Îmbinați-o într-o ramură de staging existentă prin glisare și plasare peste acea ramură.
Utilizați comanda git merge pentru a îmbina ramurile.

Aceasta creează o nouă versiune de staging care duplică baza de date de producție și o rulează pe un server actualizat cu cele mai recente modificări din ramura dvs.

Odată ce baza de date este pregătită, faceți clic pe Connect pentru a o accesa.

Instalați modulul¶

Instalați modulul din aplicația Apps. Deoarece modulul poate să nu apară direct în lista de aplicații, actualizați lista de aplicații prin activarea modului dezvoltator și făcând clic pe Update Apps List ‣ Update.

Notă

Modulul nu este instalat automat, deoarece scopul versiunii de staging este să testeze comportamentul modificărilor dvs. așa cum ar fi pe baza de date de producție, astfel încât nu doriți ca un modul să fie instalat automat.

Instalați în producție¶

Odată ce ați testat modulul într-o ramură de staging cu datele de producție și considerați că este pregătit pentru producție, puteți îmbina ramura în ramura de producție prin:

Glisarea și plasarea ramurii de staging peste ramura de producție.
Utilizarea comenzii git merge pentru a îmbina ramurile.

Aceasta îmbină cele mai recente modificări din ramura de staging în ramura de producție și actualizează serverul de producție cu acestea.

Odată ce baza de date este pregătită, faceți clic pe Connect pentru a o accesa.

Instalați modulul¶

Adăugați o modificare¶

Această secțiune explică cum să adăugați o modificare în modulul dvs. prin adăugarea unui câmp nou într-un model și implementarea acestuia.

Din editor sau de pe computer, deschideți dosarul modulului ~/src/odoo-addons/my_module, apoi deschideți fișierul models/models.py pentru a-l edita. După câmpul description:
```
description = fields.Text()
```
adăugați un câmp datetime:
```
start_datetime = fields.Datetime('Start time', default=lambda self: fields.Datetime.now())
```

Deschideți fișierul views/views.xml și după:

<field name="value2"/>

adăugați:

<field name="start_datetime"/>

Aceste modificări alterează structura bazei de date prin adăugarea unei coloane la un tabel și modificarea unei vizualizări. Pentru a fi aplicate unei baze de date existente, cum ar fi baza dvs. de date de producție, aceste modificări necesită actualizarea modulului. Dacă doriți ca actualizarea să fie efectuată automat de platforma Odoo.sh atunci când trimiteți modificările, creșteți versiunea modulului în manifestul său prin deschiderea __manifest__.py și înlocuirea:
```
'version': '0.1',
```
cu:
```
'version': '0.2',
```
Platforma va detecta o schimbare de versiune și va declanșa actualizarea modulului la implementarea noii revizii.
Apoi, trimiteți modificările.
Odată ce ați testat modificările, puteți să le îmbinați în ramura de producție, de exemplu, prin tragerea și plasarea ramurii pe ramura de producție în interfața Odoo.sh. Deoarece ați crescut versiunea modulului în manifest, platforma va actualiza automat modulul, iar noul câmp va fi disponibil imediat. În caz contrar, puteți actualiza manual modulul din lista de aplicații.

Utilizați o bibliotecă Python externă¶

Dacă doriți să utilizați o bibliotecă Python externă care nu este instalată implicit, puteți defini un fișier requirements.txt care enumeră bibliotecile externe de care depind modulele dumneavoastră. Platforma va utiliza acest fișier pentru a instala automat bibliotecile Python necesare proiectului dumneavoastră.

Notă

Nu este posibil să instalați sau să actualizați pachete de sistem pe bazele de date Odoo.sh (de exemplu, pachete apt). Totuși, în condiții specifice, pachetele pot fi luate în considerare pentru instalare. Acest lucru se aplică și modulelor Python care necesită pachete de sistem pentru compilare și modulelor Odoo terțe.
Extensiile PostgreSQL nu sunt suportate pe Odoo.sh, prin urmare nu este posibilă instalarea de extensii (cum ar fi PostGIS, ltree, …) în bazele de date Odoo.sh.

De exemplu, pentru a utiliza biblioteca Unidecode în modulul dumneavoastră:

Creați un fișier requirements.txt în dosarul rădăcină al depozitului dumneavoastră:
- Din editorul Odoo.sh, creați și deschideți fișierul ~/src/user/requirements.txt.
- De pe computerul dumneavoastră, creați și deschideți fișierul ~/src/odoo-addons/requirements.txt.
Adăugați în fișier:
```
unidecode
```
Acum puteți utiliza biblioteca în modulul dumneavoastră, de exemplu, pentru a elimina accentele din caractere în câmpul de nume al modelului dumneavoastră. Pentru a face acest lucru, deschideți fișierul models/models.py și înainte de:
```
from odoo import models, fields, api
```
adăugați:
```
from unidecode import unidecode
```

După:

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

adăugați:

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

Creșteți versiunea modulului pentru a instala dependența Python editând manifestul modulului __manifest__.py.
Apoi, trimiteți modificările.

Sfat
Pregătiți fișierul requirements.txt rulând git add requirements.txt.

Editează pe GitHub