#
# 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"
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
# 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)
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"""
if hasattr(self,'db_connect'):
db_connect.close()
+class ObjetSQLInconnuError(Exception):
+ def __init__(self, type):
+ self.type = type
+ def __str__(self):
+ return self.type
+
# 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
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"""
--- /dev/null
+<pre>{{ debug()|e }}</pre>
+
--- /dev/null
+<utilisateur>
+ <code>{{ code }}</code>
+ <nom>{{ nom }}</nom>
+ <nom_connexion>{{ nom_connexion }}</nom_connexion>
+ <date_connexion>{{ date_connexion }}</date_connexion>
+ <implantation>{{ implantation }}</implantation>
+</utilisateur>
+
--- /dev/null
+#!/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
+