Modello MVC per wxPython e Kahemba

Nota per chi legge grazie a google

Trattasi di pagina non linkata e di un appunto incompleto di una idea che non so se progredirà mai.

In questo articolo verrà descritto un modello MVC per applicazioni GUI realizzate in wxPython, con lo specifico obiettivo di fornire una estensione utile per semplificare lo sviluppo di moduli per Kahemba, il gestionale Open Source italiano scritto in wxPython.

Motivazioni

Ho provato a contribuire al progetto Kahemba che intende sviluppare un gestionale Open Source in italiano, un progetto ambizioso e importante (credo molto importante).

Nonostante mi sembri che il lingaggio più di moda per lo sviluppo di applicazioni oggi sia Java, e che l'applicazione gestionale ideale dovrebbe essere Web per essere "moderna", di fatto si debba constatare che:

• la maggior parte degli utenti vorrebbero un programma GUI, per sostiture quello che hanno, che è magari a caratteri
• per le GUI Java non è il massimo (ci ho sviluppato sopra una volta, e ho giurato di non ripetere l'esperienza...)
• anche se non c'è nessuna pregiudiziale a usare Java per programmi Open Source, Java non è Open Source, è abbastanza importante per motivi puramente politici, usare un linguaggio Open Source per un sistema Open Source
• un linguaggio come Python non è affatto da trascurare ed è probailmente il linguaggio che sta ottenendo il maggior seguito
• Python è anche abbastanza simile a Visual Basic che è il linguaggio più usato per gestionali GUI e quindi la cosa potrebbe attrarre sviluppatori con questo background (e sono tanti).
• La GUI wxPython permette di produrre ottime applicazioni native, ed ha più seguito (a quanto ho potuto vedere) della SWT Java.

Quindi ho deciso di fare l'applicazione in Python + wxPython, possibilmente multidatabase anche se ritengo che di default il database deve essere sqlite. Questo per consentire la realizzazione di un unico installer che comprende tutto (ma proprio tutto).

Ho anche valutato a fondo BOA e ho concluso che non è adatto, ancora. Il codice generato appare "pasticciato" e "monolitico", prendendo il peggio dell'approccio RAD che degenera negli spaghetti visualbasici. Pertanto ho preferito un approccio che separa il disegno della GUI (fatta con l'ottimo wxGlade dell'italiano Alberto Griggio) dal resto

Tutte queste considerazioni le avevo fatte prima di esaminare in dettaglio il progetto Kahemba, e ho scoperto che Dinogen (aka Marcello Tempoli) è arrivato alle mie stesse conclusioni. Ho esaminato il progetto, e anche se ancora allo stato iniziale c'è abbastanza "struttura" che condivido da valere la pena di proseguirlo piuttosto che da zero.

Ho contattato Marcello e ci siamo scambiati un po' di email. Alla fine ho detto che l'impostazione che ha dato (suddivisione in moduli, interfaccia MVC con toolbar e tutto) andava abbastanza bene ma secondo me mi sembrava troppo laborioso scrivere codice che si legasse al database, come tipicamente una applicazione gestionale è. Sarebbe stato utile fornire un modello MVC nello stile di Delphi VCL o JBuilder, che avrebbe reso abbastanza agevole lo sviuluppo di GUI data-aware per Kahemba.

A Dino l'idea è piaciuta così ci siamo detti che è il caso di implementarla onde completare l'architettura. Poiché Marcello è (e rimane) il principal architect di Kahemba, io implementerò il modello MVC separatamente e poi provvederà Marcello a integrarla in Kahemba.

Come tutte le cose informatiche, vengono meglio se si sa prima quello che si fa, quindi prima di procedere a implementarlo scrivo una specifica che rendo pubblica per avere suggerimenti e consigli.

L'idea

Per semplificare lo sviluppo si applica un sistema MVC. Il contenitore di moduli è già fatto. Ogni singolo modulo avrà questo layout

layout:

app/modulo/view.wxg
app/modulo/model.ini
app/modulo/control.py

Quindi la cosa funzionerebbe così:

- Si disegna la view con wxGlade - Si definisce il database con il model.ini:

Per esempio:

fattura? ragione_sociale=string,1001 via=string,1001 fattura_item? descrizione=string,varchar(20),10001 quantita=number,10002

Esiste poi un makedataset.py che per ogni model.ini genera app/modulo/model.py. Notare che ogni item del model è legato a un control della form di cui i numeri sono gli ID!

A questo punto si implementa la classe control.py che estende view.py (generato da wxGlade) e model.py (generato da makedataset.py)

IDEA: forse si potrebbe evitare un generatore e scrivere solo una classe che estende una classe DataSet.py specificando i campi del database...

IDEA: si potrebbe evitare del tutto la generazione di codice, salvare la gui in xrc (xml) format e lasciare la descrizione del model come .ini che viene letto dalla classe che implementa il control...

In ogni caso, la view viene disegnata, il model viene composto in base al database e c'è solo da implementare il control, ovvero la gestione di eventi. Questa classe implementa la business logic, in questo modo:

• manipola i MODEL
• i quali indirettamente visualizzano la VIEW (cioè la gui).
• l'utente interagisce con la GUI e di conseguenza invoca i metodi del control.

Ricordare che in fase di configurazione del model si indica direttamente quali elementi GUI sono visualizzazioni di campi del database.