![Creare la form: via Form e metaclassi >>> class Person(Form): ... first_name = CharField() ... last_name = CharField() ... birthday = DateField() Pass a dictionary to a Form's __init__(). >>> p = Person({'first_name': u'John', 'last_name': u'Lennon', 'birthday': u'1940-10-9'}) >>> p.is_bound True >>> p.errors {} >>> p.is_valid() True >>> p.errors.as_ul() u'' >>> p.errors.as_text() u'' >>> p.clean_data {'first_name': u'John', 'last_name': u'Lennon', 'birthday': datetime.date(1940, 10, 9)} >>> print p['first_name'] <input type="text" name="first_name" value="John" id="id_first_name" />](https://image.slidesharecdn.com/pycon-jungle4789/85/Pycon-Jungle-20-320.jpg)
Pycon Jungle
- 1. Django a modo mio: makosafare + Alessandro Dentella
- 2. Avviso ai naviganti Non sono un esperto web nè un teorico Presento 'jungle', l' intepretazione di ThunderSystems di django che sostituisce i template originari con mako Jungle è ora base per gli applicativi web di ThunderSystems E' un esempio completo per chi voglia studiare django. Comprende demo. Si compone di: libreria applicazioni
- 3. Perchè sostituire i template? Una questione di pigrizia...
- 4. Questione di gusti? Facilità di lettura In molte situazioni non esiste un web designer e siamo sempre noi a scrivere i template => voglio tutti i controlli Così posso passare blocchi interi come argomento a funzioni: questo permette di descrivere il layout in modo simbolico e molto efficace DRY... maggiore pulizia template: maggiore facilita' nella manutenzione/modifica
- 5. python nei template i core developer di django difendono strenuamente il fatto che i template non sono 'pythonici' Adrian in particolare chiede di non tornare sull'argomento di permettere le newline nei tag per 'aestethic reason' Per il resto django è splendido...
- 6. definizione di una form #- general data user email first_name last_name #- bith data birth_date T=time city state -- s=Add
- 7. Django in gran sintesi dispatcher: url/view modello ORM/manager newform (debug) (test) interfaccia admin template + tags authentication session transaction signals ... Cenni su: Tralascio :
- 9. schema essenziale GET o POST: /ticket/ticket/ (r'^ticket/ticket?$', 'ticket.views.my_view') HttpResponse urls.py views.py urls.py: corrispondenza url / view views.py: le funzioni che creano la risposta models.py: la definizione del modello (opzionale...)
- 10. urls.py from django.conf.urls.defaults import * urlpatterns = patterns('', (r'^admin/', include('django.contrib.admin.urls.admin')), (r'^jobs/', include('djproject.jobs.urls')), ) Nel progetto: Nella application
- 11. La view analizza la richiesta (HttpRequest) produce i dati necessari crea un contesto (insieme di variabili) apre un template a cui passa il contesto ritorna una risposta HttpResponse NOTA: tutta la manipolazione dei dati avviene nella view.
- 12. Il modello
- 13. modello ci permette di generare sql della tabella e di tabelle necessarie per le relazioni many2many eredita da models.Model: ogni istanza “sa” come generare il codice sql quando ne invochiamo il metodo .save() genera una tabella ticket_ticket (se, come nel nostro caso l'application ha nome ticket) la definizione precedente :
- 14. queryset il queryset rappresenta una collezione di oggetti del db: Ticket.objects.all() è l'insieme di tutti i ticket solo quando viene chiamata repr sul queryset il manager interroga il db, questo permette di costruire progressivamente il queryset.
- 15. filter() il queryset ha un metodo che permette di filtrare rispetto a campi del record. Aggiunge quindi condizioni WHERE allo statement SQL generato: q = Ticket.objects.filter(name='myproj') Permette però in modo semplice anche di filtrare su altre tabelle facendo implicitamente un JOIN: q.filter(manager__name='sandro') Faremo ampio uso di questi filtri
- 16. dati, validazione, html birth_date = models.DateField() <class 'django.db.models.fields.DateField'> questa informa 'manage syncdb' del tipo nella tabella del db e, tramite il metodo .formfield(), determina la validazione: <class 'django.newforms.fields.DateField'> questa classe ha un metodo .clean(value) che trasforma il dato da stringa a datetime.date(), ed ha associato un widget: <class 'django.newforms.widgets.TextInput'> Pensiamo ad un campo 'date' del db:
- 17. fields/widget un field del db ha una sua normale associazione ad un field delle forms un field delle form ha associato un widget (inputText, select, checkbox...) il field delle form è uno strumento di validazione ed ha un metodo .clean() che restituisce un oggetto python Ovvero:
- 18. Ancora field - widgets Impariamo dai doctests >>> w = TextInput() >>> w.render('email', '') u'<input type="text" name="email"> >>> import datetime >>> f = DateField() >>> f.clean(datetime.date(2006, 10, 25)) datetime.date(2006, 10, 25) >>> f.clean('10/25/2006') datetime.date(2006, 10, 25)
- 19. Form La form è un oggetto python definito da una collezione di campi, per ogni campo è definita una validazione capace di generare il codice html di una form e dei singoli campi che permette di definire metodi di validazione di un campo in dipendenza da altri che “sa” come processare i dati quando si preme 'submit' Quindi la form serve sia per generare il template (GET) che per processare i dati (POST)
- 20. Creare la form: via Form e metaclassi >>> class Person(Form): ... first_name = CharField() ... last_name = CharField() ... birthday = DateField() Pass a dictionary to a Form's __init__(). >>> p = Person({'first_name': u'John', 'last_name': u'Lennon', 'birthday': u'1940-10-9'}) >>> p.is_bound True >>> p.errors {} >>> p.is_valid() True >>> p.errors.as_ul() u'' >>> p.errors.as_text() u'' >>> p.clean_data {'first_name': u'John', 'last_name': u'Lennon', 'birthday': datetime.date(1940, 10, 9)} >>> print p['first_name'] <input type="text" name="first_name" value="John" id="id_first_name" />
- 21. Form
- 22. template <%! from jungle.templatetags.jungle_tags import offset_txt %> L'utente ${ticket.submitter} ha aperto il ticket # ${ticket.id} per il tuo progetto ' ${ticket.project.name} ': ID: ${ticket.id} Titolo: ${ticket.title} Descrizione: ${offset_txt(ticket.description)} Priorita': ${ticket.get_priority_display()} Il mail ti è inviato in qualità di ${title} ---------------------------------------------------------------- Puoi vedere questo ticket qui: ${"%s/ticket/ticket/%s/" % (jun.host_url(), ticket.id)}
- 23. sintesi del percorso con form aggiunta dati GET: /ticket/ticket/add/ urls.py view creazione form per generare html template response POST: /ticket/ticket/add/ + {'a':'b'} urls.py view creazione form per usare dati redirect response
- 24. Al lavoro! prepara il template! E ricorda: per ogni campo devi: creare la label e tradurla mettere il widget del campo usa una table per incolonnarla bene <td></td> controlla se la form ha indicato un errore, se lo ha indicato usa una classe 'error' e poi scrivi l'errore nella posizione corretta, per facilitare l'utente <tr><td> <label for="id_city">City:</label> {{ form.city }} {% if form.city.errors %}*** {{ form.city.errors|join:", " }}{% endif %} </td><td> <label for="id_state">State:</label> {{ form.state }} {% if form.state.errors %}*** {{ form.state.errors|join:", " }}{% endif %} </td></tr> o cosi: o alla jungle way...: city state
- 25. concretamente <%def name="layout()"> city state <%/def> ${forms.mako_table_data(context, layout, obj, ) }
- 26. basta chiacchiere! Ora vai al serverino di sviluppo e mostra qualcosa dal vivo. Per chi segue da casa: http://jungle.thundersystems.it Non dimenticare i manager del modello!
- 27. object_list from jungle.views.fast_search import search2 filter_cnd, order_by, form = search2( request, model, order_by=order_by, **kw) if filter_cnd: queryset = queryset.filter(**filter_cnd) if order_by: queryset = queryset.order_by(order_by) hai dimenticato i manager, vero?
- 28. debug: pdb ieri abbiamo visto come WSGI permetta di entrare a debuggare ciò che succede ed intervenire. Usando il server di sviluppo di django possiamo usare pdb.set_trace() in qualunque punto ed otteniamo una sessione interattiva!!!
- 29. test la mia esperienza precedente sui test rasenta lo zero. Li ho molto apprezzati per la chiarezza Siccome conosco la mia pigrizia ho preparato una classe che tramite una metaclasse popola di test, come minimo a partire dalle entry del menu, e da alcuni dizionari.
- 30. considerazioni sullo sviluppo c'è ancora molto da fare, molto da rifinire, sicuramente le api non sono stabili. Alcune scelte son fatte di getto, una comunità potrebbe aiutare a ponderare meglio le decisioni molti test da aggiungere! ajax da aggiungere polici di sicurezza da aggiungere molto codice da pulire... volontari?
- 31. Ringraziamenti python... django. Il core team è veramente sollecito nelle risposte non solo ai bug ma anche ai dubbi mako ThunderSystems che mi ha dato la possibilità di dedicare tanto tempo a questo splendido framework ed i due Giorgio con i quali sviluppo.