Durante l'utilizzo di Openerp ho spesso trovato la necessità di conoscere un po' meglio campi e collegamenti/relazioni tra i vari oggetti che formano il DB.

Ovviamente il bravo programmatore dovrebbe usare direttamente il livello di astrazione fornito dallo strato ORM, capita però che, dovendo fare una stampa, volendo spulciare velocemente i campi che sono presenti in alcuni oggetti, o scopi del genere, si renda necessario il classico “schemino”; il grafico UML può fare al caso nostro. Gli strumenti che vengono descritti in questa guida, atti allo scopo, sono due: OOOR e OOOP, vediamoli in dettaglio:

Non intendo snocciolare tutte le funzionalità complete del componente OOOR che andremo ad utilizzare, quello che si vuole ottenere è semplicemente: mettere in grado l'utente programmatore o il creatore di report, di accedere al vostro DB di openerp e vedere come si legano 2 o più tabelle.

L'applicativo OOOR lo potete tovare su git, seguito e mantenuto da Raphael Valyi, da cui è tratta parte della documentazione che utilizzo, l'indirizzo del progetto è:

https://github.com/rvalyi/ooor

Nota: A chi spesso “maneggia” dati e fa attività di ETL, verrà anche in mente il componente per Kettle: Terminatooor che sfrutta gli stessi concetti e il linguaggio Ruby per il suo scopo.

L'installazione è effettuata su un Ubuntu, attualmente la mia macchina monta un 10.4, percio' da bash:

sudo apt-get install irb ruby rubygems
sudo gem install ooor
sudo apt-get install libopenssl-ruby 

Lanciare la shell irb:

irb

Da qui in poi si entra nella console di irb:

irb(main):001:0>require 'rubygems' # carichiamo il package
irb(main):001:0>require 'ooor' # carichiamo OOOR
irb(main):001:0>Ooor.new({:url => 'http://localhost:8069/xmlrpc', :database => 'mybase', :username => 'admin', :password => 'admin'}) # Connettiamoci al DB (il server è localhost)

Qui avviene un dialogo con il server seguito dalla trasformazione di tutte le tabelle/oggetti del DB in oggetti veri e propri utilizzabili dalla console

Un estratto:

⇒ #<Ooor::Ooor:0xb66f3978 @ir_model_class=IrModel,
@config={:password=>"admin", :database=>"mybase", :url=>"http:localhost:8069/xmlrpc", :user_id=>1, :username=>"admin"},
@global_context={}, @base_url="http:localhost:8069/xmlrpc",
@logger=#<Logger:0xb66f3950 @progname=nil,
@logdev=#<Logger::LogDevice:0xb66f38ec @filename=nil,
@mutex=#<Logger::LogDevice::LogDeviceMutex:0xb66f38c4
@mon_entering_queue=[], @mon_count=0, @mon_owner=nil,
@mon_waiting_queue=[]>, @dev=#<IO:0xb78d7568>, @shift_size=nil,
@shift_age=nil>, @formatter=nil, @level=0,
@default_formatter=#<Logger::Formatter:0xb66f3914 @datetime_format=nil>>,
@loaded_models=[IrModel, AccountAccount, AccountAccountTemplate, AccountAccountType, AccountAddtmplWizard, AccountAgedTrialBalance, AccountAnalyticAccount, AccountAnalyticBalance, AccountAnalyticChart, AccountAnalyticCostLedger, AccountAnalyticCostLedgerJournalReport, AccountAnalyticInvertedBalance, AccountAnalyticJournal, AccountAnalyticJournalReport, AccountAnalyticLine, AccountAutomaticReconcile, AccountBalanceReport, AccountBankAccountsWizard, AccountBankStatement, AccountBankStatementLine, AccountBsReport, AccountCashboxLine, AccountCentralJournal, AccountChangeCurrency, AccountChart, AccountChartTemplate, …

Gli oggetti vengono qui creati usando il “CamelCase”, un esempio delle differenze tra i nomi:

• Oggetto python: account.account
• In postgres è realizzato con: account_account
• In irb viene trasformato in: AccountAccount

Grazie a questi oggetti è possibile perciò fare normali operazioni di ORM (trova, modifica, salva ecc.).
Anche se non è lo scopo del tutorial ecco alcuni esempi che vi fanno capire le potenzialità dello strumento (personalmente, per le normali operazioni qui descritte, utilizzo script XMLRPC, senza scomodare - e di conseguenza installare - tutti questi strumenti)

irb(main):001:0>p=ProductProduct.find(1) # Ricerca prodotto ID 1
⇒ Una istanza dell'oggetto ProductProduct sottende tutti i campi e relazioni della classe OpenERP
irb(main):001:0>p.name = 'Nome prodotto XXX'
irb(main):001:0>p.save
irb(main):001:0>p.name
⇒ "Nome prodotto XXX"

irb(main):001:0>new_categ = ProductCategory.new(:name ⇒ 'Suckfree API')
irb(main):001:0>p.categ_id = new_categ.save # Salva e ritorna l'id dell'elemento appena generato
irb(main):001:0>p.save
irb(main):001:0>p.categ_id.name
⇒ "Suckfree API"

irb(main):001:0>s=SaleOrder.find(1)
irb(main):001:0>s.date_order=2.days.ago # Rails 'activesupport' magic brought to OpenERP
irb(main):001:0>s.save

Convalidare tutte le fatture in bozza (in una sola riga!)

irb(main):001:0>AccountInvoice.find(:all, :domain ⇒ [ ['state', '=', 'draft'] ]).each{|invoice| invoice.wkf_action('invoice_open')}

L'utilità principale, che qui sponsorizzo, è quella che permette di creare dei grafici, il comando è il seguente:

irb(main):001:0>Ooor::UML.print_uml([SaleOrder, SaleShop])

Così facendo verrà prodotta una immagine UML.PNG o X.PNG nella directory nella quale è stato lanciato irb
Se provate ad aprire l'immagine vedrete i due oggetti principali, con rappresentate tutte le relazioni con gli altri oggetti.
E' anche possibile fare lo stesso su un singolo oggetto sfruttando il metodo:

irb(main):001:0>SaleOrder.print_uml()

E' inoltre possibile passare alcune opzioni:

• :detailed – di default, stampa tutti i campi della classe
• :nodetail – usare questa opzione per evitare i campi “non relazione”, semplificando lo schema, es: UML.print_uml([SaleOrder, StockMove], :nodetail)
• :all – vero di default, permette di vedere tutti gli oggetti collegati (altrimenti solo quelli nominati esplicitamente)

Quando avrete prodotti i primi grafici UML vi segnalo la particolarità che le relazioni sono state indicate con archi tra gli oggetti e, il nome proprio del campo, è scritto sull'arco (doppio se c'è anche la relazione di ritorno).
Nell'attesa delle vostre produzioni, un esempio dell'oggetto ProductProduct:

Il progetto Open Object On Python utilizza per l'appunto Python per la “manipolazione” e la creazione del grafico UML. Il progetto è presente sempre su git e viene mantenuto da Lasarux (da qui sono prelevati gli esempi di seguito), all'indirizzo:

https://github.com/lasarux/ooop

L'installazione è da effettuare scaricando il modulo zip o tar.gz nella sezione download dell'hub di git, al link precedente potrete accedere alla localizzazione del download. Ad oggi è possibile effettuare il download e l'installazione con la seguente procedura:

1. Scaricate il file in https://github.com/lasarux/ooop/tarball/master (oppure andate in https://github.com/lasarux, premete DOWNLOAD e scegliete se scaricarlo nel formato tar.gz oppure zip
2. Scompattare il file scaricato, normalmente ha come nome: lasarux-oop-???????.tar.gz
3. Entrare nella cartelle e installare il modulo di python

sudo python setup.py install

Quando è avvenuta l'installazione è possibile fare parecchie cose, come per il componente ooor di cui sopra, rimanendo nel seminato descriviamo uno script per disegnare un grafico partendo da un oggetto di riferimento: Entrare nell'ambiente python oppure creare uno script, nel nostro caso la prima, perciò da bash:

python

nell'ambiente python scriveremo (per accedere ad un DB chiamato “Prova” con la password dell'utente admin):

>>> from ooop import OOOP
>>> o= OOOP(dbname="Prova", pwd="p@ssw0rd")
>>> o.ResPartner.export(deep=2)

Il grafico prodotto porta il nome dell'oggetto e l'estensione dell'immagine, viene salvato nella directory dove è stato lanciato lo script o l'ambiente python, nel nostro esempio infatti avremo il file “res.partner.png” Il parametro deep che viene passato serve per specificare all'analizzatore quanto spingersi in profondità nelle relazioni dell'oggetto res.partner, attenzione a non esagerare con il valore, questo è il risultato di quello che abbiamo ottenuto con il semplice deep=2:

NOTA: il nome utilizzato per l'oggetto (es. o.ResPartner) ha la stessa forma in “Camel Case” che si è visto per ooor.

Possono essere utilizzati altri metodi per la mappatura delle relazioni tra tabelle.

Di seguito è riportato uno schema ottenuto esportando la struttura delle tabelle in un file separato e creando manualmente i legami. Non è così accurato e rapido come il metodo proposto sopra ma permette comprendere la struttura mentre si cercano e si segnano i legami in modo manuale.

Non sono state indicate tutte le relazioni ma solo quelle più significative che possono servire a dare l'idea della struttura minima e completa dello strato finale dello sviluppo.