DJANGO PERMISSION

Salut 😉

Aujourd’hui  je vais   parler  de l’utilisation des  permissions  dans une application django

.Pour illustrer j’utiliserai quelques codes sources  d’une application que j’ai développé  récemment  (supervisors)  et qui se trouve dans mon compte github .

simple   exemples .

* la saisie d’un superviseur  nécessite une authentification

    
@login_required
def  edit_sup(req ,pk , tpl_name ="supervisor/edit.html"):
    """ Edit supervisor of village"""
    context ={}
    sup =get_object_or_404 (Supervisor , id =pk)
    if req.method =="POST":
    form =  SupervisorForm(req.POST, instance = sup)
    if form.is_valid ():
         form.save ()
         context ['statut']=_('Edit success')
   else :
         context["error"] = form.errors
   else:
         form =SupervisorForm(instance = sup)

   context['form'] = form
   context['sup']  = sup
   context['title']= _("Edit supervisor title")
   return render_to_response  (tpl_name , context)

Ce bout de code ne sera exécuté tant que l’utilisateur n’est pas authentifié . A chaque tentative échouée  DJANGO renverra a nouveau vers la page d’authentification .

La deuxième façon fréquente  d’utiliser les permissions sous django est  d’exiger un certains type de permission  de l’utilisateur pour faire un traitement .Par exemple

dans le code qui suit je veux que l’utilisateur qui exécute l’export dispose  de  la permission   (can_export)

*  Code

@permission_required ("permission.can_export")
def export_sup(req):
   """ export  villages or supervisors  data """
   try:
   ass_dict  = []
   for sup in  Supervisor.objects.all():
       keys  = sup.data_count.keys()
       ass_dict.append (sup.data_count)
       # Exporting suppervisor data
       return export_dict(list(keys), ass_dict)
 except Exception  ,e:
      print  "Error export data "
      print  e
      return HttpResponse (
      """
      Exception when reporting data , please
      please contact  :dia.aliounes@gmail.com
      """)

Ne soyez pas surpris  de voir( permission.can_export )   au lieu  de (permission)  .Sachez que sous django les permissions doivent être liées  à des models de données .Naturellement  un model peut juste contenir des permissions ce que j’ai fais  .

* models.py

 class Permission(models.Model):
 """
 This model  does nothing It exist only to handle permissions
 for users using Web UI interface
 """
 class Meta:
     permissions = (
     ("can_export" , "can  export"),
     ("can_edit" , "can  edit"),    
     ("can_see" , "can  see"),
 )

Voila c’est  tout  , a plus   😉

DJANGO AUTHENTIFICATION

Salut  😉

L’un des problèmes auxquels  le développeurs sont souvent confrontés lorsqu’ils développent des  applications  sont:

* Comment gérer les utilisateurs  , les groupes

* Comment gérer les permissions des utilisateurs

*Comment gérer les sessions

* Comment gérer l’authentification

Cet article répond a l’une de ces question comment authentifier dans une application django  , c’est très simple.

*    urls.py

    from django.conf.urls.defaults import *

# Uncomment the next two lines to enable the admin:

from django.contrib import admin
from django.contrib.auth.decorators import login_required
from django.views.generic.simple import direct_to_template
from login_logout import  views

admin.autodiscover()

urlpatterns = patterns('',
 # Example:
 # (r'^projects/', include('projects.foo.urls')),
 # Uncomment the admin/doc line below and add 'django.contrib.admindocs'
 # to INSTALLED_APPS to enable admin documentation:
 (r'^$' , login_required(direct_to_template),
 {"template" : "partials/welcom.html" }),
 (r'^accounts/login' , 'django.contrib.auth.views.login'),
)

lorsque l’utilisateur accède   a l’URL  (r’^$’)  , django vérifie  qu’il est bien authentifié , sinon  alors une redirection est faite  vers  (/accounts/login).

Lorsque l’url  (r’^$’)  est parsé alors la vue (django.contrib.auth.views.login)  est appelée .Cette vue renvoie au template  (/registration/login.html)  se trouvant dans votre répertoire de template  . Voici un exemple classique de ce fichier de template .

* login.html

{% extends "base.html" %}
{% block content %}
{% if form.errors %}
<p>Your username and password didn't match. Please try again.</p>
{% endif %}
<form method="post" action="{% url django.contrib.auth.views.login %}">{% csrf_token %}
<table>
<tr>
 <td>{{ form.username.label_tag }}</td>
 <td>{{ form.username }}</td>
</tr>
<tr>
 <td>{{ form.password.label_tag }}</td>
 <td>{{ form.password }}</td>
</tr>
</table>
<input type="submit" value="login" />
<input type="hidden" name="next" value="{{ next }}" />
</form>

{% endblock %

Si l’utilisateur s’est authentifiée alors  la redirection est faite vers  le template defini dans  ( {‘template’ :’partials/welcom.html’})   dans mon cas  .Naturellement vous pouvez faire une redirection  la ou vous voulez  ( partials/welcom.html  n’est qu’un exemple de template  😉  )

* welcom.html

{% if user.is_authenticated %}
 <p>Welcome, {{ user.username }}. Thanks for logging in.</p>
{% else %}
 <p>Welcome, new user. Please log in.</p>
{% endif %}

Voila c’est  tout 😉

RAPIDSMS APP

Bonsoir  je suis un peu insomniaque aujourd’hui alors je vais parler de RAPIDSMS 😉

RAPIDSMS est un framework applicatif de UNICEF  permettant de développer des applications SMS essentiellement .

Cependant RAPIDSMS peut aussi faire EMAIL , IRC , KANNEL  , Bref vous pouvez  programmer n’ importe quel Backend .

L’application que je vais programmer est inspirée  par le Séminaire WARA (West African Research Association)

Par ce cas pratique , l’application  RAPIDSMS que j’appellerai (waraseminaire)  permettra de créer un système d’ enregistrement des

présentations du séminaire  .Également La possibilité de consulter les présentations sera traitée .

Vous pouvez  télécharger le code source de cette application sur mon compte github

http://github.com/aliounedia/rapidsms-senegal/tree/master/apps/wara

ou  faire un clone

http://github.com/aliounedia/rapidsms-senegal.git

1 . Installation de  RAPIDSMS

~$ git clone git://github.com/rapidsms/rapidsms.git
~$ cd rapidsms
~rapidsms$

2 .Firing UP RAPIDSMS

~rapidsms$ python rapidsms syncdb
Creating table auth_permission
Creating table auth_group
Creating table auth_user
Creating table auth_message
Creating table django_content_type
Creating table django_session
Creating table django_site
Creating table django_admin_log
Creating table httptester_message
Creating table locations_locationtype
Creating table locations_location
Creating table patterns_pattern
Creating table reporters_role
Creating table reporters_reportergroup
Creating table reporters_reporter
Creating table reporters_persistantbackend
Creating table reporters_persistantconnection
Creating table logger_incomingmessage
Creating table logger_outgoingmessage

You just installed Django's auth system, which means you don't have any superusers defined.
Would you like to create one now? (yes/no):

3 .Creating new Application

~rapidsms$ python rapidsms startapp mileage
Don't forget to add 'mileage' to your rapidsms.ini apps.
~rapidsms$

C’est fini on peut maintenant commencer a écrire la logique  de notre application:)
4 .Editer le fichier app.py  avec le code suivant :
C’est ce fichier qui contient la logique métier de votre application .Lorsque le Backend GSM lit un SMS du modem ,
il parse ce fichier et exécute les  méthodes  handle , parse  ,…
import rapidsms
from rapidsms.parsers.keyworder import *
import models as m
import time
from datetime import datetime
from time import localtime
class App (rapidsms.app.App):
    kw = Keyworder ()
    def start (self):
        """Configure your app in the start phase."""
        pass
    def parse (self, message):
        """Parse and annotate messages in the parse phase."""
        pass
    def handle (self, message):
        """Add your main application logic in the handle phase."""
        # pass
        try:
           function , captures = self.kw.match (self, message.text)
           function (self,message ,*captures)
        except Exception , e:
            message.respond ("Invalid commande : wara theme [theme]  date [date] ")
    @kw("help")
    def help (message):
        message.respond ("wara theme <theme> date <jour mois>")
    @kw("wara theme (.+) date (\d\d? \d\d?)")
    def add_presentation (self , message , theme , date):
	"""
	Ajouter un nouveau presentateur au seminaire
	"""
        try:
	    jr  , hr  =tuple(date.split())
            an ,mois = localtime ()[0], localtime()[1]
            m.Seminaire.objects.create\
            (theme=theme , phone =message.connection.identity,
                    date=datetime (int (an),int (mois),int (jr),int (hr)))
            message.respond ("Merci d'avoir proposer un theme  au seminaire ,\
                    tapez [wara themes] pour la liste")
            return True
        except Exception , e:
            print "Exception"
            print e
    @kw ("wara themes|warathemes")
    def _get_wara_themes (self , message , *args):
        """
	Lister tous les themes proposes lors du seminaire WARA
        (WEST AFRICAN RESEARCH )
	"""
        def to_str(el):
            return  "[Presentation: %s ,Date : le %s a %s Heures]"%\
                        (el.theme  ,el.date.day ,  el.date.hour)
        def _get_presentation (old_list , given_el):
             try:
                   item  =old_list [-1]
                   new_given  = to_str (item) + given_el
                   if len (new_given)>= 140:
                        return given_el
                   else :
                        old_list.pop ()
                        return  new_given
             except Exception , e:
                print "Into _get_presentation"
                print  e
                return  given_el
        seminaires  = m.Seminaire.objects.all ()
        if not seminaires  or len (seminaires)==0:
            message.respond  ("Aucun seminaire pour le  moment")
            return
        # We got some presentations into data base
        seminaires  = list (seminaires)
        given_el    =  seminaires.pop ()
        given_el    = to_str (given_el)
        while True :
            try:
                output_el  =_get_presentation (seminaires , given_el)
                # Good message size
                if  output_el  == given_el:
                    message.respond(output_el)
                    given_el  =to_str (seminaires.pop ())
                    time.sleep (10)
                else :
                     given_el =output_el
            except Exception , e :
                print  e
                break 

    def cleanup (self, message):
        """Perform any clean up after all handlers have run in the
        cleanup phase."""
        pass
    def outgoing (self, message):
        """Handle outgoing message notifications."""
        pass
    def stop (self):
        """Perform global app cleanup when the application is stopped."""
        pass

5.Editer le fichier models.py
C’est votre model de données ,exactement comme sous DJANGO , en fait RAPIDMS enveloppe DJANGO
from django.db import models
from time import localtime
from datetime import datetime
# Create your Django models here, if you need them.
class Seminaire(models.Model):
    """
    Model to Store all communication
    """
    phone = models.CharField (max_length =160)
    theme = models.CharField (max_length =160)
    date = models.DateTimeField ()
    def __unicode__(self):
        return (" %s:%s:%s "%(self.phone  , self.theme , self.date))

5.Screenshot:
Ce diaporama nécessite JavaScript.




Voici le resultat obtenu  avec le WEB UI Interface
Vous pouvez brancher votre modem (Mutlitech s’il vous plait  ; ) ) et  laisser votre systeme tourner 😉



app.py

import rapidsms

from rapidsms.parsers.keyworder import *

import models as m

import time

from datetime import datetime

from time import localtime
class App (rapidsms.app.App):

kw = Keyworder ()

def start (self):

«  » »Configure your app in the start phase. » » »

pass
def parse (self, message):

«  » »Parse and annotate messages in the parse phase. » » »

pass
def handle (self, message):

«  » »Add your main application logic in the handle phase. » » »

# pass

try:

function , captures = self.kw.match (self, message.text)

function (self,message ,*captures)

except Exception , e:

print « Exception when handling message »

print e
@kw(« help »)

def help (message):

message.respond (« wara theme <theme> date <jour mois> »)
@kw(« wara theme (.+) date (\d\d? \d\d?) »)

def add_presentation (self , message , theme , date):

«  » »

Ajouter un nouveau presentateur au seminaire

1,1          Haut