Objet au lieu de ObjetSQL. bug statut dans document/id
authorThomas NOEL <thomas@new-dev.(none)>
Fri, 4 Jul 2008 17:18:57 +0000 (13:18 -0400)
committerThomas NOEL <thomas.noel@auf.org>
Fri, 4 Jul 2008 17:18:57 +0000 (13:18 -0400)
document.py
objet.py [new file with mode: 0644]
objetsql.py [deleted file]
rest.py
utilisateur.py

index d2aac0f..664e750 100644 (file)
@@ -8,10 +8,10 @@
 # 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'):
@@ -20,14 +20,15 @@ class Document(ObjetSQL):
         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 = []
@@ -62,7 +63,7 @@ class Document(ObjetSQL):
        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
diff --git a/objet.py b/objet.py
new file mode 100644 (file)
index 0000000..56b0768
--- /dev/null
+++ b/objet.py
@@ -0,0 +1,77 @@
+#!/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
+
diff --git a/objetsql.py b/objetsql.py
deleted file mode 100644 (file)
index 74bd55c..0000000
+++ /dev/null
@@ -1,77 +0,0 @@
-#!/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
-
diff --git a/rest.py b/rest.py
index 11049bf..73f7e4e 100644 (file)
--- a/rest.py
+++ b/rest.py
@@ -13,7 +13,7 @@ from routes.middleware import RoutesMiddleware
 
 # 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
@@ -62,7 +62,7 @@ def dispatcher(environ, start_response):
        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:
index f184361..c5c28f6 100644 (file)
@@ -5,10 +5,10 @@
 # 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):
@@ -41,7 +41,7 @@ class utilisateur(ObjetSQL):
        cursor.execute( request )
         utilisateur = dict_fetchone(cursor)
        if utilisateur == None:
-           raise ObjetSQLInconnuError('utilisateur')
+           raise ObjetInconnu('utilisateur')
        utilisateur['requete_sql'] = request
         return utilisateur