mode debug : demander le format .debug

[restcoda.git] / objet.py

#!/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/modeles/'))

# 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')
	if not self.outputformat == 'debug':
	    modele = '%s.%s' % (template,self.outputformat)
	else:
	    modele = 'debug'
	return ejinja.get_template( modele )

    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()

# exception levée quand une requete SQL ne revoit rien
class ObjetInconnu(Exception):
    def __init__(self, type):
        self.type = type
    def __str__(self):
        return self.type