openerp/addons/base/ir/ir_http.py

   1 #----------------------------------------------------------
   2 # ir_http modular http routing
   3 #----------------------------------------------------------
   4 import logging
   5 import re
   6 import sys
   7
   8 import werkzeug.exceptions
   9 import werkzeug.routing
  10
  11 import openerp
  12 from openerp import http
  13 from openerp.http import request
  14 from openerp.osv import osv, orm
  15
  16 _logger = logging.getLogger(__name__)
  17
  18 UID_PLACEHOLDER = object()
  19
  20 class ModelConverter(werkzeug.routing.BaseConverter):
  21
  22     def __init__(self, url_map, model=False):
  23         super(ModelConverter, self).__init__(url_map)
  24         self.model = model
  25         self.regex = '([0-9]+)'
  26
  27     def to_python(self, value):
  28         m = re.match(self.regex, value)
  29         return request.registry[self.model].browse(
  30             request.cr, UID_PLACEHOLDER, int(m.group(1)), context=request.context)
  31
  32     def to_url(self, value):
  33         return value.id
  34
  35 class ModelsConverter(werkzeug.routing.BaseConverter):
  36
  37     def __init__(self, url_map, model=False):
  38         super(ModelsConverter, self).__init__(url_map)
  39         self.model = model
  40         # TODO add support for slug in the form [A-Za-z0-9-] bla-bla-89 -> id 89
  41         self.regex = '([0-9,]+)'
  42
  43     def to_python(self, value):
  44         return request.registry[self.model].browse(request.cr, UID_PLACEHOLDER, [int(i) for i in value.split(',')], context=request.context)
  45
  46     def to_url(self, value):
  47         return ",".join(i.id for i in value)
  48
  49 class ir_http(osv.AbstractModel):
  50     _name = 'ir.http'
  51     _description = "HTTP routing"
  52
  53     def _get_converters(self):
  54         return {'model': ModelConverter, 'models': ModelsConverter}
  55
  56     def _find_handler(self):
  57         return self.routing_map().bind_to_environ(request.httprequest.environ).match()
  58
  59     def _auth_method_user(self):
  60         request.uid = request.session.uid
  61         if not request.uid:
  62             raise http.SessionExpiredException("Session expired")
  63
  64     def _auth_method_admin(self):
  65         if not request.db:
  66             raise http.SessionExpiredException("No valid database for request %s" % request.httprequest)
  67         request.uid = openerp.SUPERUSER_ID
  68
  69     def _auth_method_none(self):
  70         request.disable_db = True
  71         request.uid = None
  72
  73     def _auth_method_public(self):
  74         if not request.session.uid:
  75             dummy, request.uid = self.pool['ir.model.data'].get_object_reference(request.cr, openerp.SUPERUSER_ID, 'base', 'public_user')
  76         else:
  77             request.uid = request.session.uid
  78
  79     def _authenticate(self, auth_method='user'):
  80         if request.session.uid:
  81             try:
  82                 request.session.check_security()
  83                 # what if error in security.check()
  84                 #   -> res_users.check()
  85                 #   -> res_users.check_credentials()
  86             except Exception:
  87                 request.session.logout()
  88         getattr(self, "_auth_method_%s" % auth_method)()
  89         return auth_method
  90
  91     def _handle_exception(self, exception):
  92         # If handle exception return something different than None, it will be used as a response
  93         raise
  94
  95     def _dispatch(self):
  96         # locate the controller method
  97         try:
  98             func, arguments = self._find_handler()
  99         except werkzeug.exceptions.NotFound, e:
 100             return self._handle_exception(e)
 101
 102         # check authentication level
 103         try:
 104             auth_method = self._authenticate(func.routing["auth"])
 105         except Exception:
 106             # force a Forbidden exception with the original traceback
 107             return self._handle_exception(
 108                 convert_exception_to(
 109                     werkzeug.exceptions.Forbidden))
 110
 111         processing = self._postprocess_args(arguments)
 112         if processing:
 113             return processing
 114
 115
 116         # set and execute handler
 117         try:
 118             request.set_handler(func, arguments, auth_method)
 119             result = request.dispatch()
 120             if isinstance(result, Exception):
 121                 raise result
 122         except Exception, e:
 123             return self._handle_exception(e)
 124
 125         return result
 126
 127     def _postprocess_args(self, arguments):
 128         """ post process arg to set uid on browse records """
 129         for arg in arguments.itervalues():
 130             if isinstance(arg, orm.browse_record) and arg._uid is UID_PLACEHOLDER:
 131                 arg._uid = request.uid
 132                 try:
 133                     arg[arg._rec_name]
 134                 except KeyError:
 135                     return self._handle_exception(werkzeug.exceptions.NotFound())
 136
 137     def routing_map(self):
 138         if not hasattr(self, '_routing_map'):
 139             _logger.info("Generating routing map")
 140             cr = request.cr
 141             m = request.registry.get('ir.module.module')
 142             ids = m.search(cr, openerp.SUPERUSER_ID, [('state', '=', 'installed'), ('name', '!=', 'web')], context=request.context)
 143             installed = set(x['name'] for x in m.read(cr, 1, ids, ['name'], context=request.context))
 144             mods = ['', "web"] + sorted(installed)
 145             self._routing_map = http.routing_map(mods, False, converters=self._get_converters())
 146
 147         return self._routing_map
 148
 149 def convert_exception_to(to_type, with_message=False):
 150     """ Should only be called from an exception handler. Fetches the current
 151     exception data from sys.exc_info() and creates a new exception of type
 152     ``to_type`` with the original traceback.
 153
 154     If ``with_message`` is ``True``, sets the new exception's message to be
 155     the stringification of the original exception. If ``False``, does not
 156     set the new exception's message. Otherwise, uses ``with_message`` as the
 157     new exception's message.
 158
 159     :type with_message: str|bool
 160     """
 161     etype, original, tb = sys.exc_info()
 162     try:
 163         if with_message is False:
 164             message = None
 165         elif with_message is True:
 166             message = str(original)
 167         else:
 168             message = str(with_message)
 169
 170         raise to_type, message, tb
 171     except to_type, e:
 172         return e
 173
 174 # vim:et: