# générique, qui sera hérité. Chaque classe fille précisera le code du document.
#
-from objetsql import ObjetSQL, ObjetSQLInconnuError
+from objet import Objet, ObjetInconnu
from utils import dict_fetchone, coda2rest
-class Document(ObjetSQL):
+class Document(Objet):
"""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'):
self.prefix_template = prefix_template
# filtrage : si aucun statut n'est spécifié, on prend "statut like non%"
if self.sqlwhere != '': self.sqlwhere = ' and ' + self.sqlwhere
- if not 'statut' in self.filters:
- self.sqlwhere = " and (statut like 'non%') " + self.sqlwhere
def _get_index(self, code):
"""renvoie une liste de documents"""
# connexion a la base de données
cursor = self.cursor()
# extraction des données
+ # statut par defaut : non-autorisé
+ if not 'statut' in self.filters:
+ self.sqlwhere = " and (statut like 'non%') " + self.sqlwhere
request = "select top %d * from auf_v_acces_demcom where (code like '%s') %s order by date_modif desc" % ( self.sqllimit, code, self.sqlwhere )
cursor.execute( request )
items = []
cursor.execute( request )
document = dict_fetchone(cursor)
if document == None:
- raise ObjetSQLInconnuError('document')
+ raise ObjetInconnu('document')
document['code_rest'] = coda2rest( document['code'] )
document['details'] = self._get_details( code,id )
document['requete_sql'] = request
--- /dev/null
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+#
+# Un "Objet" dispose de tout ce qui est nécessaire pour extraire
+# les données (accès au MS-SQL) et pour en faire le rendu final
+# (accès au système de template)
+#
+# Il analyse également l'environnement WSGI afin d'en extraire
+# les données de filtrage (extrait des arguments de l'URL, après le ?)
+# et de les transformer en critères SQL (where, limit, order)
+
+# l'accès à MS-SQL
+from pymssql import connect
+
+# le système de template
+from jinja import Environment, FileSystemLoader
+ejinja = Environment(loader=FileSystemLoader('/home/thomas/public_html/templates/'))
+
+# le système d'analyse des variables HTTP
+from paste.request import parse_formvars
+
+# accès à la configuration (données pour la connexion MS-SQL)
+import sys
+sys.path.append('/home/thomas/public_html/')
+import rest_config
+
+
+class Objet(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 traduction des variables HTTP (filtres) en SQL"""
+ self.environ = environ
+ parse_formvars(environ) # extraction des variables de query_string et POST
+ self.filters = environ['paste.parsed_formvars'][0].dict_of_lists() # puis traduction en dictionnaire {var1:[val1,val2], ...}
+ # filtrage : on extrait la liste des filtres "acceptes" pour en faire des where
+ sqlwhere = []
+ if hasattr(self,'accept_like_filters'):
+ 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 ici filtres min_*/max_*, avant/apres
+ 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 = 50
+ # TODO : ajouter filtres tri_asc/tri_desc
+ self.sqlorder = ''
+
+ def template(self,template):
+ """Retourne un environnement de rendu"""
+ self.outputformat = self.environ['wsgiorg.routing_args'][1].get('format','xml')
+ return ejinja.get_template('%s.%s' % (template,self.outputformat))
+ def cursor(self):
+ """Retourne un curseur vers la base de données"""
+ if not hasattr(self,'db_connect'):
+ self.db_connect = connect(host=rest_config.host,user=rest_config.user,password=rest_config.password,database=rest_config.database)
+ if not hasattr(self,'db_cursor'):
+ self.db_cursor = self.db_connect.cursor()
+ return self.db_cursor
+ def __del__(self):
+ """Destructeur : coupe la connexion à MSSQL à la mort de l'objet"""
+ # (normalement ça se fait tout seul mais j'en suis pas sûr sûr)
+ if hasattr(self,'db_connect'):
+ db_connect.close()
+
+class ObjetInconnu(Exception):
+ def __init__(self, type):
+ self.type = type
+ def __str__(self):
+ return self.type
+
+++ /dev/null
-#!/usr/bin/python
-# -*- coding: utf-8 -*-
-
-#
-# Un "objetsql" dispose de tout ce qui est nécessaire pour extraire
-# les données (accès au MS-SQL) et pour en faire le rendu final
-# (accès au système de template)
-#
-# Il analyse également l'environnement WSGI afin d'en extraire
-# les données de filtrage (extrait des arguments de l'URL, après le ?)
-# et de les transformer en critères SQL (where, limit, order)
-
-# l'accès à MS-SQL
-from pymssql import connect
-
-# le système de template
-from jinja import Environment, FileSystemLoader
-ejinja = Environment(loader=FileSystemLoader('/home/thomas/public_html/templates/'))
-
-# le système d'analyse des variables HTTP
-from paste.request import parse_formvars
-
-# accès à la configuration (données pour la connexion MS-SQL)
-import sys
-sys.path.append('/home/thomas/public_html/')
-import rest_config
-
-
-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 traduction des variables HTTP (filtres) en SQL"""
- self.environ = environ
- parse_formvars(environ) # extraction des variables de query_string et POST
- self.filters = environ['paste.parsed_formvars'][0].dict_of_lists() # puis traduction en dictionnaire {var1:[val1,val2], ...}
- # filtrage : on extrait la liste des filtres "acceptes" pour en faire des where
- sqlwhere = []
- if hasattr(self,'accept_like_filters'):
- 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 ici filtres min_*/max_*, avant/apres
- 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 = 50
- # TODO : ajouter filtres tri_asc/tri_desc
- self.sqlorder = ''
-
- def template(self,template):
- """Retourne un environnement de rendu"""
- self.outputformat = self.environ['wsgiorg.routing_args'][1].get('format','xml')
- return ejinja.get_template('%s.%s' % (template,self.outputformat))
- def cursor(self):
- """Retourne un curseur vers la base de données"""
- if not hasattr(self,'db_connect'):
- self.db_connect = connect(host=rest_config.host,user=rest_config.user,password=rest_config.password,database=rest_config.database)
- if not hasattr(self,'db_cursor'):
- self.db_cursor = self.db_connect.cursor()
- return self.db_cursor
- def __del__(self):
- """Destructeur : coupe la connexion à MSSQL à la mort de l'objet"""
- # (normalement ça se fait tout seul mais j'en suis pas sûr sûr)
- 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
+from objet import ObjetInconnu
# TODO : ajouter un middleware de cache (beaker, basé sur REQUEST_URI quand la methode est GET)
# from beaker.middleware import CacheMiddleware
start_response("200 OK", [('Content-type', formats[type])])
return output.encode('utf-8')
# gestion des problèmes possibles pendant l'exécution
- except ObjetSQLInconnuError, type:
+ except ObjetInconnu, type:
start_response("404 Not Found", [('Content-type', 'text/html')])
return '<html><body><h2>404 %s inexistant</h2></body></html>' % type
except TemplateNotFound, template:
# Classe pour un utilisateur
# (export de la vue auf_v_acces_users)
-from objetsql import ObjetSQL, ObjetSQLInconnuError
+from objet import Objet, ObjetInconnu
from utils import dict_fetchone
-class utilisateur(ObjetSQL):
+class utilisateur(Objet):
"""objet utilisateur CODA"""
accept_like_filters = [ 'code', 'nom', 'nom_connexion', 'implantation' ]
def __init__(self, environ):
cursor.execute( request )
utilisateur = dict_fetchone(cursor)
if utilisateur == None:
- raise ObjetSQLInconnuError('utilisateur')
+ raise ObjetInconnu('utilisateur')
utilisateur['requete_sql'] = request
return utilisateur
projets / restcoda.git / commitdiff
