def _check_model(self, cr, uid, ids, context=None):
for action in self.browse(cr, uid, ids, context):
- if not self.pool.get(action.res_model):
+ if action.res_model not in self.pool:
return False
- if action.src_model and not self.pool.get(action.src_model):
+ if action.src_model and action.src_model not in self.pool:
return False
return True
}
def get_email(self, cr, uid, action, context):
- obj_pool = self.pool.get(action.model_id.model)
+ obj_pool = self.pool[action.model_id.model]
id = context.get('active_id')
obj = obj_pool.browse(cr, uid, id)
return obj
def get_mobile(self, cr, uid, action, context):
- obj_pool = self.pool.get(action.model_id.model)
+ obj_pool = self.pool[action.model_id.model]
id = context.get('active_id')
obj = obj_pool.browse(cr, uid, id)
context = {}
def merge(match):
- obj_pool = self.pool.get(action.model_id.model)
+ obj_pool = self.pool[action.model_id.model]
id = context.get('active_id')
obj = obj_pool.browse(cr, uid, id)
exp = str(match.group()[2:-2]).strip()
user = self.pool.get('res.users').browse(cr, uid, uid)
for action in self.browse(cr, uid, ids, context):
obj = None
- obj_pool = self.pool.get(action.model_id.model)
+ obj_pool = self.pool[action.model_id.model]
if context.get('active_model') == action.model_id.model and context.get('active_id'):
obj = obj_pool.browse(cr, uid, context['active_id'], context=context)
cxt = {
if action.state=='client_action':
if not action.action_id:
raise osv.except_osv(_('Error'), _("Please specify an action to launch !"))
- return self.pool.get(action.action_id.type)\
- .read(cr, uid, action.action_id.id, context=context)
+ return self.pool[action.action_id.type].read(cr, uid, action.action_id.id, context=context)
if action.state=='code':
eval(action.code, cxt, mode="exec", nocopy=True) # nocopy allows to return 'action'
if not action.write_id:
if not action.srcmodel_id:
- obj_pool = self.pool.get(action.model_id.model)
+ obj_pool = self.pool[action.model_id.model]
obj_pool.write(cr, uid, [context.get('active_id')], res)
else:
write_id = context.get('active_id')
- obj_pool = self.pool.get(action.srcmodel_id.model)
+ obj_pool = self.pool[action.srcmodel_id.model]
obj_pool.write(cr, uid, [write_id], res)
elif action.write_id:
- obj_pool = self.pool.get(action.srcmodel_id.model)
- rec = self.pool.get(action.model_id.model).browse(cr, uid, context.get('active_id'))
+ obj_pool = self.pool[action.srcmodel_id.model]
+ rec = self.pool[action.model_id.model].browse(cr, uid, context.get('active_id'))
id = eval(action.write_id, {'object': rec})
try:
id = int(id)
expr = exp.value
res[exp.col1.name] = expr
- obj_pool = self.pool.get(action.srcmodel_id.model)
+ obj_pool = self.pool[action.srcmodel_id.model]
res_id = obj_pool.create(cr, uid, res)
if action.record_id:
- self.pool.get(action.model_id.model).write(cr, uid, [context.get('active_id')], {action.record_id.name:res_id})
+ self.pool[action.model_id.model].write(cr, uid, [context.get('active_id')], {action.record_id.name:res_id})
if action.state == 'object_copy':
res = {}
model = action.copy_object.split(',')[0]
cid = action.copy_object.split(',')[1]
- obj_pool = self.pool.get(model)
+ obj_pool = self.pool[model]
obj_pool.copy(cr, uid, int(cid), res)
return False
# Load action
act_type = self.pool.get('ir.actions.actions').read(cr, uid, wizard.action_id.id, ['type'], context=context)
- res = self.pool.get(act_type['type']).read(cr, uid, wizard.action_id.id, [], context=context)
+ res = self.pool[act_type['type']].read(cr, uid, wizard.action_id.id, [], context=context)
if act_type['type'] != 'ir.actions.act_window':
return res
res.setdefault('context','{}')
model_object = attachment.res_model
res_id = attachment.res_id
if model_object and res_id:
- model_pool = self.pool.get(model_object)
+ model_pool = self.pool[model_object]
res = model_pool.name_get(cr,uid,[res_id],context)
res_name = res and res[0][1] or False
if res_name:
for model, mids in res_ids.items():
# ignore attachments that are not attached to a resource anymore when checking access rights
# (resource was deleted but attachment was not)
- mids = self.pool.get(model).exists(cr, uid, mids)
+ mids = self.pool[model].exists(cr, uid, mids)
ima.check(cr, uid, model, mode)
- self.pool.get(model).check_access_rule(cr, uid, mids, mode, context=context)
+ self.pool[model].check_access_rule(cr, uid, mids, mode, context=context)
def _search(self, cr, uid, args, offset=0, limit=None, order=None, context=None, count=False, access_rights_uid=None):
ids = super(ir_attachment, self)._search(cr, uid, args, offset=offset,
# filter ids according to what access rules permit
target_ids = targets.keys()
- allowed_ids = self.pool.get(model).search(cr, uid, [('id', 'in', target_ids)], context=context)
+ allowed_ids = self.pool[model].search(cr, uid, [('id', 'in', target_ids)], context=context)
disallowed_ids = set(target_ids).difference(allowed_ids)
for res_id in disallowed_ids:
for attach_id in targets[res_id]:
args = str2tuple(args)
openerp.modules.registry.RegistryManager.check_registry_signaling(cr.dbname)
registry = openerp.registry(cr.dbname)
- model = registry.get(model_name)
- if model and hasattr(model, method_name):
- method = getattr(model, method_name)
- log_depth = (None if _logger.isEnabledFor(logging.DEBUG) else 1)
- netsvc.log(_logger, logging.DEBUG, 'cron.object.execute', (cr.dbname,uid,'*',model_name,method_name)+tuple(args), depth=log_depth)
- if _logger.isEnabledFor(logging.DEBUG):
- start_time = time.time()
- method(cr, uid, *args)
- if _logger.isEnabledFor(logging.DEBUG):
- end_time = time.time()
- _logger.debug('%.3fs (%s, %s)' % (end_time - start_time, model_name, method_name))
- openerp.modules.registry.RegistryManager.signal_caches_change(cr.dbname)
+ if model_name in registry:
+ model = registry[model_name]
+ if hasattr(model, method_name):
+ log_depth = (None if _logger.isEnabledFor(logging.DEBUG) else 1)
+ netsvc.log(_logger, logging.DEBUG, 'cron.object.execute', (cr.dbname,uid,'*',model_name,method_name)+tuple(args), depth=log_depth)
+ if _logger.isEnabledFor(logging.DEBUG):
+ start_time = time.time()
+ getattr(model, method_name)(cr, uid, *args)
+ if _logger.isEnabledFor(logging.DEBUG):
+ end_time = time.time()
+ _logger.debug('%.3fs (%s, %s)' % (end_time - start_time, model_name, method_name))
+ openerp.modules.registry.RegistryManager.signal_caches_change(cr.dbname)
+ else:
+ msg = "Method `%s.%s` does not exist." % (model_name, method_name)
+ _logger.warning(msg)
else:
- msg = "Method `%s.%s` does not exist." % (model_name, method_name) \
- if model else "Model `%s` does not exist." % model_name
+ msg = "Model `%s` does not exist." % model_name
_logger.warning(msg)
except Exception, e:
self._handle_callback_exception(cr, uid, model_name, method_name, args, job_id, e)
models = self.browse(cr, uid, ids, context=context)
res = dict.fromkeys(ids)
for model in models:
- if self.pool.get(model.model):
+ if model.model in self.pool:
res[model.id] = self.pool[model.model].is_transient()
else:
_logger.error('Missing model %s' % (model.model, ))
if vals.get('relation',False) and not self.pool['ir.model'].search(cr, user, [('model','=',vals['relation'])]):
raise except_orm(_('Error'), _("Model %s does not exist!") % vals['relation'])
- if self.pool.get(vals['model']):
+ if vals['model'] in self.pool:
self.pool[vals['model']].__init__(self.pool, cr)
#Added context to _auto_init for special treatment to custom field for select_level
ctx = dict(context,
raise except_orm(_('Error!'), _('Renaming sparse field "%s" is not allowed')%field.name)
column_rename = None # if set, *one* column can be renamed here
- obj = None
models_patch = {} # structs of (obj, [(field, prop, change_to),..])
# data to be updated on the orm model
checked_selection = False # need only check it once, so defer
for item in self.browse(cr, user, ids, context=context):
- if not (obj and obj._name == item.model):
- obj = self.pool.get(item.model)
+ obj = self.pool.get(item.model)
if item.state != 'manual':
raise except_orm(_('Error!'),
# We don't check the 'state', because it might come from the context
# (thus be set for multiple fields) and will be ignored anyway.
- if obj:
+ if obj is not None:
models_patch.setdefault(obj._name, (obj,[]))
# find out which properties (per model) we need to update
for field_name, field_property, set_fn in model_props:
ids.reverse()
for data in self.browse(cr, uid, ids, context):
model = data.model.model
- model_obj = self.pool.get(model)
+ model_obj = self.pool[model]
name = openerp.tools.ustr(data.name)
typ = data.type
model_name = model
# TransientModel records have no access rights, only an implicit access rule
- if not self.pool.get(model_name):
+ if model_name not in self.pool:
_logger.error('Missing model %s' % (model_name, ))
elif self.pool[model_name].is_transient():
return True
def call_cache_clearing_methods(self, cr):
self.check.clear_cache(self) # clear the cache of check function
for model, method in self.__cache_clearing_methods:
- object_ = self.pool.get(model)
- if object_:
- getattr(object_, method)()
+ if model in self.pool:
+ getattr(self.pool[model], method)()
#
# Check rights on actions
return super(ir_model_data,self).unlink(cr, uid, ids, context=context)
def _update(self,cr, uid, model, module, values, xml_id=False, store=True, noupdate=False, mode='init', res_id=False, context=None):
- model_obj = self.pool.get(model)
+ model_obj = self.pool[model]
if not context:
context = {}
# records created during module install should not display the messages of OpenChatter
to_unlink.append((model,res_id))
if not config.get('import_partial'):
for (model, res_id) in to_unlink:
- if self.pool.get(model):
+ if model in self.pool:
_logger.info('Deleting %s@%s', res_id, model)
self.pool[model].unlink(cr, uid, [res_id])
return res
def _check_model_obj(self, cr, uid, ids, context=None):
- return not any(self.pool.get(rule.model_id.model).is_transient() for rule in self.browse(cr, uid, ids, context))
+ return not any(self.pool[rule.model_id.model].is_transient() for rule in self.browse(cr, uid, ids, context))
def _check_model_name(self, cr, uid, ids, context=None):
# Don't allow rules on rules records (this model).
# involve objects on which the real uid has no acces rights.
# This means also there is no implicit restriction (e.g. an object
# references another object the user can't see).
- query = self.pool.get(model_name)._where_calc(cr, SUPERUSER_ID, dom, active_test=False)
+ query = self.pool[model_name]._where_calc(cr, SUPERUSER_ID, dom, active_test=False)
return query.where_clause, query.where_clause_params, query.tables
- return [], [], ['"'+self.pool.get(model_name)._table+'"']
+ return [], [], ['"' + self.pool[model_name]._table + '"']
def unlink(self, cr, uid, ids, context=None):
res = super(ir_rule, self).unlink(cr, uid, ids, context=context)
return result
def translate_fields(self, cr, uid, model, id, field=None, context=None):
- trans_model = self.pool.get(model)
+ trans_model = self.pool[model]
domain = ['&', ('res_id', '=', id), ('name', '=like', model + ',%')]
langs_ids = self.pool.get('res.lang').search(cr, uid, [('code', '!=', 'en_US')], context=context)
if not langs_ids:
res = dict.fromkeys(ids, False)
for menu in self.browse(cr, uid, ids, context=context):
if menu.action and menu.action.type in ('ir.actions.act_window', 'ir.actions.client') and menu.action.res_model:
- obj = self.pool.get(menu.action.res_model)
- if obj and obj._needaction:
+ if menu.action.res_model in self.pool and self.pool[menu.action.res_model]._needaction:
res[menu.id] = True
return res
'needaction_counter': False,
}
if menu.action and menu.action.type in ('ir.actions.act_window', 'ir.actions.client') and menu.action.res_model:
- obj = self.pool.get(menu.action.res_model)
- if obj and obj._needaction:
- if menu.action.type == 'ir.actions.act_window':
- dom = menu.action.domain and eval(menu.action.domain, {'uid': uid}) or []
- else:
- dom = eval(menu.action.params_store or '{}', {'uid': uid}).get('domain')
- res[menu.id]['needaction_enabled'] = obj._needaction
- res[menu.id]['needaction_counter'] = obj._needaction_count(cr, uid, dom, context=context)
+ if menu.action.res_model in self.pool:
+ obj = self.pool[menu.action.res_model]
+ if obj._needaction:
+ if menu.action.type == 'ir.actions.act_window':
+ dom = menu.action.domain and eval(menu.action.domain, {'uid': uid}) or []
+ else:
+ dom = eval(menu.action.params_store or '{}', {'uid': uid}).get('domain')
+ res[menu.id]['needaction_enabled'] = obj._needaction
+ res[menu.id]['needaction_counter'] = obj._needaction_count(cr, uid, dom, context=context)
return res
_columns = {
if no error occurred, else False.
"""
try:
- fvg = self.pool.get(view.model).fields_view_get(cr, uid, view_id=view.id, view_type=view.type, context=context)
+ fvg = self.pool[view.model].fields_view_get(cr, uid, view_id=view.id, view_type=view.type, context=context)
return fvg['arch']
except:
_logger.exception("Can't render view %s for model: %s", view.xml_id, view.model)
no_ancester=[]
blank_nodes = []
- _Model_Obj=self.pool.get(model)
- _Node_Obj=self.pool.get(node_obj)
- _Arrow_Obj=self.pool.get(conn_obj)
+ _Model_Obj = self.pool[model]
+ _Node_Obj = self.pool[node_obj]
+ _Arrow_Obj = self.pool[conn_obj]
for model_key,model_value in _Model_Obj._columns.items():
if model_value._type=='one2many':
def get_sc(self, cr, uid, user_id, model='ir.ui.menu', context=None):
ids = self.search(cr, uid, [('user_id','=',user_id),('resource','=',model)], context=context)
results = self.read(cr, uid, ids, ['res_id'], context=context)
- name_map = dict(self.pool.get(model).name_get(cr, uid, [x['res_id'] for x in results], context=context))
+ name_map = dict(self.pool[model].name_get(cr, uid, [x['res_id'] for x in results], context=context))
# Make sure to return only shortcuts pointing to exisintg menu items.
filtered_results = filter(lambda result: result['res_id'] in name_map, results)
for result in filtered_results:
action_model,id = action['value'].split(',')
fields = [
field
- for field in self.pool.get(action_model)._all_columns
+ for field in self.pool[action_model]._all_columns
if field not in EXCLUDED_FIELDS]
# FIXME: needs cleanup
try:
- action_def = self.pool.get(action_model).read(cr, uid, int(id), fields, context)
+ action_def = self.pool[action_model].read(cr, uid, int(id), fields, context)
if action_def:
if action_model in ('ir.actions.report.xml','ir.actions.act_window',
'ir.actions.wizard'):
'findflds': self._fields_find,
})
def _object_doc(self, obj):
- modobj = self.pool.get(obj)
+ modobj = self.pool[obj]
strdocs= modobj.__doc__
if not strdocs:
return None
return res
def _object_doc2(self, obj):
- modobj = self.pool.get(obj)
+ modobj = self.pool[obj]
strdocs= modobj.__doc__
if not strdocs:
return None
return modobj.browse(self.cr, self.uid, ids)
def _fields_find(self, obj):
- modobj = self.pool.get(obj)
+ modobj = self.pool[obj]
res = modobj.fields_get(self.cr, self.uid).items()
res.sort()
return res
if processed_modules:
cr.execute("""select model,name from ir_model where id NOT IN (select distinct model_id from ir_model_access)""")
for (model, name) in cr.fetchall():
- model_obj = registry.get(model)
- if model_obj and not model_obj.is_transient():
+ if model in registry and not registry[model].is_transient():
_logger.warning('The model %s has no access rules, consider adding one. E.g. access_%s,access_%s,model_%s,,1,1,1,1',
model, model.replace('.', '_'), model.replace('.', '_'), model.replace('.', '_'))
# been replaced by owner-only access rights
cr.execute("""select distinct mod.model, mod.name from ir_model_access acc, ir_model mod where acc.model_id = mod.id""")
for (model, name) in cr.fetchall():
- model_obj = registry.get(model)
- if model_obj and model_obj.is_transient():
+ if model in registry and registry[model].is_transient():
_logger.warning('The transient model %s (%s) should not have explicit access rules!', model, name)
cr.execute("SELECT model from ir_model")
for (model,) in cr.fetchall():
- obj = registry.get(model)
- if obj:
- obj._check_removed_columns(cr, log=True)
+ if model in registry:
+ registry[model]._check_removed_columns(cr, log=True)
else:
_logger.warning("Model %s is declared but cannot be loaded! (Perhaps a module was partially removed or renamed)", model)
field_path = left.split('.', 1)
field = working_model._columns.get(field_path[0])
if field and field._obj:
- relational_model = working_model.pool.get(field._obj)
+ relational_model = working_model.pool[field._obj]
else:
relational_model = None
# comments about inherits'd fields
# { 'field_name': ('parent_model', 'm2o_field_to_reach_parent',
# field_column_obj, origina_parent_model), ... }
- next_model = working_model.pool.get(working_model._inherit_fields[field_path[0]][0])
+ next_model = working_model.pool[working_model._inherit_fields[field_path[0]][0]]
leaf.add_join_context(next_model, working_model._inherits[next_model._name], 'id', working_model._inherits[next_model._name])
push(leaf)
result[value['id']] = value[name]
if value[name]:
model, res_id = value[name].split(',')
- if not obj.pool.get(model).exists(cr, uid, [int(res_id)], context=context):
+ if not obj.pool[model].exists(cr, uid, [int(res_id)], context=context):
result[value['id']] = False
return result
# reference fields have a 'model,id'-like value, that we need to convert
# to a real name
model_name, res_id = value.split(',')
- model = obj.pool.get(model_name)
- if model and res_id:
+ if model_name in obj.pool and res_id:
+ model = obj.pool[model_name]
return model.name_get(cr, uid, [int(res_id)], context=context)[0][1]
return tools.ustr(value)
res[r['id']] = r[name]
for id in ids:
res.setdefault(id, '')
- obj = obj.pool.get(self._obj)
+ obj = obj.pool[self._obj]
# build a dictionary of the form {'id_of_distant_resource': name_of_distant_resource}
# we use uid=1 because the visibility of a many2one field value (just id and name)
def set(self, cr, obj_src, id, field, values, user=None, context=None):
if not context:
context = {}
- obj = obj_src.pool.get(self._obj)
- self._table = obj_src.pool.get(self._obj)._table
+ obj = obj_src.pool[self._obj]
+ self._table = obj._table
if type(values) == type([]):
for act in values:
if act[0] == 0:
cr.execute('update '+obj_src._table+' set '+field+'=null where id=%s', (id,))
def search(self, cr, obj, args, name, value, offset=0, limit=None, uid=None, context=None):
- return obj.pool.get(self._obj).search(cr, uid, args+self._domain+[('name', 'like', value)], offset, limit, context=context)
+ return obj.pool[self._obj].search(cr, uid, args+self._domain+[('name', 'like', value)], offset, limit, context=context)
@classmethod
res[id] = []
domain = self._domain(obj) if callable(self._domain) else self._domain
- ids2 = obj.pool.get(self._obj).search(cr, user, domain + [(self._fields_id, 'in', ids)], limit=self._limit, context=context)
- for r in obj.pool.get(self._obj)._read_flat(cr, user, ids2, [self._fields_id], context=context, load='_classic_write'):
+ model = obj.pool[self._obj]
+ ids2 = model.search(cr, user, domain + [(self._fields_id, 'in', ids)], limit=self._limit, context=context)
+ for r in model._read_flat(cr, user, ids2, [self._fields_id], context=context, load='_classic_write'):
if r[self._fields_id] in res:
res[r[self._fields_id]].append(r['id'])
return res
context['no_store_function'] = True
if not values:
return
- _table = obj.pool.get(self._obj)._table
- obj = obj.pool.get(self._obj)
+ obj = obj.pool[self._obj]
+ _table = obj._table
for act in values:
if act[0] == 0:
act[2][self._fields_id] = id
def search(self, cr, obj, args, name, value, offset=0, limit=None, uid=None, operator='like', context=None):
domain = self._domain(obj) if callable(self._domain) else self._domain
- return obj.pool.get(self._obj).name_search(cr, uid, value, domain, operator, context=context,limit=limit)
+ return obj.pool[self._obj].name_search(cr, uid, value, domain, operator, context=context,limit=limit)
@classmethod
tbl, col1, col2 = self._rel, self._id1, self._id2
if not all((tbl, col1, col2)):
# the default table name is based on the stable alphabetical order of tables
- dest_model = source_model.pool.get(self._obj)
+ dest_model = source_model.pool[self._obj]
tables = tuple(sorted([source_model._table, dest_model._table]))
if not tbl:
assert tables[0] != tables[1], 'Implicit/Canonical naming of m2m relationship table '\
_logger.warning(
"Specifying offset at a many2many.get() is deprecated and may"
" produce unpredictable results.")
- obj = model.pool.get(self._obj)
+ obj = model.pool[self._obj]
rel, id1, id2 = self._sql_names(model)
# static domains are lists, and are evaluated both here and on client-side, while string
if not values:
return
rel, id1, id2 = self._sql_names(model)
- obj = model.pool.get(self._obj)
+ obj = model.pool[self._obj]
for act in values:
if not (isinstance(act, list) or isinstance(act, tuple)) or not act:
continue
# TODO: use a name_search
#
def search(self, cr, obj, args, name, value, offset=0, limit=None, uid=None, operator='like', context=None):
- return obj.pool.get(self._obj).search(cr, uid, args+self._domain+[('name', operator, value)], offset, limit, context=context)
+ return obj.pool[self._obj].search(cr, uid, args+self._domain+[('name', operator, value)], offset, limit, context=context)
@classmethod
def _as_display_name(cls, field, cr, uid, obj, value, context=None):
if field_type == "many2one":
# make the result a tuple if it is not already one
if isinstance(value, (int,long)) and hasattr(obj._columns[field], 'relation'):
- obj_model = obj.pool.get(obj._columns[field].relation)
+ obj_model = obj.pool[obj._columns[field].relation]
dict_names = dict(obj_model.name_get(cr, uid, [value], context))
result = (value, dict_names[value])
# Perform name_get as root, as seeing the name of a related object depends on
# access right of source document, not target, so user may not have access.
value_ids = list(set(value.id for value in res.itervalues() if value))
- value_name = dict(obj.pool.get(self._obj).name_get(cr, SUPERUSER_ID, value_ids, context=context))
+ value_name = dict(obj.pool[self._obj].name_get(cr, SUPERUSER_ID, value_ids, context=context))
res = dict((id, value and (value.id, value_name[value.id])) for id, value in res.iteritems())
elif self._type in ('one2many', 'many2many'):
elif self._type == 'one2many':
if not read_value:
read_value = []
- relation_obj = obj.pool.get(self.relation)
+ relation_obj = obj.pool[self.relation]
for vals in value:
assert vals[0] in (0,1,2), 'Unsupported o2m value for sparse field: %s' % vals
if vals[0] == 0:
value = value or []
if value:
# filter out deleted records as superuser
- relation_obj = obj.pool.get(obj._columns[field_name].relation)
+ relation_obj = obj.pool[obj._columns[field_name].relation]
value = relation_obj.exists(cr, openerp.SUPERUSER_ID, value)
if type(value) in (int,long) and field_type == 'many2one':
- relation_obj = obj.pool.get(obj._columns[field_name].relation)
+ relation_obj = obj.pool[obj._columns[field_name].relation]
# check for deleted record as superuser
if not relation_obj.exists(cr, openerp.SUPERUSER_ID, [value]):
value = False
# not target, so user may not have access) in order to avoid
# pointing on an unexisting record.
if property_destination_obj:
- if res[id][prop_name] and obj.pool.get(property_destination_obj).exists(cr, SUPERUSER_ID, res[id][prop_name].id):
+ if res[id][prop_name] and obj.pool[property_destination_obj].exists(cr, SUPERUSER_ID, res[id][prop_name].id):
name_get_ids[id] = res[id][prop_name].id
else:
res[id][prop_name] = False
# name_get as root (as seeing the name of a related
# object depends on access right of source document,
# not target, so user may not have access.)
- name_get_values = dict(obj.pool.get(property_destination_obj).name_get(cr, SUPERUSER_ID, name_get_ids.values(), context=context))
+ name_get_values = dict(obj.pool[property_destination_obj].name_get(cr, SUPERUSER_ID, name_get_ids.values(), context=context))
# the property field is a m2o, we need to return a tuple with (id, name)
for k, v in name_get_ids.iteritems():
if res[k][prop_name]:
for field_name, field_column in fields_to_fetch:
if field_column._type == 'many2one':
if result_line[field_name]:
- obj = self._table.pool.get(field_column._obj)
+ obj = self._table.pool[field_column._obj]
if isinstance(result_line[field_name], (list, tuple)):
value = result_line[field_name][0]
else:
else:
new_data[field_name] = browse_null()
elif field_column._type in ('one2many', 'many2many') and len(result_line[field_name]):
- new_data[field_name] = self._list_class([browse_record(self._cr, self._uid, id, self._table.pool.get(field_column._obj), self._cache, context=self._context, list_class=self._list_class, fields_process=self._fields_process) for id in result_line[field_name]], self._context)
+ new_data[field_name] = self._list_class([browse_record(self._cr, self._uid, id, self._table.pool[field_column._obj], self._cache, context=self._context, list_class=self._list_class, fields_process=self._fields_process) for id in result_line[field_name]], self._context)
elif field_column._type == 'reference':
if result_line[field_name]:
if isinstance(result_line[field_name], browse_record):
ref_obj, ref_id = result_line[field_name].split(',')
ref_id = long(ref_id)
if ref_id:
- obj = self._table.pool.get(ref_obj)
+ obj = self._table.pool[ref_obj]
new_data[field_name] = browse_record(self._cr, self._uid, ref_id, obj, self._cache, context=self._context, list_class=self._list_class, fields_process=self._fields_process)
else:
new_data[field_name] = browse_null()
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_model = pool.get(parent_name)
- if not parent_model:
+ if parent_name not in pool:
raise TypeError('The model "%s" specifies an unexisting parent class "%s"\n'
'You may need to add a dependency on the parent class\' module.' % (name, parent_name))
+ parent_model = pool[parent_name]
if not getattr(cls, '_original_module', None) and name == parent_model._name:
cls._original_module = parent_model._original_module
parent_class = parent_model.__class__
return ''
def selection_field(in_field):
- col_obj = self.pool.get(in_field.keys()[0])
+ col_obj = self.pool[in_field.keys()[0]]
if f[i] in col_obj._columns.keys():
return col_obj._columns[f[i]]
elif f[i] in col_obj._inherits.keys():
if not data[fpos]:
dt = ''
for rr in r:
- name_relation = self.pool.get(rr._table_name)._rec_name
+ name_relation = self.pool[rr._table_name]._rec_name
if isinstance(rr[name_relation], browse_record):
rr = rr[name_relation]
- rr_name = self.pool.get(rr._table_name).name_get(cr, uid, [rr.id], context=context)
+ rr_name = self.pool[rr._table_name].name_get(cr, uid, [rr.id], context=context)
rr_name = rr_name and rr_name[0] and rr_name[0][1] or ''
dt += tools.ustr(rr_name or '') + ','
data[fpos] = dt[:-1]
i += 1
if i == len(f):
if isinstance(r, browse_record):
- r = self.pool.get(r._table_name).name_get(cr, uid, [r.id], context=context)
+ r = self.pool[r._table_name].name_get(cr, uid, [r.id], context=context)
r = r and r[0] and r[0][1] or ''
data[fpos] = tools.ustr(r or '')
return [data] + lines
# get the default values for the inherited fields
for t in self._inherits.keys():
- defaults.update(self.pool.get(t).default_get(cr, uid, fields_list,
- context))
+ defaults.update(self.pool[t].default_get(cr, uid, fields_list, context))
# get the default values defined in the object
for f in fields_list:
if field in fields_list:
fld_def = (field in self._columns) and self._columns[field] or self._inherit_fields[field][2]
if fld_def._type == 'many2one':
- obj = self.pool.get(fld_def._obj)
+ obj = self.pool[fld_def._obj]
if not obj.search(cr, uid, [('id', '=', field_value or False)]):
continue
if fld_def._type == 'many2many':
- obj = self.pool.get(fld_def._obj)
+ obj = self.pool[fld_def._obj]
field_value2 = []
for i in range(len(field_value or [])):
if not obj.search(cr, uid, [('id', '=',
field_value2.append(field_value[i])
field_value = field_value2
if fld_def._type == 'one2many':
- obj = self.pool.get(fld_def._obj)
+ obj = self.pool[fld_def._obj]
field_value2 = []
for i in range(len(field_value or [])):
field_value2.append({})
for field2 in field_value[i]:
if field2 in obj._columns.keys() and obj._columns[field2]._type == 'many2one':
- obj2 = self.pool.get(obj._columns[field2]._obj)
+ obj2 = self.pool[obj._columns[field2]._obj]
if not obj2.search(cr, uid,
[('id', '=', field_value[i][field2])]):
continue
elif field2 in obj._inherit_fields.keys() and obj._inherit_fields[field2][2]._type == 'many2one':
- obj2 = self.pool.get(obj._inherit_fields[field2][2]._obj)
+ obj2 = self.pool[obj._inherit_fields[field2][2]._obj]
if not obj2.search(cr, uid,
[('id', '=', field_value[i][field2])]):
continue
# TODO I believe this loop can be replace by
# res.extend(self._inherit_fields.key())
for parent in self._inherits:
- res.extend(self.pool.get(parent).fields_get_keys(cr, user, context))
+ res.extend(self.pool[parent].fields_get_keys(cr, user, context))
return res
def _rec_name_fallback(self, cr, uid, context=None):
new_xml = etree.fromstring(encode(xml))
ctx = context.copy()
ctx['base_model_name'] = self._name
- xarch, xfields = self.pool.get(node.get('object')).__view_look_dom_arch(cr, user, new_xml, view_id, ctx)
+ xarch, xfields = self.pool[node.get('object')].__view_look_dom_arch(cr, user, new_xml, view_id, ctx)
views['form'] = {
'arch': xarch,
'fields': xfields
column = False
if column:
- relation = self.pool.get(column._obj)
+ relation = self.pool[column._obj] if column._obj else None
children = False
views = {}
fields = {}
if node.tag == 'diagram':
if node.getchildren()[0].tag == 'node':
- node_model = self.pool.get(node.getchildren()[0].get('object'))
+ node_model = self.pool[node.getchildren()[0].get('object')]
node_fields = node_model.fields_get(cr, user, None, context)
fields.update(node_fields)
if not node.get("create") and not node_model.check_access_rights(cr, user, 'create', raise_exception=False):
node.set("create", 'false')
if node.getchildren()[1].tag == 'arrow':
- arrow_fields = self.pool.get(node.getchildren()[1].get('object')).fields_get(cr, user, None, context)
+ arrow_fields = self.pool[node.getchildren()[1].get('object')].fields_get(cr, user, None, context)
fields.update(arrow_fields)
else:
fields = self.fields_get(cr, user, None, context)
res[lang][f] = self._columns[f].string
for table in self._inherits:
cols = intersect(self._inherit_fields.keys(), fields)
- res2 = self.pool.get(table).read_string(cr, uid, id, langs, cols, context)
+ res2 = self.pool[table].read_string(cr, uid, id, langs, cols, context)
for lang in res2:
if lang in res:
res[lang]['code'] = lang
for table in self._inherits:
cols = intersect(self._inherit_fields.keys(), vals)
if cols:
- self.pool.get(table).write_string(cr, uid, id, langs, vals, context)
+ self.pool[table].write_string(cr, uid, id, langs, vals, context)
return True
def _add_missing_default_values(self, cr, uid, values, context=None):
:param query: query object on which the JOIN should be added
"""
inherits_field = current_model._inherits[parent_model_name]
- parent_model = self.pool.get(parent_model_name)
+ parent_model = self.pool[parent_model_name]
parent_alias, parent_alias_statement = query.add_join((current_model._table, parent_model._table, inherits_field, 'id', inherits_field), implicit=True)
return parent_alias
parent_alias = '"%s"' % current_table._table
while field in current_table._inherit_fields and not field in current_table._columns:
parent_model_name = current_table._inherit_fields[field][0]
- parent_table = self.pool.get(parent_model_name)
+ parent_table = self.pool[parent_model_name]
parent_alias = self._inherits_join_add(current_table, parent_model_name, query)
current_table = parent_table
return '%s."%s"' % (parent_alias, field)
_schema.debug(msg, self._table, k, f._type)
if isinstance(f, fields.many2one):
- dest_model = self.pool.get(f._obj)
+ dest_model = self.pool[f._obj]
if dest_model._table != 'ir_actions':
self._m2o_fix_foreign_key(cr, self._table, k, dest_model, f.ondelete)
# and add constraints if needed
if isinstance(f, fields.many2one):
- if not self.pool.get(f._obj):
+ if f._obj not in self.pool:
raise except_orm('Programming Error', 'There is no reference available for %s' % (f._obj,))
- dest_model = self.pool.get(f._obj)
+ dest_model = self.pool[f._obj]
ref = dest_model._table
# ir_actions is inherited so foreign key doesn't work on it
if ref != 'ir_actions':
def _o2m_raise_on_missing_reference(self, cr, f):
# TODO this check should be a method on fields.one2many.
-
- other = self.pool.get(f._obj)
- if other:
+ if f._obj in self.pool:
+ other = self.pool[f._obj]
# TODO the condition could use fields_get_keys().
if f._fields_id not in other._columns.keys():
if f._fields_id not in other._inherit_fields.keys():
self._save_relation_table(cr, m2m_tbl)
cr.execute("SELECT relname FROM pg_class WHERE relkind IN ('r','v') AND relname=%s", (m2m_tbl,))
if not cr.dictfetchall():
- if not self.pool.get(f._obj):
+ if f._obj not in self.pool:
raise except_orm('Programming Error', 'Many2Many destination model does not exist: `%s`' % (f._obj,))
- dest_model = self.pool.get(f._obj)
+ dest_model = self.pool[f._obj]
ref = dest_model._table
cr.execute('CREATE TABLE "%s" ("%s" INTEGER NOT NULL, "%s" INTEGER NOT NULL, UNIQUE("%s","%s"))' % (m2m_tbl, col1, col2, col1, col2))
# create foreign key references with ondelete=cascade, unless the targets are SQL views
"""
res = {}
for table in self._inherits:
- other = self.pool.get(table)
+ other = self.pool[table]
for col in other._columns.keys():
res[col] = (table, self._inherits[table], other._columns[col], table)
for col in other._inherit_fields.keys():
translation_obj = self.pool.get('ir.translation')
for parent in self._inherits:
- res.update(self.pool.get(parent).fields_get(cr, user, allfields, context))
+ res.update(self.pool[parent].fields_get(cr, user, allfields, context))
for f, field in self._columns.iteritems():
if (allfields and f not in allfields) or \
cols = [x for x in intersect(self._inherit_fields.keys(), fields_to_read) if x not in self._columns.keys()]
if not cols:
continue
- res2 = self.pool.get(table).read(cr, user, [x[col] for x in res], cols, context, load)
+ res2 = self.pool[table].read(cr, user, [x[col] for x in res], cols, context, load)
res3 = {}
for r in res2:
if ir_value_ids:
ir_values_obj.unlink(cr, uid, ir_value_ids, context=context)
- for order, object, store_ids, fields in result_store:
- if object != self._name:
- obj = self.pool.get(object)
+ for order, obj_name, store_ids, fields in result_store:
+ if obj_name != self._name:
+ obj = self.pool[obj_name]
cr.execute('select id from '+obj._table+' where id IN %s', (tuple(store_ids),))
rids = map(lambda x: x[0], cr.fetchall())
if rids:
# TODO: optimize
for f in direct:
if self._columns[f].translate:
- src_trans = self.pool.get(self._name).read(cr, user, ids, [f])[0][f]
+ src_trans = self.pool[self._name].read(cr, user, ids, [f])[0][f]
if not src_trans:
src_trans = vals[f]
# Inserting value to DB
v[val] = vals[val]
unknown_fields.remove(val)
if v:
- self.pool.get(table).write(cr, user, nids, v, context)
+ self.pool[table].write(cr, user, nids, v, context)
if unknown_fields:
_logger.warning(
result.sort()
done = {}
- for order, object, ids_to_update, fields_to_recompute in result:
- key = (object, tuple(fields_to_recompute))
+ for order, model_name, ids_to_update, fields_to_recompute in result:
+ key = (model_name, tuple(fields_to_recompute))
done.setdefault(key, {})
# avoid to do several times the same computation
todo = []
if id not in done[key]:
done[key][id] = True
todo.append(id)
- self.pool.get(object)._store_set_values(cr, user, todo, fields_to_recompute, context)
+ self.pool[model_name]._store_set_values(cr, user, todo, fields_to_recompute, context)
self.step_workflow(cr, user, ids, context=context)
return True
parent_context.pop('no_store_function', None)
if record_id is None or not record_id:
- record_id = self.pool.get(table).create(cr, user, tocreate[table], context=parent_context)
+ record_id = self.pool[table].create(cr, user, tocreate[table], context=parent_context)
else:
- self.pool.get(table).write(cr, user, [record_id], tocreate[table], context=parent_context)
+ self.pool[table].write(cr, user, [record_id], tocreate[table], context=parent_context)
upd0 += ',' + self._inherits[table]
upd1 += ',%s'
result += self._store_get_values(cr, user, [id_new], vals.keys(), context)
result.sort()
done = []
- for order, object, ids, fields2 in result:
- if not (object, ids, fields2) in done:
- self.pool.get(object)._store_set_values(cr, user, ids, fields2, context)
- done.append((object, ids, fields2))
+ for order, model_name, ids, fields2 in result:
+ if not (model_name, ids, fields2) in done:
+ self.pool[model_name]._store_set_values(cr, user, ids, fields2, context)
+ done.append((model_name, ids, fields2))
if self._log_create and not (context and context.get('no_store_function', False)):
message = self._description + \
# to reach the parent table (if it was not JOINed yet in the query)
parent_alias = child_object._inherits_join_add(child_object, parent_model, query)
# inherited rules are applied on the external table -> need to get the alias and replace
- parent_table = self.pool.get(parent_model)._table
+ parent_table = self.pool[parent_model]._table
added_clause = [clause.replace('"%s"' % parent_table, '"%s"' % parent_alias) for clause in added_clause]
# change references to parent_table to parent_alias, because we now use the alias to refer to the table
new_tables = []
return
# figure out the applicable order_by for the m2o
- dest_model = self.pool.get(order_field_column._obj)
+ dest_model = self.pool[order_field_column._obj]
m2o_order = dest_model._order
if not regex_order.match(m2o_order):
# _order is complex, can't use it here, so we default to _rec_name
else:
continue # ignore non-readable or "non-joinable" fields
elif order_field in self._inherit_fields:
- parent_obj = self.pool.get(self._inherit_fields[order_field][3])
+ parent_obj = self.pool[self._inherit_fields[order_field][3]]
order_column = parent_obj._columns[order_field]
if order_column._classic_read:
inner_clause = self._inherits_join_calc(order_field, query)
if not args:
args = []
if field in self._inherit_fields:
- return self.pool.get(self._inherit_fields[field][0]).distinct_field_get(cr, uid, field, value, args, offset, limit)
+ return self.pool[self._inherit_fields[field][0]].distinct_field_get(cr, uid, field, value, args, offset, limit)
else:
return self._columns[field].search(cr, self, args, field, value, offset, limit, uid)
if field_to_other in default:
# all the fields of 'other' are given by the record: default[field_to_other],
# except the ones redefined in self
- blacklist.update(set(self.pool.get(other)._all_columns) - set(self._columns))
+ blacklist.update(set(self.pool[other]._all_columns) - set(self._columns))
else:
- blacklist_given_fields(self.pool.get(other))
+ blacklist_given_fields(self.pool[other])
blacklist_given_fields(self)
res = dict(default)
elif field._type == 'many2one':
res[f] = data[f] and data[f][0]
elif field._type == 'one2many':
- other = self.pool.get(field._obj)
+ other = self.pool[field._obj]
# duplicate following the order of the ids because we'll rely on
# it later for copying translations in copy_translation()!
lines = [other.copy_data(cr, uid, line_id, context=context) for line_id in sorted(data[f])]
for field_name, field_def in fields.items():
# we must recursively copy the translations for o2o and o2m
if field_def['type'] == 'one2many':
- target_obj = self.pool.get(field_def['relation'])
+ target_obj = self.pool[field_def['relation']]
old_record, new_record = self.read(cr, uid, [old_id, new_id], [field_name], context=context)
# here we rely on the order of the ids to match the translations
# as foreseen in copy_data()
result, record_ids = [], list(command[2])
# read the records and apply the updates
- other_model = self.pool.get(self._all_columns[field_name].column._obj)
+ other_model = self.pool[self._all_columns[field_name].column._obj]
for record in other_model.read(cr, uid, record_ids, fields=fields, context=context):
record.update(updates.get(record['id'], {}))
result.append(record)
args = []
# get the object
if 'model' in attrs:
- obj = self.pool.get(attrs['model'])
+ obj = self.pool[attrs['model']]
else:
if isinstance(browser, list):
obj = browser[0]._table
last_quote_begin = errortxt.rfind('"', 0, last_quote_end)
model_name = table = errortxt[last_quote_begin+1:last_quote_end].strip()
model = table.replace("_",".")
- model_obj = registry.get(model)
- if model_obj:
+ if model in registry:
+ model_obj = registry[model]
model_name = model_obj._description or model_obj._name
msg += _('\n\n[object with reference: %s - %s]') % (model_name, model)
except Exception:
def cursor():
return openerp.modules.registry.RegistryManager.get(DB).db.cursor()
-def get_module(module_name):
+def model_exists(model_name):
registry = openerp.modules.registry.RegistryManager.get(DB)
- return registry.get(module_name)
+ return model_name in registry
def reload_registry():
openerp.modules.registry.RegistryManager.new(
def test_01_install(self):
""" Check a few things showing the module is installed. """
install_module('test_uninstall')
- assert get_module('test_uninstall.model')
+ assert model_exists('test_uninstall.model')
assert search_registry('ir.model.data',
[('module', '=', 'test_uninstall')])
def test_02_uninstall(self):
""" Check a few things showing the module is uninstalled. """
uninstall_module('test_uninstall')
- assert not get_module('test_uninstall.model')
+ assert not model_exists('test_uninstall.model')
assert not search_registry('ir.model.data',
[('module', '=', 'test_uninstall')])
model = encode(model)
xml_name = "%s.%s" % (module, encode(xml_name))
- if not registry.get(model):
+ if model not in registry:
_logger.error("Unable to find object %r", model)
continue
push_constraint_msg(module, term_type, model._name, constraint[msg_pos])
for (_, model, module) in cr.fetchall():
- model_obj = registry.get(model)
-
- if not model_obj:
+ if model not in registry:
_logger.error("Unable to find object %r", model)
continue
+ model_obj = registry[model]
+
if model_obj._constraints:
push_local_constraints(module, model_obj, 'constraints')
def process_delete(self, node):
assert getattr(node, 'model'), "Attribute %s of delete tag is empty !" % ('model',)
- if self.pool.get(node.model):
+ if node.model in self.pool:
if node.search:
ids = self.pool[node.model].search(self.cr, self.uid, eval(node.search, self.eval_context))
else:
openerp.netsvc.init_logger()
registry = openerp.modules.registry.RegistryManager.get(
args.database, update_module=False)
- model = registry.get(args.model)
+ model = registry[args.model]
longest_k = 1
longest_string = 1
columns = model._columns
openerp.netsvc.init_logger()
registry = openerp.modules.registry.RegistryManager.get(
args.database, update_module=False)
- model = registry.get(args.model)
+ model = registry[args.model]
cr = registry.db.cursor() # TODO context manager
field_names = [args.field] if args.field else []
if args.short:
projects / odoo / odoo.git / commitdiff