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 dumneavoastră GitHub.

Glosar

~/src este directorul în care se află 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.

Înlocuiește-le 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 dvs. de dezvoltare din dosarul ~/src/user.

Clonați depozitul dvs. GitHub pe computer executâ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ă executând:
```
git checkout -b feature-1 main
```

Creați structura modulului¶

Scheletare¶

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

Din terminalul editorului, executați:

odoo-bin scaffold my_module ~/src/user/

Cu Odoo instalat pe computer, executați:

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

Sfat

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

Va fi generată structura de mai jos:

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 liniuțe de subliniere (_) când denumiți modulul, deoarece numele său este folosit pentru clasele Python, iar numele de clasă care conțin caractere speciale altele decât liniuțele de subliniere 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 o vizualizare formular, cu meniurile care le deschid
demo/demo.xml înregistrări demonstrative pentru modelul exemplu
controllers/controllers.py un exemplu de controller care implementează câteva rute
views/templates.xml două vizualizări qweb exemplu utilizate de rutele controller-ului
__manifest__.py manifestul modulului dvs., incluzând titlul, descrierea și fișierele de date de încărcat. Decomentați fișierul de date al listei 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.

Încarcă pe ramura de dezvoltare¶

Pregătește modificările pentru a fi trimise prin rularea:
```
git add my_module
```
Trimite modificările tale prin rularea:
```
git commit -m "My first module"
```
Încarcă modificările tale în depozitul tău distant prin rularea:
Din terminalul editorului, executați:
git push https HEAD:feature-1
Vedeți și
Documentația editorului online: trimiterea și încărcarea modificărilor
Rulează:
git push -u origin feature-1
Este necesar să specifici -u origin feature-1 doar prima dată când încarci. După aceea, rulează:
git push

Testează modulul¶

Ramura ar trebui să apară în secțiunea Dezvoltare din panoul de navigare Vizualizarea ramurilor.

Dă clic pe numele ramurii pentru a vedea istoricul său, inclusiv modificările pe care tocmai le-ai încărcat. Odată ce baza de date este gata, dă clic pe Conectează pentru a o accesa.

Butonul de conectare pentru a accesa o bază de date

Dacă proiectul tău 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 sub aplicația Aplicații.

Noul modul pe tabloul de bord al bazei de date

Testați cu datele de producție¶

Notă

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

După ce ați testat modulul într-o versiune de dezvoltare cu datele de demonstrație și considerăți că este pregătit, puteți să-l testați cu datele de producție utilizând o ramură de staging.

Puteți:

Convertiți ramura de dezvoltare într-o ramură de staging tragând-o și plasand-o în secțiunea Staging.
Să o îmbinați într-o ramură de staging existentă tragând-o și plasând-o pe 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 ultimele modificări din ramura dumneavoastră.

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

Instalarea modulului¶

Instalați modulul din aplicația Apps. Deoarece modulul ar putea să nu apară direct în lista de aplicații, actualizați lista de aplicații activând modul dezvoltator și făcând clic pe Actualizează lista de aplicații ‣ Actualizează.

Notă

Modulul nu este instalat automat, deoarece scopul versiunii de staging este de a testa comportamentul modificărilor dumneavoastră așa cum ar fi pe baza de date de producție, deci nu ați dori ca un modul să fie instalat automat.

Instalați în producție¶

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

Tragând și plasând ramura de staging pe ramura de producție.
Utilizând comanda git merge pentru a îmbina ramurile.

Aceasta îmbină ultimele modificări din ramura de staging în ramura de producție și actualizează serverul de producție cu ele.

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

Instalarea modulului¶

Adăugați o modificare¶

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

Din editor sau de pe calculator, deschideți dosarul modulului ~/src/odoo-addons/my_module, apoi deschideți fișierul models/models.py pentru a-l edita. După câmpul de descriere:
```
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 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 deschizând __manifest__.py și înlocuind:
```
'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, le puteți îmbina în ramura de producție, de exemplu, trăgând și plasând ramura peste ramura de producție în interfața Odoo.sh. Deoarece ați crescut versiunea modulului în manifest, platforma va actualiza automat modulul, iar noul dvs. 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ă în mod implicit, puteți defini un fișier requirements.txt care listează bibliotecile externe de care depind modulele dvs. Platforma va folosi acest fișier pentru a instala automat bibliotecile Python de care proiectul dvs. are nevoie.

Notă

Nu este posibilă instalarea sau actualizarea pachetelor de sistem pe bazele de date Odoo.sh (de exemplu, pachete apt). Cu toate acestea, î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ță parte.
Extensiile PostgreSQL nu sunt acceptate pe Odoo.sh, prin urmare nu este posibilă instalarea extensiilor (cum ar fi PostGIS, ltree, …) în bazele de date Odoo.sh.

De exemplu, pentru a utiliza biblioteca Unidecode în modulul dvs.:

Creați un fișier requirements.txt în dosarul rădăcină al depozitului dvs.:
- Din editorul Odoo.sh, creați și deschideți fișierul ~/src/user/requirements.txt.
- De pe computer, creați și deschideți fișierul ~/src/odoo-addons/requirements.txt.
Adăugați în fișier:
```
unidecode
```
Acum puteți folosi biblioteca în modulul dvs., de exemplu, pentru a elimina accentele din caractere în câmpul de nume al modelului dvs. 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