ajout objet utilisateur
authorThomas NOEL <thomas@new-dev.(none)>
Fri, 4 Jul 2008 15:52:48 +0000 (11:52 -0400)
committerThomas NOEL <thomas.noel@auf.org>
Fri, 4 Jul 2008 15:52:48 +0000 (11:52 -0400)
document.py
objetsql.py
rest.py
templates/utilisateur-index.html [new file with mode: 0644]
templates/utilisateur.xml [new file with mode: 0644]
utilisateur.py [new file with mode: 0644]

index a9eeba0..4ab0339 100644 (file)
@@ -4,18 +4,18 @@
 #
 # Classes pour les documents DEM-* et COM-*
 #
-# Ces documents ont tous les même format. On créé donc un objet "document"
+# Ces documents ont tous les même format. On créé donc une classe "Document"
 # générique, qui sera hérité. Chaque classe fille précisera le code du document.
 #
 
-from objetsql import *
-from utils import *
+from objetsql import ObjetSQL, ObjetSQLInconnuError
+from utils import dict_fetchone, coda2rest
 
-class document(objetsql):
+class Document(ObjetSQL):
     """objet document CODA (demlog, comlog, demdep... ils ont tous le même format)"""
     accept_like_filters = [ 'code', 'demandeur', 'approbateur', 'code_service', 'statut', 'fournisseur', 'statut' ]
     def __init__(self, environ, code_document='%', prefix_template='document'):
-        super(document, self).__init__(environ)
+        super(Document, self).__init__(environ)
         self.code_document = code_document
         self.prefix_template = prefix_template
        # TODO : voir si on peut faire le filtrage dans "objetsql"
@@ -77,7 +77,7 @@ class document(objetsql):
         cursor.execute("select top 1 * from auf_v_acces_demcom where (code like '%s') and (numero = %d) %s" % (code, id, self.sqlwhere))
         document = dict_fetchone(cursor)
        if document == None:
-           raise "document inexistant"
+           raise ObjetSQLInconnuError('document')
        document['code_rest'] = coda2rest( document['code'] )
         document['details'] = self._get_details( code,id )
        return document
@@ -102,50 +102,50 @@ class document(objetsql):
 # les classes filles précisent le code_document
 #
 
-class dem(document):
+class dem(Document):
     def __init__(self, environ):
         super(dem, self).__init__(environ, code_document = 'DEM-%')
 
-class com(document):
+class com(Document):
     def __init__(self, environ):
         super(com, self).__init__(environ, code_document = 'COM-%')
 
-class demlog(document):
+class demlog(Document):
     def __init__(self, environ):
         super(demlog, self).__init__(environ, code_document = 'DEM-LOG-AUF')
 
-class comlog(document):
+class comlog(Document):
     def __init__(self, environ):
         super(comlog, self).__init__(environ, code_document = 'COM-LOG-AUF')
 
-class demdep(document):
+class demdep(Document):
     def __init__(self, environ):
         super(demdep, self).__init__(environ, code_document = 'DEM-DEP-AUF')
 
-class comdep(document):
+class comdep(Document):
     def __init__(self, environ):
         super(comdep, self).__init__(environ, code_document = 'COM-DEP-AUF')
 
-class dempub(document):
+class dempub(Document):
     def __init__(self, environ):
         super(dempub, self).__init__(environ, code_document = 'DEM-PUB-AUF')
 
-class compub(document):
+class compub(Document):
     def __init__(self, environ):
         super(compub, self).__init__(environ, code_document = 'COM-PUB-AUF')
 
-class comsre(document):
+class comsre(Document):
     def __init__(self, environ):
         # on distingue comsre et comsrexxx (avec xxx = implantation)
         impl = environ['wsgiorg.routing_args'][1].get('impl','%')
         super(comsre, self).__init__(environ, code_document = 'COM-SRE-%s' % impl)
 
-class comare(document):
+class comare(Document):
     def __init__(self, environ):
         impl = environ['wsgiorg.routing_args'][1].get('impl','%')
         super(comare, self).__init__(environ, code_document = 'COM-ARE-%s' % impl)
 
-class comxre(document):
+class comxre(Document):
     def __init__(self, environ):
         impl = environ['wsgiorg.routing_args'][1].get('impl','%')
         super(comxre, self).__init__(environ, code_document = 'COM-%%RE-%s' % impl)
index c726ef9..c4d3804 100644 (file)
@@ -26,7 +26,7 @@ sys.path.append('/home/thomas/public_html/')
 import rest_config
 
 
-class objetsql(object):
+class ObjetSQL(object):
     """Objet de base : dispose d'un accès à MS-SQL (lire les données) et d'un accès à jinja (rendu des données)"""
     def __init__(self, environ):
         """Conserve l'environnement WSGI et analyse les variables HTTP"""
@@ -50,3 +50,9 @@ class objetsql(object):
         if hasattr(self,'db_connect'):
            db_connect.close()
 
+class ObjetSQLInconnuError(Exception):
+    def __init__(self, type):
+        self.type = type
+    def __str__(self):
+        return self.type
+
diff --git a/rest.py b/rest.py
index 0c3caf6..2fc3494 100644 (file)
--- a/rest.py
+++ b/rest.py
@@ -13,6 +13,7 @@ from routes.middleware import RoutesMiddleware
 
 # Gestion des erreurs
 from jinja.exceptions import TemplateNotFound
+from objetsql import ObjetSQLInconnuError
 
 # TODO : ajouter un middleware de cache (beaker, basé sur REQUEST_URI quand la methode est GET)
 # from beaker.middleware import CacheMiddleware
@@ -38,9 +39,11 @@ mapper.resource('comxre','comxre') # comxre = comare + comsre
 mapper.resource('comxrei','comxre:(impl)',controller='comxre')
 mapper.resource('dem','dem')
 mapper.resource('com','com')
+mapper.resource('utilisateur','utilisateur')
 
 # objets disponibles
 from document import demlog, comlog, demdep, comdep, dempub, compub, comare, comsre, comxre, dem, com
+from utilisateur import utilisateur
 
 def dispatcher(environ, start_response):
     """dispatch vers la bonne methode du bon objet, et retour WSGI"""
diff --git a/templates/utilisateur-index.html b/templates/utilisateur-index.html
new file mode 100644 (file)
index 0000000..5f07ff3
--- /dev/null
@@ -0,0 +1,2 @@
+<pre>{{ debug()|e }}</pre>
+
diff --git a/templates/utilisateur.xml b/templates/utilisateur.xml
new file mode 100644 (file)
index 0000000..dcd587a
--- /dev/null
@@ -0,0 +1,8 @@
+<utilisateur>
+  <code>{{ code }}</code>
+  <nom>{{ nom }}</nom>
+  <nom_connexion>{{ nom_connexion }}</nom_connexion>
+  <date_connexion>{{ date_connexion }}</date_connexion>
+  <implantation>{{ implantation }}</implantation>
+</utilisateur>
+
diff --git a/utilisateur.py b/utilisateur.py
new file mode 100644 (file)
index 0000000..d2a3446
--- /dev/null
@@ -0,0 +1,76 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+#
+# Classe pour un utilisateur
+# (export de la vue auf_v_acces_users)
+
+from objetsql import ObjetSQL, ObjetSQLInconnuError
+from utils import dict_fetchone
+
+class utilisateur(ObjetSQL):
+    """objet utilisateur CODA"""
+    accept_like_filters = [ 'code', 'nom', 'nom_connexion', 'implantation' ]
+    def __init__(self, environ):
+        super(utilisateur, self).__init__(environ)
+       # TODO : voir si on peut faire le filtrage dans "objetsql"
+       # filtrage : on extrait la liste des filtres "acceptes" pour en faire des where
+        sqlwhere = []
+       for filter in self.accept_like_filters:
+            if filter in self.filters:
+               or_list = []
+               for v in self.filters[filter]:
+                   or_list.append("%s like '%s'" % (filter,v.replace('*','%')))
+               sqlwhere.append('(' + ' or '.join(or_list) + ')')
+       # TODO : ajouter filtres min_*/max_*, avant/apres dans ce sqlwhere
+       self.sqlwhere = ' and '.join(sqlwhere)
+       # filtrage : valeur en cas de limite ("top n" en ODBC), 200 maxi
+       if 'limite' in self.filters:
+           self.sqllimit = min( int(self.filters['limite'][0]), 200 )
+       else:
+           self.sqllimit = 15
+       # TODO : ajouter filtres tri_asc/tri_desc
+       self.sqlorder = ''
+
+    def _get_index(self):
+        """renvoie une liste d'utilisateur"""
+       # connexion a la base de données
+       cursor = self.cursor()
+       if self.sqlwhere != '': self.sqlwhere = ' where ' + self.sqlwhere
+       # extraction des données
+       cursor.execute("select top %d * from auf_v_acces_users %s order by date_connexion desc" % ( self.sqllimit, self.sqlwhere ) )
+       items = []
+       while 1:
+           item = dict_fetchone( cursor )
+           if item == None: break
+           items.append(item)
+       index = {}
+       index['filtres'] = self.filters
+       index['utilisateurs'] = items
+       return index
+
+    def _get_utilisateur(self,code):
+        """renvoie un utilisateur"""
+       cursor = self.cursor()
+       if self.sqlwhere != '': self.sqlwhere = ' and ' + self.sqlwhere
+        cursor.execute("select top 1 * from auf_v_acces_users where (code like '%s') %s" % (code, self.sqlwhere))
+        utilisateur = dict_fetchone(cursor)
+       if utilisateur == None:
+           raise ObjetSQLInconnuError('utilisateur')
+        return utilisateur
+
+    def index(self):
+        """renvoie une liste d'utilisateurs formatée"""
+        template = self.template('utilisateur-index') # préparation du modèle
+       index = self._get_index( )                    # extraction des documents concernés
+       output = template.render( index )             # formattage via le modèle
+       return self.outputformat, output
+
+    def show(self):
+        """renvoie un utilisateur formaté"""
+        code = self.environ['wsgiorg.routing_args'][1]['id'].replace('*','%').upper()
+        template = self.template( 'utilisateur' )
+        utilisateur = self._get_utilisateur( code )
+        output = template.render( utilisateur )
+       return self.outputformat, output
+