-# -*- encoding: utf-8 -*-
+# -*- coding: utf-8 -*-
##############################################################################
#
# OpenERP, Open Source Management Solution
-# Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>). All Rights Reserved
-# $Id$
+# Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>).
#
# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
+# it under the terms of the GNU Affero General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
+# GNU Affero General Public License for more details.
#
-# You should have received a copy of the GNU General Public License
+# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
import pooler
import copy
import sys
-
-from psycopg2 import IntegrityError
-from netsvc import Logger, LOG_ERROR
-from tools.misc import UpdateableDict
-
-from tools.translate import _
+import traceback
+import logging
+from psycopg2 import IntegrityError, errorcodes
+from tools.func import wraps
+from tools.translate import translate
module_list = []
module_class_list = {}
class_pool = {}
-
class except_osv(Exception):
def __init__(self, name, value, exc_type='warning'):
self.name = name
self.args = (exc_type, name)
-from tools.func import wraps
class osv_pool(netsvc.Service):
-
+
def check(f):
@wraps(f)
def wrapper(self, dbname, *args, **kwargs):
+ """ Wraps around OSV functions and normalises a few exceptions
+ """
+
+ def tr(src, ttype):
+ # We try to do the same as the _(), but without the frame
+ # inspection, since we aready are wrapping an osv function
+ # trans_obj = self.get('ir.translation') cannot work yet :(
+ ctx = {}
+ if not kwargs:
+ if args and isinstance(args[-1], dict):
+ ctx = args[-1]
+ else:
+ ctx = {}
+ elif isinstance(kwargs, dict):
+ ctx = kwargs.get('context', {})
+ else:
+ ctx = {}
+
+ uid = 1
+ if args and isinstance(args[0], (long, int)):
+ uid = args[0]
+
+ lang = ctx and ctx.get('lang', False)
+ if not (lang or hasattr(src, '__call__')):
+ return src
+
+ # We open a *new* cursor here, one reason is that failed SQL
+ # queries (as in IntegrityError) will invalidate the current one.
+ cr = False
+
+ if hasattr(src, '__call__'):
+ # callable. We need to find the right parameters to call
+ # the orm._sql_message(self, cr, uid, ids, context) function,
+ # or we skip..
+ # our signature is f(osv_pool, dbname [,uid, obj, method, args])
+ try:
+ if args and len(args) > 1:
+ obj = self.get(args[1])
+ if len(args) > 3 and isinstance(args[3], (long, int, list)):
+ ids = args[3]
+ else:
+ ids = []
+ cr = pooler.get_db_only(dbname).cursor()
+ return src(obj, cr, uid, ids, context=(ctx or {}))
+ except Exception, e:
+ pass
+ finally:
+ if cr: cr.close()
+
+ return False # so that the original SQL error will
+ # be returned, it is the best we have.
+
+ try:
+ cr = pooler.get_db_only(dbname).cursor()
+ #return trans_obj._get_source( name=?)
+ res = translate(cr, name=False, source_type=ttype,
+ lang=lang, source=src)
+ if res:
+ return res
+ else:
+ return src
+ finally:
+ if cr: cr.close()
+
+ def _(src):
+ return tr(src, 'code')
+
try:
if not pooler.get_pool(dbname)._ready:
raise except_osv('Database not ready', 'Currently, this database is not fully loaded and can not be used.')
return f(self, dbname, *args, **kwargs)
except orm.except_orm, inst:
+ if inst.name == 'AccessError':
+ self.logger.debug("AccessError", exc_info=True)
self.abortResponse(1, inst.name, 'warning', inst.value)
except except_osv, inst:
self.abortResponse(1, inst.name, inst.exc_type, inst.value)
except IntegrityError, inst:
for key in self._sql_error.keys():
if key in inst[0]:
- self.abortResponse(1, _('Constraint Error'), 'warning', _(self._sql_error[key]))
- self.abortResponse(1, 'Integrity Error', 'warning', inst[0])
+ self.abortResponse(1, _('Constraint Error'), 'warning',
+ tr(self._sql_error[key], 'sql_constraint') or inst[0])
+ if inst.pgcode in (errorcodes.NOT_NULL_VIOLATION, errorcodes.FOREIGN_KEY_VIOLATION, errorcodes.RESTRICT_VIOLATION):
+ msg = _('The operation cannot be completed, probably due to the following:\n- deletion: you may be trying to delete a record while other records still reference it\n- creation/update: a mandatory field is not correctly set')
+ self.logger.debug("IntegrityError", exc_info=True)
+ try:
+ errortxt = inst.pgerror.replace('«','"').replace('»','"')
+ if '"public".' in errortxt:
+ context = errortxt.split('"public".')[1]
+ model_name = table = context.split('"')[1]
+ else:
+ last_quote_end = errortxt.rfind('"')
+ last_quote_begin = errortxt.rfind('"', 0, last_quote_end)
+ model_name = table = errortxt[last_quote_begin+1:last_quote_end].strip()
+ print "MODEL", last_quote_begin, last_quote_end, model_name
+ model = table.replace("_",".")
+ model_obj = self.get(model)
+ if model_obj:
+ model_name = model_obj._description or model_obj._name
+ msg += _('\n\n[object with reference: %s - %s]') % (model_name, model)
+ except Exception:
+ pass
+ self.abortResponse(1, _('Integrity Error'), 'warning', msg)
+ else:
+ self.abortResponse(1, _('Integrity Error'), 'warning', inst[0])
except Exception, e:
- import traceback, sys
- tb_s = "".join(traceback.format_exception(*sys.exc_info()))
- logger = Logger()
- logger.notifyChannel('web-services', LOG_ERROR, tb_s)
+ self.logger.exception("Uncaught exception")
raise
return wrapper
self._store_function = {}
self._init = True
self._init_parent = {}
+ self.logger = logging.getLogger("web-services")
netsvc.Service.__init__(self, 'object_proxy', audience='')
self.exportMethod(self.obj_list)
self.exportMethod(self.exec_workflow)
for o in self._init_parent:
self.get(o)._parent_store_compute(cr)
self._init = mode
-
+
self._ready = True
return different
-
+
def execute_cr(self, cr, uid, obj, method, *args, **kw):
object = pooler.get_pool(cr.dbname).get(obj)
if not object:
raise except_osv('Object Error', 'Object %s doesn\'t exist' % str(obj))
return getattr(object, method)(cr, uid, *args, **kw)
-
+
@check
def execute(self, db, uid, obj, method, *args, **kw):
db, pool = pooler.get_db_and_pool(db)
cr = db.cursor()
try:
try:
+ if method.startswith('_'):
+ raise except_osv('Access Denied', 'Private methods (such as %s) cannot be called remotely.' % (method,))
res = pool.execute_cr(cr, uid, obj, method, *args, **kw)
+ if res is None:
+ self.logger.warning('The method %s of the object %s can not return `None` !', method, obj)
cr.commit()
except Exception:
cr.rollback()
res.append(klass.createInstance(self, module, cr))
return res
+class osv_base(object):
+ def __init__(self, pool, cr):
+ pool.add(self._name, self)
+ self.pool = pool
+ super(osv_base, self).__init__(cr)
-class osv_memory(orm.orm_memory):
- #__metaclass__ = inheritor
def __new__(cls):
module = str(cls)[6:]
module = module[:len(module)-1]
module_list.append(cls._module)
return None
+class osv_memory(osv_base, orm.orm_memory):
#
# Goal: try to apply inheritancy at the instanciation level and
# put objects in the pool var
#
def createInstance(cls, pool, module, cr):
- name = hasattr(cls, '_name') and cls._name or cls._inherit
- parent_name = hasattr(cls, '_inherit') and cls._inherit
- if parent_name:
- raise 'Inherit not supported in osv_memory object !'
+ parent_names = getattr(cls, '_inherit', None)
+ if parent_names:
+ if isinstance(parent_names, (str, unicode)):
+ name = cls._name or parent_names
+ parent_names = [parent_names]
+ else:
+ name = cls._name
+ if not name:
+ raise TypeError('_name is mandatory in case of multiple inheritance')
+
+ for parent_name in ((type(parent_names)==list) and parent_names or [parent_names]):
+ parent_class = pool.get(parent_name).__class__
+ assert pool.get(parent_name), "parent class %s does not exist in module %s !" % (parent_name, module)
+ nattr = {}
+ for s in ('_columns', '_defaults'):
+ new = copy.copy(getattr(pool.get(parent_name), s))
+ if hasattr(new, 'update'):
+ new.update(cls.__dict__.get(s, {}))
+ else:
+ new.extend(cls.__dict__.get(s, []))
+ nattr[s] = new
+ cls = type(name, (cls, parent_class), nattr)
+
obj = object.__new__(cls)
obj.__init__(pool, cr)
return obj
createInstance = classmethod(createInstance)
- def __init__(self, pool, cr):
- pool.add(self._name, self)
- self.pool = pool
- orm.orm_memory.__init__(self, cr)
-
-
-
-class osv(orm.orm):
- #__metaclass__ = inheritor
- def __new__(cls):
- module = str(cls)[6:]
- module = module[:len(module)-1]
- module = module.split('.')[0][2:]
- if not hasattr(cls, '_module'):
- cls._module = module
- module_class_list.setdefault(cls._module, []).append(cls)
- class_pool[cls._name] = cls
- if module not in module_list:
- module_list.append(cls._module)
- return None
-
+class osv(osv_base, orm.orm):
#
# Goal: try to apply inheritancy at the instanciation level and
# put objects in the pool var
#
def createInstance(cls, pool, module, cr):
- parent_name = hasattr(cls, '_inherit') and cls._inherit
- if parent_name:
- parent_class = pool.get(parent_name).__class__
- assert pool.get(parent_name), "parent class %s does not exist in module %s !" % (parent_name, module)
- nattr = {}
- for s in ('_columns', '_defaults', '_inherits', '_constraints', '_sql_constraints'):
- new = copy.copy(getattr(pool.get(parent_name), s))
- if hasattr(new, 'update'):
- new.update(cls.__dict__.get(s, {}))
- else:
- if s=='_constraints':
- for c in cls.__dict__.get(s, []):
- exist = False
- for c2 in range(len(new)):
- if new[c2][2]==c[2]:
- new[c2] = c
- exist = True
- break
- if not exist:
- new.append(c)
+ parent_names = getattr(cls, '_inherit', None)
+ if parent_names:
+ if isinstance(parent_names, (str, unicode)):
+ name = cls._name or parent_names
+ parent_names = [parent_names]
+ else:
+ name = cls._name
+ if not name:
+ raise TypeError('_name is mandatory in case of multiple inheritance')
+
+ for parent_name in ((type(parent_names)==list) and parent_names or [parent_names]):
+ parent_class = pool.get(parent_name).__class__
+ assert pool.get(parent_name), "parent class %s does not exist in module %s !" % (parent_name, module)
+ nattr = {}
+ for s in ('_columns', '_defaults', '_inherits', '_constraints', '_sql_constraints'):
+ new = copy.copy(getattr(pool.get(parent_name), s))
+ if hasattr(new, 'update'):
+ new.update(cls.__dict__.get(s, {}))
else:
- new.extend(cls.__dict__.get(s, []))
- nattr[s] = new
- name = hasattr(cls, '_name') and cls._name or cls._inherit
- cls = type(name, (cls, parent_class), nattr)
+ if s=='_constraints':
+ for c in cls.__dict__.get(s, []):
+ exist = False
+ for c2 in range(len(new)):
+ #For _constraints, we should check field and methods as well
+ if new[c2][2]==c[2] and new[c2][0]==c[0]:
+ new[c2] = c
+ exist = True
+ break
+ if not exist:
+ new.append(c)
+ else:
+ new.extend(cls.__dict__.get(s, []))
+ nattr[s] = new
+ cls = type(name, (cls, parent_class), nattr)
obj = object.__new__(cls)
obj.__init__(pool, cr)
return obj
createInstance = classmethod(createInstance)
- def __init__(self, pool, cr):
- pool.add(self._name, self)
- self.pool = pool
- orm.orm.__init__(self, cr)
-
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
projects / odoo / odoo.git / blobdiff