return False
# if the field is a classic one or a many2one, we'll fetch all classic and many2one fields
- if col._classic_write:
+ if col._prefetch:
# gen the list of "local" (ie not inherited) fields which are classic or many2one
ffields = filter(lambda x: x[1]._classic_write, self._table._columns.items())
# gen the list of inherited fields
t = eval('fields.'+(f._type))
f_type = (type_dict[t], type_dict[t])
elif isinstance(f, fields.function) and f._type == 'float':
- f_type = ('float8', 'DOUBLE PRECISION')
+ if f.digits:
+ f_type = ('numeric', 'NUMERIC(%d,%d)' % (f.digits[0], f.digits[1]))
+ else:
+ f_type = ('float8', 'DOUBLE PRECISION')
elif isinstance(f, fields.function) and f._type == 'selection':
f_type = ('text', 'text')
elif isinstance(f, fields.function) and f._type == 'char':
))
if 'module' in context:
name1 = 'field_' + self._table + '_' + k
- cr.execute("select name from ir_model_data where name='%s'"%(name1))
+ cr.execute("select name from ir_model_data where name=%s", (name1,))
if cr.fetchone():
name1 = name1 + "_" + str(id)
cr.execute("INSERT INTO ir_model_data (name,date_init,date_update,module,model,res_id) VALUES (%s, now(), now(), %s, %s, %s)", \
- (name1[:64], context['module'], 'ir.model.fields', id)
+ (name1, context['module'], 'ir.model.fields', id)
)
else:
for key, val in vals.items():
for rr in r :
if isinstance(rr.name, browse_record):
rr = rr.name
- dt+=rr.name+','
+ dt += rr.name or '' + ','
data[fpos] = dt[:-1]
break
lines += lines2[1:]
warning = ''
warning_fields = []
for field in fields_export:
- if imp_comp and len(field)>1:
+ if imp_comp and len(field)>1:
warning_fields.append('/'.join(map(lambda x:x in cols and cols[x].string or x,field)))
elif len (field) <=1:
if imp_comp and cols.get(field and field[0],False):
fields = map(lambda x: x.split('/'), fields)
logger = netsvc.Logger()
ir_model_data_obj = self.pool.get('ir.model.data')
+
+ def _check_db_id(self, model_name, db_id):
+ obj_model = self.pool.get(model_name)
+ ids = obj_model.search(cr, uid, [('id','=',int(db_id))])
+ if not len(ids):
+ raise Exception(_("Database ID doesn't exist: %s : %s") %(model_name, db_id))
+ return True
+
def process_liness(self, datas, prefix, current_module, model_name, fields_def, position=0):
line = datas[position]
row = {}
translate = {}
todo = []
- warning = ''
+ warning = []
data_id = False
data_res_id = False
is_xml_id = False
raise Exception(_('Please check that all your lines have %d columns.') % (len(fields),))
if not line[i]:
continue
- field = fields[i]
+ field = fields[i]
+ if (len(field)==len(prefix)+1) and field[len(prefix)].endswith(':db_id'):
+ # Database ID
+ res = False
+ if line[i]:
+ field_name = field[0].split(':')[0]
+ model_rel = fields_def[field_name]['relation']
+
+ if fields_def[field[len(prefix)][:-6]]['type']=='many2many':
+ res_id = []
+ for db_id in line[i].split(config.get('csv_internal_sep')):
+ try:
+ _check_db_id(self, model_rel, db_id)
+ res_id.append(db_id)
+ except Exception,e:
+ warning += [tools.exception_to_unicode(e)]
+ logger.notifyChannel("import", netsvc.LOG_ERROR,
+ tools.exception_to_unicode(e))
+ if len(res_id):
+ res = [(6, 0, res_id)]
+ else:
+ try:
+ _check_db_id(self, model_rel, line[i])
+ res = line[i]
+ except Exception,e:
+ warning += [tools.exception_to_unicode(e)]
+ logger.notifyChannel("import", netsvc.LOG_ERROR,
+ tools.exception_to_unicode(e))
+ row[field_name] = res or False
+ continue
+
if (len(field)==len(prefix)+1) and field[len(prefix)].endswith(':id'):
res_id = False
if line[i]:
ir_model_data_obj.create(cr, uid, {'module':module, 'model':model_name, 'name':name, 'res_id':is_db_id})
db_id = is_db_id
if is_db_id and int(db_id) != int(is_db_id):
- warning += ("Id is not the same than existing one: " + str(is_db_id) + " !\n")
+ warning += [_("Id is not the same than existing one: %s")%(is_db_id)]
logger.notifyChannel("import", netsvc.LOG_ERROR,
- "Id is not the same than existing one: " + str(is_db_id) + ' !\n')
+ _("Id is not the same than existing one: %s")%(is_db_id))
continue
if field[len(prefix)] == "db_id":
# Database ID
- try:
- line[i]= int(line[i])
- except Exception, e:
- warning += (str(e) + "!\n")
+ try:
+ _check_db_id(self, model_name, line[i])
+ data_res_id = is_db_id = int(line[i])
+ except Exception,e:
+ warning += [tools.exception_to_unicode(e)]
logger.notifyChannel("import", netsvc.LOG_ERROR,
- str(e) + '!\n')
+ tools.exception_to_unicode(e))
continue
- is_db_id = line[i]
- obj_model = self.pool.get(model_name)
- ids = obj_model.search(cr, uid, [('id','=',line[i])])
- if not len(ids):
- warning += ("Database ID doesn't exist: " + model_name + ": " + str(line[i]) + " !\n")
- logger.notifyChannel("import", netsvc.LOG_ERROR,
- "Database ID doesn't exist: " + model_name + ": " + str(line[i]) + ' !\n')
- continue
- else:
- data_res_id = ids[0]
data_ids = ir_model_data_obj.search(cr, uid, [('model','=',model_name),('res_id','=',line[i])])
if len(data_ids):
d = ir_model_data_obj.read(cr, uid, data_ids, ['name','module'])[0]
if is_xml_id and not data_id:
data_id = is_xml_id
if is_xml_id and is_xml_id!=data_id:
- warning += ("Id is not the same than existing one: " + str(line[i]) + " !\n")
+ warning += [_("Id is not the same than existing one: %s")%(line[i])]
logger.notifyChannel("import", netsvc.LOG_ERROR,
- "Id is not the same than existing one: " + str(line[i]) + ' !\n')
+ _("Id is not the same than existing one: %s")%(line[i]))
continue
if fields_def[field[len(prefix)]]['type'] == 'integer':
res = line[i] and int(line[i])
elif fields_def[field[len(prefix)]]['type'] == 'boolean':
- res = line[i] and eval(line[i])
+ res = line[i].lower() not in ('0', 'false', 'off')
elif fields_def[field[len(prefix)]]['type'] == 'float':
res = line[i] and float(line[i])
elif fields_def[field[len(prefix)]]['type'] == 'selection':
break
if line[i] and not res:
logger.notifyChannel("import", netsvc.LOG_WARNING,
- "key '%s' not found in selection field '%s'" % \
+ _("key '%s' not found in selection field '%s'") % \
(line[i], field[len(prefix)]))
- warning += "Key/value '"+ str(line[i]) +"' not found in selection field '"+str(field[len(prefix)])+"'"
+ warning += [_("Key/value '%s' not found in selection field '%s'")%(line[i],field[len(prefix)])]
elif fields_def[field[len(prefix)]]['type']=='many2one':
res = False
line[i], [], operator='=', context=context)
res = (res2 and res2[0][0]) or False
if not res:
- warning += ('Relation not found: ' + line[i] + \
- ' on ' + relation + ' !\n')
+ warning += [_("Relation not found: %s on '%s'")%(line[i],relation)]
logger.notifyChannel("import", netsvc.LOG_WARNING,
- 'Relation not found: ' + line[i] + \
- ' on ' + relation + ' !\n')
+ _("Relation not found: %s on '%s'")%(line[i],relation))
elif fields_def[field[len(prefix)]]['type']=='many2many':
res = []
if line[i]:
uid, word, [], operator='=', context=context)
res3 = (res2 and res2[0][0]) or False
if not res3:
- warning += ('Relation not found: ' + \
- line[i] + ' on '+relation + ' !\n')
+ warning += [_("Relation not found: %s on '%s'")%(line[i],relation)]
logger.notifyChannel("import",
netsvc.LOG_WARNING,
- 'Relation not found: ' + line[i] + \
- ' on '+relation + ' !\n')
+ _("Relation not found: %s on '%s'")%(line[i],relation))
else:
res.append(res3)
if len(res):
#try:
(res, other, warning, translate, data_id, res_id) = \
process_liness(self, datas, [], current_module, self._name, fields_def)
- if warning:
+ if len(warning):
cr.rollback()
- return (-1, res, 'Line ' + str(counter) +' : ' + warning, '')
+ return (-1, res, 'Line ' + str(counter) +' : ' + '!\n'.join(warning), '')
try:
id = ir_model_data_obj._update(cr, uid, self._name,
except Exception, e:
import psycopg2
if isinstance(e,psycopg2.IntegrityError):
- msg= 'Insertion Failed!'
+ msg= _('Insertion Failed!')
for key in self.pool._sql_error.keys():
if key in e[0]:
msg = self.pool._sql_error[key]
attrs = {'views': views}
if node.hasAttribute('widget') and node.getAttribute('widget')=='selection':
# We can not use the 'string' domain has it is defined according to the record !
- dom = None
+ dom = []
if column._domain and not isinstance(column._domain, (str, unicode)):
dom = column._domain
+
attrs['selection'] = self.pool.get(relation).name_search(cr, user, '', dom, context=context)
if (node.hasAttribute('required') and not int(node.getAttribute('required'))) or not column.required:
attrs['selection'].append((False,''))
def read_string(self, cr, uid, id, langs, fields=None, context=None):
res = {}
res2 = {}
- self.pool.get('ir.model.access').check(cr, uid, 'ir.translation', 'read')
+ self.pool.get('ir.model.access').check(cr, uid, 'ir.translation', 'read', context=context)
if not fields:
fields = self._columns.keys() + self._inherit_fields.keys()
for lang in langs:
return res
def write_string(self, cr, uid, id, langs, vals, context=None):
- self.pool.get('ir.model.access').check(cr, uid, 'ir.translation', 'write')
+ self.pool.get('ir.model.access').check(cr, uid, 'ir.translation', 'write', context=context)
for lang in langs:
for field in vals:
if field in self._columns:
self._validate(cr, user, [id_new], context)
wf_service = netsvc.LocalService("workflow")
wf_service.trg_write(user, self._name, id_new, cr)
- self.vaccum(cr, user)
return id_new
def create(self, cr, user, vals, context=None):
+ self.vaccum(cr, user)
self.next_id += 1
id_new = self.next_id
default = []
self._validate(cr, user, [id_new], context)
wf_service = netsvc.LocalService("workflow")
wf_service.trg_create(user, self._name, id_new, cr)
- self.vaccum(cr, user)
return id_new
def default_get(self, cr, uid, fields_list, context=None):
self._inherits_reload_src()
def fields_get(self, cr, user, fields=None, context=None):
- read_access = self.pool.get('ir.model.access').check(cr, user, self._name, 'write', raise_exception=False)
+ ira = self.pool.get('ir.model.access')
+ read_access = ira.check(cr, user, self._name, 'write', raise_exception=False, context=context) or \
+ ira.check(cr, user, self._name, 'create', raise_exception=False, context=context)
return super(orm, self).fields_get(cr, user, fields, context, read_access)
def read(self, cr, user, ids, fields=None, context=None, load='_classic_read'):
if not context:
context = {}
- self.pool.get('ir.model.access').check(cr, user, self._name, 'read')
+ self.pool.get('ir.model.access').check(cr, user, self._name, 'read', context=context)
if not fields:
fields = self._columns.keys() + self._inherit_fields.keys()
select = ids
if d1:
cr.execute('SELECT %s FROM \"%s\" WHERE id IN (%s) AND %s ORDER BY %s' % \
(','.join(fields_pre2 + ['id']), self._table,
- ','.join([str(x) for x in sub_ids]), d1,
- self._order), d2)
+ ','.join(['%s' for x in sub_ids]), d1,
+ self._order),sub_ids + d2)
if not cr.rowcount == len({}.fromkeys(sub_ids)):
raise except_orm(_('AccessError'),
_('You try to bypass an access rule (Document type: %s).') % self._description)
else:
cr.execute('SELECT %s FROM \"%s\" WHERE id IN (%s) ORDER BY %s' % \
(','.join(fields_pre2 + ['id']), self._table,
- ','.join([str(x) for x in sub_ids]),
- self._order))
+ ','.join(['%s' for x in sub_ids]),
+ self._order), sub_ids)
res.extend(cr.dictfetchall())
else:
res = map(lambda x: {'id': x}, ids)
self._check_concurrency(cr, ids, context)
- self.pool.get('ir.model.access').check(cr, uid, self._name, 'unlink')
+ self.pool.get('ir.model.access').check(cr, uid, self._name, 'unlink', context=context)
+
+ properties = self.pool.get('ir.property')
+ domain = [('res_id', '=', False),
+ ('value', 'in', ['%s,%s' % (self._name, i) for i in ids]),
+ ]
+ if properties.search(cr, uid, domain, context=context):
+ raise except_orm(_('Error'), _('Unable to delete this document because it is used as a default property'))
wf_service = netsvc.LocalService("workflow")
- for id in ids:
- wf_service.trg_delete(uid, self._name, id, cr)
+ for oid in ids:
+ wf_service.trg_delete(uid, self._name, oid, cr)
#cr.execute('select * from '+self._table+' where id in ('+str_d+')', ids)
#res = cr.dictfetchall()
if d1:
cr.execute('SELECT id FROM "'+self._table+'" ' \
'WHERE id IN ('+str_d+')'+d1, sub_ids+d2)
- if not cr.rowcount == len({}.fromkeys(ids)):
+ if not cr.rowcount == len(sub_ids):
raise except_orm(_('AccessError'),
_('You try to bypass an access rule (Document type: %s).') % \
self._description)
cr.execute('delete from "'+self._table+'" ' \
'where id in ('+str_d+')', sub_ids)
- for order, object, ids, fields in result_store:
+ for order, object, store_ids, fields in result_store:
if object<>self._name:
obj = self.pool.get(object)
- cr.execute('select id from '+obj._table+' where id in ('+','.join(map(str, ids))+')')
- ids = map(lambda x: x[0], cr.fetchall())
- if ids:
- obj._store_set_values(cr, uid, ids, fields, context)
+ cr.execute('select id from '+obj._table+' where id in ('+','.join(map(str, store_ids))+')')
+ rids = map(lambda x: x[0], cr.fetchall())
+ if rids:
+ obj._store_set_values(cr, uid, rids, fields, context)
return True
#
if not edit:
vals.pop(field)
+
if not context:
context = {}
if not ids:
self._check_concurrency(cr, ids, context)
- self.pool.get('ir.model.access').check(cr, user, self._name, 'write')
+ self.pool.get('ir.model.access').check(cr, user, self._name, 'write', context=context)
+
upd0 = []
upd1 = []
src_trans = self.pool.get(self._name).read(cr,user,ids,[f])
self.pool.get('ir.translation')._set_ids(cr, user, self._name+','+f, 'model', context['lang'], ids, vals[f], src_trans[0][f])
+
# call the 'set' method of fields which are not classic_write
upd_todo.sort(lambda x, y: self._columns[x].priority-self._columns[y].priority)
- # default element in context must be remove when call a one2many or many2many
+ # default element in context must be removed when call a one2many or many2many
rel_context = context.copy()
for c in context.items():
if c[0].startswith('default_'):
del rel_context[c[0]]
+ result = []
for field in upd_todo:
for id in ids:
- self._columns[field].set(cr, self, id, field, vals[field], user, context=rel_context)
+ result += self._columns[field].set(cr, self, id, field, vals[field], user, context=rel_context) or []
for table in self._inherits:
col = self._inherits[table]
cr.execute('update '+self._table+' set parent_right=parent_right+%s where parent_right>=%s', (distance, position))
cr.execute('update '+self._table+' set parent_left=parent_left-%s, parent_right=parent_right-%s where parent_left>=%s and parent_left<%s', (pleft-position+distance,pleft-position+distance, pleft+distance, pright+distance))
- result = self._store_get_values(cr, user, ids, vals.keys(), context)
+ result += self._store_get_values(cr, user, ids, vals.keys(), context)
for order, object, ids, fields in result:
self.pool.get(object)._store_set_values(cr, user, ids, fields, context)
"""
if not context:
context = {}
- self.pool.get('ir.model.access').check(cr, user, self._name, 'create')
+ self.pool.get('ir.model.access').check(cr, user, self._name, 'create', context=context)
default = []
for (t, c) in self._inherits.items():
if c in vals:
avoid_table.append(t)
- for f in self._columns.keys(): # + self._inherit_fields.keys():
- if not f in vals:
+ for f in self._columns.keys():
+ if (not f in vals) and (not isinstance(self._columns[f], fields.property)):
default.append(f)
for f in self._inherit_fields.keys():
- if (not f in vals) and (self._inherit_fields[f][0] not in avoid_table):
+ if (not f in vals) and (self._inherit_fields[f][0] not in avoid_table) and (not isinstance(self._inherit_fields[f][2], fields.property)):
default.append(f)
if len(default):
if dv in self._columns and self._columns[dv]._type == 'many2many':
if default_values[dv] and isinstance(default_values[dv][0], (int, long)):
default_values[dv] = [(6, 0, default_values[dv])]
-
vals.update(default_values)
tocreate = {}
#End
for field in vals:
- if self._columns[field]._classic_write:
- upd0 = upd0 + ',"' + field + '"'
- upd1 = upd1 + ',' + self._columns[field]._symbol_set[0]
- upd2.append(self._columns[field]._symbol_set[1](vals[field]))
- else:
- upd_todo.append(field)
+ if field in self._columns:
+ if self._columns[field]._classic_write:
+ upd0 = upd0 + ',"' + field + '"'
+ upd1 = upd1 + ',' + self._columns[field]._symbol_set[0]
+ upd2.append(self._columns[field]._symbol_set[1](vals[field]))
+ else:
+ upd_todo.append(field)
if field in self._columns \
and hasattr(self._columns[field], 'selection') \
and vals[field]:
cr.execute('update '+self._table+' set parent_right=parent_right+2 where parent_right>%s', (pleft,))
cr.execute('update '+self._table+' set parent_left=%s,parent_right=%s where id=%s', (pleft+1,pleft+2,id_new))
- # default element in context must be remove when call a one2many or many2many
+ # default element in context must be removed when call a one2many or many2many
rel_context = context.copy()
for c in context.items():
if c[0].startswith('default_'):
del rel_context[c[0]]
-
+
+ result = []
for field in upd_todo:
- self._columns[field].set(cr, self, id_new, field, vals[field], user, rel_context)
+ result += self._columns[field].set(cr, self, id_new, field, vals[field], user, rel_context) or []
self._validate(cr, user, [id_new], context)
- result = self._store_get_values(cr, user, [id_new], vals.keys(), context)
- for order, object, ids, fields in result:
- self.pool.get(object)._store_set_values(cr, user, ids, fields, context)
+ if not context.get('no_store_function', False):
+ 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))
wf_service = netsvc.LocalService("workflow")
wf_service.trg_create(user, self._name, id_new, cr)
result = {}
fncts = self.pool._store_function.get(self._name, [])
for fnct in range(len(fncts)):
+ if fncts[fnct][3]:
+ ok = False
+ for f in (fields or []):
+ if f in fncts[fnct][3]:
+ ok = True
+ break
+ if not ok:
+ continue
+
result.setdefault(fncts[fnct][0], {})
ids2 = fncts[fnct][2](self,cr, uid, ids, context)
for id in filter(None, ids2):
if 'state' in self._defaults:
default['state'] = self._defaults['state'](self, cr, uid, context)
data = self.read(cr, uid, [id], context=context)[0]
- fields = self.fields_get(cr, uid)
+ fields = self.fields_get(cr, uid, context=context)
trans_data=[]
for f in fields:
ftype = fields[f]['type']
def copy(self, cr, uid, id, default=None, context=None):
trans_obj = self.pool.get('ir.translation')
data, trans_data = self.copy_data(cr, uid, id, default, context)
- new_id=self.create(cr, uid, data)
+ new_id = self.create(cr, uid, data, context)
for record in trans_data:
del record['id']
- record['res_id']=new_id
- trans_obj.create(cr,uid,record)
+ record['res_id'] = new_id
+ trans_obj.create(cr, uid, record, context)
return new_id
def exists(self, cr, uid, id, context=None):