Un amministratore conferma la loro iscrizione, abilitandoli così al servizio di prenotazione dei veicoli.

Attraverso un motore di ricerca che fa uso di Ajax per l’aggiornamento dei select, filtrando l’elenco delle sedi scelte per zone e province, ed inserendo la data di ritiro e di consegna, l’utente riceve l’elenco dei veicoli disponibili (cioè non in uso e non in manutenzione).

Confermando le proprie scelte in 3 semplici passaggi, all’utente viene presentato un file pdf autogenerato da firmare e consegnare al deposito, con i dati relativi allo stato dell’auto (come il chilometraggio), e l’anagrafica di utente e veicolo.

Le officine hanno a disposizione una schermata per la gestione delle manutenzioni ed il controllo dello stato dei mezzi, ed una timeline che visualizza l’elenco degli interventi per una più precisa analisi dei costi relativi ai singoli veicoli.

L’uso di django ci ha permesso da un lato una estrema flessibilità, e dall’altro la semplicità di fornire personalizzazioni spinte dell’architettura, adattabili alle diverse esigenze dei clienti.

Guarda la galleria degli screenshot:

One way to generate those templates it to write by hand the XML, with some difficult actions needed to generate tables and complex items.

Another easy way is to use OpenOffice.org to make the template.
The procedure is quite simple and we’ll explain it here.

First of all, generate a text odt document. If you use tables, make sure to have the same number of column for every rows. If you need a more complicated table, split it in different tables or good results will be difficult to achieve.

Format the page dimensions with openoffice, it will be the same on pdf.

In your template you must be sure to put also the text you will change, to format it to your needs. To use it in a django app, you can use the django template system placeholders like {{name}} or {{address}}.

Then, save it and use Tiny SXW2RML to transform it to RML.

./tiny_sxw2rml.py template.odt > template.rml

You can use python-trml2pdf to see the results:
apt-get install python-trml2pdf

and then
trml2pdf template.rml > template.pdf

If it’s good, you can simply replace placeholders with the text of your report (or packing slip, as we’ve done) and then generate your pdf. Using them on django apps makes RML a very good choice to generate automatically documents from databases and web apps.

Potete scaricare i file della traduzione direttamente sul nostro repository github, in attesa che il team di sviluppatori includa la patch nella branca principale di django-cms:

Scarica la traduzione italiana di django-cms

Per un elenco completo delle novità e dei cambiamenti puoi consultare le note di rilascio; Il download di trova nella pagina del progetto.

Questa versione è il frutto del duro lavoro di centinaia di persone che hanno dato il loro contributo a Django ed hanno speso il loro tempo facendo prove, test e segnalando errori aiutando gli sviluppatori a correggerli ed a sviluppare le nuove funzionalità.

E’ stato realizzato con Satchmo e Django, per il quale SOASI ha già rilasciato alla comunità la traduzione italiana. Il sistema centrale dei pagamenti è basato su Paypal express Checkout, per il quale abbiamo realizzato una libreria Python apposita.

Nel caso si abbiano più amministratori del portale si può però voler filtrare gli oggetti modificabili e visualizzabili dallo staff, a seconda dell’utente. Nel caso di un portale di notizie, ad esempio, può essere necessario filtrare l’elenco degli articoli mostrando solo quelli il cui autore è l’utente loggato, e dare solo al super amministratore la possibilità di vedere tutto.

In django 1.0 ci viene in aiuto la classe admin del nostro modello.

class SchedaOptions(admin.ModelAdmin):
    def has_change_permission(self, request, obj=None):
        if obj and request.user == obj.referente: # (1)
            return super(SchedaOptions, self).has_change_permission(request, obj)
        elif obj is None or request.user.is_superuser:
            return True
        else:
            return False

    def queryset(self, request):
       # Limit the queryset to some subset based on the value of user.
       qs = super(SchedaOptions,self).queryset(request)
       utente = request.user
       if utente.is_superuser:
           return qs
       else:
           return qs.filter(referente=utente) # (2)

In questo esempio solo il referente di una scheda (referente == request.user) può modificare (vedi riga contrassegnata (1), ed il set di oggetti visualizzato (queryset) dall’admin è filtrato con la riga (2).

Una volta salvato provate a loggarvi con il superutente: nulla sarà cambiato (ed è bene che sia così nel 99% dei casi). Entrando con un utente staff, invece, vedrete solo gli oggetti che avete la possibilità di modificare.

Nel pannello di Dreamhost -> Domains -> Manage Domains dovete cliccare sul dominio che volete utilizzare per la vostra applicazione django (nell’esempio sarà domain.com), ed attivare l’opzione “Ruby on Rails Passenger (mod_rails)” NB: questa impostazione cambia la modalità con la quale Apache pubblica le pagine ed i file, quindi dovete assicurarvi di settare questa opzione solo per il dominio o il sottodominio nel quale installerete il progetto Django.

SUl server entrate nella directory /home/user/domain.com e create la sottodirectory “public”:

cd /home/user/domain.com && mkdir public

Tutto quello che risiede in questa directory verrà pubblicato da Apache direttamente, a meno che lo stesso URL non venga intercettato dalle impostazioni degli URL del progetto django .

Ad esempio, se aggiungiamo un file robots.txt dentro /home/user/domain.com/public/ la sua URL sarà www.domain.com/robots.txt, e verrà visualizzato a meno che non sia presente una espressione regolare simile a ‘^robots.txt$’ nel file urls.py di django.

Scaricate il sorgente di django source e decomprimete la cartella django al suo interno nella directory /home/user/domain.com/django. Per assicurarvi di aver scelto correttamente le directory, controllate di avere la sottodirectory /home/user/domain.com/django/core .

Se avete bisogno di alcune librerie python esterne a django ed al vostro progetto, inseritele in /home/user/domain.com/libraries/. Metteremo questa directory nel PYTHONPATH per fare in modo che siano correttamente separate dal resto, rendendo più facili gli aggiornamenti.

Caricate il progetto su /home/user/domain.com/myproject. Se non ne avete ancora uno, potete creare lo scheletro con il comando

cd /home/user/domain.com/
/home/user/domain.com/django/bin/django-admin.py startproject myproject

Non avrete bisogno di nessun file .htaccess, perché la confugurazione di passenger funzionerà anche senza, trovando file e url dinamiche senza il nostro intervento.

A questo punto creato un file chiamato passenger_wsgi.py dentro /home/user/domain.com/:

vim /home/user/domain.com/passenger_wsgi.py

Con questo contenuto:


import sys,os
INTERP = "/usr/bin/python2.4"
if sys.executable != INTERP: os.execl(INTERP, INTERP, *sys.argv)
sys.path.append("/home/user/domain.com/")
sys.path.append("/home/user/domain.com/libraries")
os.environ['DJANGO_SETTINGS_MODULE'] = 'myproject.settings'
import django.core.handlers.wsgi
application = django.core.handlers.wsgi.WSGIHandler()


Dentro /home/user/domain.com/myproject/settings.py controllate le seguenti impostazioni:
MEDIA_ROOT = '/home/user/domain.com/public/media/'
MEDIA_URL = 'http://www.domain.com/media/'
ADMIN_MEDIA_PREFIX = '/admin_media/'


Come potete vedere, la stringa/directory, “public” viene mangiata da passenger, quindi è consigliabile creare una sottodirectory “media” per assicurarci che gli URL dei file statici non vengano oscurati dalle impostazioni del vostro urls.py

Se utilizzate l’admin create un link simbolico per i file css e js contenuti in admin_media:
cd /home/user/domain.com/public/
ln -s home/user/domain.com/django/contrib/admin/media/ admin_media

E’ tutto, ed è molto più semplice di quanto sembri. Una volta creato il progetto sarà molto facile aggiornarlo ed apportarvi modifiche, grazie alla corretta separazione nel deploy dell’applicazione dei file statici, di django, del progetto e delle librerie python.

Dopo ogni modifica al codice, se volete controllarlo potete eseguire un
pkill python
che obbligherà il server a ricopilare e ricaricare i file python (con un piccolo prezzo in termini di tempo, necessario al primo avvio).

Potete approfondire questo tema su:
Passenger WSGI
Dreamhost Passenger
Django on Dreamhost with FCGI

In Dreamhost panel -> Domains -> Manage Domains click on the domain you want to put your app on (in the example we will set domain.com), and activate “Ruby on Rails Passenger (mod_rails)” option. Pay attention: it change the way it serves files on that domains, so be sure to set this option only on the domain or subdomain you want to use with django.

On the server side, enter on /home/user/domain.com and create a “public” subdir:

cd /home/user/domain.com && mkdir public

Everything inside this dir will be served on the root web URL, after checking if there’s any django url matching it.

So, if you add a robots.txt inside /home/user/domain.com/public/ the url will be www.domain.com/robots.txt if there’s no ‘^robots.txt$’ or similar match in your urls.py django file.

Download django source code and unzip the django dir inside on /home/user/domain.com/django. To make sure you have done correctly check if you have /home/user/domain.com/django/core directory.

If you need some other python libraries, put them into /home/user/domain.com/libraries/. We will put this dir on the PYTHONPATH to collect them in a separate directory outside django and your project.

Upload your project on /home/user/domain.com/myproject. If you don’t have already one, you can create it calling

cd /home/user/domain.com/
/home/user/domain.com/django/bin/django-admin.py startproject myproject

You don’t need any htaccess file, because passenger knows already where to find things.

Create a file called passenger_wsgi.py inside /home/user/domain.com/:

vim /home/user/domain.com/passenger_wsgi.py

With this content:


import sys,os
INTERP = "/usr/bin/python2.4"
if sys.executable != INTERP: os.execl(INTERP, INTERP, *sys.argv)
sys.path.append("/home/user/domain.com/")
sys.path.append("/home/user/domain.com/libraries")
os.environ['DJANGO_SETTINGS_MODULE'] = 'myproject.settings'
import django.core.handlers.wsgi
application = django.core.handlers.wsgi.WSGIHandler()


On /home/user/domain.com/myproject/settings.py file check settings:
MEDIA_ROOT = '/home/user/domain.com/public/media/'
MEDIA_URL = 'http://www.domain.com/media/'
ADMIN_MEDIA_PREFIX = '/admin_media/'


As you can see, “public” is eaten by passenger, so it’s useful to create a subdir to be sure the URL of files will not conflict with urls.py settings.

Create a symbolic link for admin_media:
cd /home/user/domain.com/public/
ln -s home/user/domain.com/django/contrib/admin/media/ admin_media

That’s all. It’s simpler than it seems. To reload a modify setting or python file, simply do

pkill python

Read also:
Passenger WSGI
Dreamhost Passenger
Django on Dreamhost with FCGI

Si tratta del rilascio più importante dalla nascita di questo framework web per perferzionisti con scadenze, come viene definito dagli autori.

SOASI lo utilizza per un buon numero di progetti, come www.animalisenzacasa.org, ed i prossimi in arrivo si baseranno sul codice presente nella versione 1.0