bin/osv/orm.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>).
   6 #
   7 #    This program is free software: you can redistribute it and/or modify
   8 #    it under the terms of the GNU Affero General Public License as
   9 #    published by the Free Software Foundation, either version 3 of the
  10 #    License, or (at your option) any later version.
  11 #
  12 #    This program is distributed in the hope that it will be useful,
  13 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 #    GNU Affero General Public License for more details.
  16 #
  17 #    You should have received a copy of the GNU Affero General Public License
  18 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20 ##############################################################################
  21
  22 #
  23 # Object relationnal mapping to postgresql module
  24 #    . Hierarchical structure
  25 #    . Constraints consistency, validations
  26 #    . Object meta Data depends on its status
  27 #    . Optimised processing by complex query (multiple actions at once)
  28 #    . Default fields value
  29 #    . Permissions optimisation
  30 #    . Persistant object: DB postgresql
  31 #    . Datas conversions
  32 #    . Multi-level caching system
  33 #    . 2 different inheritancies
  34 #    . Fields:
  35 #         - classicals (varchar, integer, boolean, ...)
  36 #         - relations (one2many, many2one, many2many)
  37 #         - functions
  38 #
  39 #
  40 import calendar
  41 import copy
  42 import datetime
  43 import logging
  44 import operator
  45 import pickle
  46 import re
  47 import time
  48 import traceback
  49 import types
  50
  51 import netsvc
  52 from lxml import etree
  53 from tools.config import config
  54 from tools.translate import _
  55
  56 import fields
  57 from query import Query
  58 import tools
  59 from tools.safe_eval import safe_eval as eval
  60
  61 regex_order = re.compile('^(([a-z0-9_]+|"[a-z0-9_]+")( *desc| *asc)?( *, *|))+$', re.I)
  62
  63
  64 POSTGRES_CONFDELTYPES = {
  65     'RESTRICT': 'r',
  66     'NO ACTION': 'a',
  67     'CASCADE': 'c',
  68     'SET NULL': 'n',
  69     'SET DEFAULT': 'd',
  70 }
  71
  72 def last_day_of_current_month():
  73     today = datetime.date.today()
  74     last_day = str(calendar.monthrange(today.year, today.month)[1])
  75     return time.strftime('%Y-%m-' + last_day)
  76
  77 def intersect(la, lb):
  78     return filter(lambda x: x in lb, la)
  79
  80 class except_orm(Exception):
  81     def __init__(self, name, value):
  82         self.name = name
  83         self.value = value
  84         self.args = (name, value)
  85
  86 class BrowseRecordError(Exception):
  87     pass
  88
  89 # Readonly python database object browser
  90 class browse_null(object):
  91
  92     def __init__(self):
  93         self.id = False
  94
  95     def __getitem__(self, name):
  96         return None
  97
  98     def __getattr__(self, name):
  99         return None  # XXX: return self ?
 100
 101     def __int__(self):
 102         return False
 103
 104     def __str__(self):
 105         return ''
 106
 107     def __nonzero__(self):
 108         return False
 109
 110     def __unicode__(self):
 111         return u''
 112
 113
 114 #
 115 # TODO: execute an object method on browse_record_list
 116 #
 117 class browse_record_list(list):
 118
 119     def __init__(self, lst, context=None):
 120         if not context:
 121             context = {}
 122         super(browse_record_list, self).__init__(lst)
 123         self.context = context
 124
 125
 126 class browse_record(object):
 127     logger = netsvc.Logger()
 128
 129     def __init__(self, cr, uid, id, table, cache, context=None, list_class = None, fields_process={}):
 130         '''
 131         table : the object (inherited from orm)
 132         context : dictionary with an optional context
 133         '''
 134         if not context:
 135             context = {}
 136         self._list_class = list_class or browse_record_list
 137         self._cr = cr
 138         self._uid = uid
 139         self._id = id
 140         self._table = table
 141         self._table_name = self._table._name
 142         self.__logger = logging.getLogger(
 143             'osv.browse_record.' + self._table_name)
 144         self._context = context
 145         self._fields_process = fields_process
 146
 147         cache.setdefault(table._name, {})
 148         self._data = cache[table._name]
 149
 150         if not (id and isinstance(id, (int, long,))):
 151             raise BrowseRecordError(_('Wrong ID for the browse record, got %r, expected an integer.') % (id,))
 152 #        if not table.exists(cr, uid, id, context):
 153 #            raise BrowseRecordError(_('Object %s does not exists') % (self,))
 154
 155         if id not in self._data:
 156             self._data[id] = {'id': id}
 157
 158         self._cache = cache
 159
 160     def __getitem__(self, name):
 161         if name == 'id':
 162             return self._id
 163
 164         if name not in self._data[self._id]:
 165             # build the list of fields we will fetch
 166
 167             # fetch the definition of the field which was asked for
 168             if name in self._table._columns:
 169                 col = self._table._columns[name]
 170             elif name in self._table._inherit_fields:
 171                 col = self._table._inherit_fields[name][2]
 172             elif hasattr(self._table, str(name)):
 173                 attr = getattr(self._table, name)
 174
 175                 if isinstance(attr, (types.MethodType, types.LambdaType, types.FunctionType)):
 176                     return lambda *args, **argv: attr(self._cr, self._uid, [self._id], *args, **argv)
 177                 else:
 178                     return attr
 179             else:
 180                 self.logger.notifyChannel("browse_record", netsvc.LOG_WARNING,
 181                     "Field '%s' does not exist in object '%s': \n%s" % (
 182                         name, self, ''.join(traceback.format_exc())))
 183                 raise KeyError("Field '%s' does not exist in object '%s'" % (
 184                     name, self))
 185
 186             # if the field is a classic one or a many2one, we'll fetch all classic and many2one fields
 187             if col._prefetch:
 188                 # gen the list of "local" (ie not inherited) fields which are classic or many2one
 189                 fields_to_fetch = filter(lambda x: x[1]._classic_write, self._table._columns.items())
 190                 # gen the list of inherited fields
 191                 inherits = map(lambda x: (x[0], x[1][2]), self._table._inherit_fields.items())
 192                 # complete the field list with the inherited fields which are classic or many2one
 193                 fields_to_fetch += filter(lambda x: x[1]._classic_write, inherits)
 194             # otherwise we fetch only that field
 195             else:
 196                 fields_to_fetch = [(name, col)]
 197             ids = filter(lambda id: name not in self._data[id], self._data.keys())
 198             # read the results
 199             field_names = map(lambda x: x[0], fields_to_fetch)
 200             field_values = self._table.read(self._cr, self._uid, ids, field_names, context=self._context, load="_classic_write")
 201             if self._fields_process:
 202                 lang = self._context.get('lang', 'en_US') or 'en_US'
 203                 lang_obj_ids = self.pool.get('res.lang').search(self._cr, self._uid, [('code', '=', lang)])
 204                 if not lang_obj_ids:
 205                     raise Exception(_('Language with code "%s" is not defined in your system !\nDefine it through the Administration menu.') % (lang,))
 206                 lang_obj = self.pool.get('res.lang').browse(self._cr, self._uid, lang_obj_ids[0])
 207
 208                 for field_name, field_column in fields_to_fetch:
 209                     if field_column._type in self._fields_process:
 210                         for result_line in field_values:
 211                             result_line[field_name] = self._fields_process[field_column._type](result_line[field_name])
 212                             if result_line[field_name]:
 213                                 result_line[field_name].set_value(self._cr, self._uid, result_line[field_name], self, field_column, lang_obj)
 214
 215             if not field_values:
 216                 # Where did those ids come from? Perhaps old entries in ir_model_dat?
 217                 self.__logger.warn("No field_values found for ids %s in %s", ids, self)
 218                 raise KeyError('Field %s not found in %s'%(name, self))
 219             # create browse records for 'remote' objects
 220             for result_line in field_values:
 221                 new_data = {}
 222                 for field_name, field_column in fields_to_fetch:
 223                     if field_column._type in ('many2one', 'one2one'):
 224                         if result_line[field_name]:
 225                             obj = self._table.pool.get(field_column._obj)
 226                             if isinstance(result_line[field_name], (list, tuple)):
 227                                 value = result_line[field_name][0]
 228                             else:
 229                                 value = result_line[field_name]
 230                             if value:
 231                                 # FIXME: this happen when a _inherits object
 232                                 #        overwrite a field of it parent. Need
 233                                 #        testing to be sure we got the right
 234                                 #        object and not the parent one.
 235                                 if not isinstance(value, browse_record):
 236                                     new_data[field_name] = browse_record(self._cr,
 237                                         self._uid, value, obj, self._cache,
 238                                         context=self._context,
 239                                         list_class=self._list_class,
 240                                         fields_process=self._fields_process)
 241                                 else:
 242                                     new_data[field_name] = value
 243                             else:
 244                                 new_data[field_name] = browse_null()
 245                         else:
 246                             new_data[field_name] = browse_null()
 247                     elif field_column._type in ('one2many', 'many2many') and len(result_line[field_name]):
 248                         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)
 249                     elif field_column._type in ('reference'):
 250                         if result_line[field_name]:
 251                             if isinstance(result_line[field_name], browse_record):
 252                                 new_data[field_name] = result_line[field_name]
 253                             else:
 254                                 ref_obj, ref_id = result_line[field_name].split(',')
 255                                 ref_id = long(ref_id)
 256                                 obj = self._table.pool.get(ref_obj)
 257                                 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)
 258                         else:
 259                             new_data[field_name] = browse_null()
 260                     else:
 261                         new_data[field_name] = result_line[field_name]
 262                 self._data[result_line['id']].update(new_data)
 263
 264         if not name in self._data[self._id]:
 265             #how did this happen?
 266             self.logger.notifyChannel("browse_record", netsvc.LOG_ERROR,
 267                     "Fields to fetch: %s, Field values: %s"%(field_names, field_values))
 268             self.logger.notifyChannel("browse_record", netsvc.LOG_ERROR,
 269                     "Cached: %s, Table: %s"%(self._data[self._id], self._table))
 270             raise KeyError(_('Unknown attribute %s in %s ') % (name, self))
 271         return self._data[self._id][name]
 272
 273     def __getattr__(self, name):
 274         try:
 275             return self[name]
 276         except KeyError, e:
 277             raise AttributeError(e)
 278
 279     def __contains__(self, name):
 280         return (name in self._table._columns) or (name in self._table._inherit_fields) or hasattr(self._table, name)
 281
 282     def __hasattr__(self, name):
 283         return name in self
 284
 285     def __int__(self):
 286         return self._id
 287
 288     def __str__(self):
 289         return "browse_record(%s, %d)" % (self._table_name, self._id)
 290
 291     def __eq__(self, other):
 292         if not isinstance(other, browse_record):
 293             return False
 294         return (self._table_name, self._id) == (other._table_name, other._id)
 295
 296     def __ne__(self, other):
 297         if not isinstance(other, browse_record):
 298             return True
 299         return (self._table_name, self._id) != (other._table_name, other._id)
 300
 301     # we need to define __unicode__ even though we've already defined __str__
 302     # because we have overridden __getattr__
 303     def __unicode__(self):
 304         return unicode(str(self))
 305
 306     def __hash__(self):
 307         return hash((self._table_name, self._id))
 308
 309     __repr__ = __str__
 310
 311
 312 def get_pg_type(f):
 313     '''
 314     returns a tuple
 315     (type returned by postgres when the column was created, type expression to create the column)
 316     '''
 317
 318     type_dict = {
 319             fields.boolean: 'bool',
 320             fields.integer: 'int4',
 321             fields.integer_big: 'int8',
 322             fields.text: 'text',
 323             fields.date: 'date',
 324             fields.time: 'time',
 325             fields.datetime: 'timestamp',
 326             fields.binary: 'bytea',
 327             fields.many2one: 'int4',
 328             }
 329     if type(f) in type_dict:
 330         f_type = (type_dict[type(f)], type_dict[type(f)])
 331     elif isinstance(f, fields.float):
 332         if f.digits:
 333             f_type = ('numeric', 'NUMERIC')
 334         else:
 335             f_type = ('float8', 'DOUBLE PRECISION')
 336     elif isinstance(f, (fields.char, fields.reference)):
 337         f_type = ('varchar', 'VARCHAR(%d)' % (f.size,))
 338     elif isinstance(f, fields.selection):
 339         if isinstance(f.selection, list) and isinstance(f.selection[0][0], (str, unicode)):
 340             f_size = reduce(lambda x, y: max(x, len(y[0])), f.selection, f.size or 16)
 341         elif isinstance(f.selection, list) and isinstance(f.selection[0][0], int):
 342             f_size = -1
 343         else:
 344             f_size = getattr(f, 'size', None) or 16
 345
 346         if f_size == -1:
 347             f_type = ('int4', 'INTEGER')
 348         else:
 349             f_type = ('varchar', 'VARCHAR(%d)' % f_size)
 350     elif isinstance(f, fields.function) and eval('fields.'+(f._type), globals()) in type_dict:
 351         t = eval('fields.'+(f._type), globals())
 352         f_type = (type_dict[t], type_dict[t])
 353     elif isinstance(f, fields.function) and f._type == 'float':
 354         if f.digits:
 355             f_type = ('numeric', 'NUMERIC')
 356         else:
 357             f_type = ('float8', 'DOUBLE PRECISION')
 358     elif isinstance(f, fields.function) and f._type == 'selection':
 359         f_type = ('text', 'text')
 360     elif isinstance(f, fields.function) and f._type == 'char':
 361         f_type = ('varchar', 'VARCHAR(%d)' % (f.size))
 362     else:
 363         logger = netsvc.Logger()
 364         logger.notifyChannel("init", netsvc.LOG_WARNING, '%s type not supported!' % (type(f)))
 365         f_type = None
 366     return f_type
 367
 368
 369 class orm_template(object):
 370     _name = None
 371     _columns = {}
 372     _constraints = []
 373     _defaults = {}
 374     _rec_name = 'name'
 375     _parent_name = 'parent_id'
 376     _parent_store = False
 377     _parent_order = False
 378     _date_name = 'date'
 379     _order = 'id'
 380     _sequence = None
 381     _description = None
 382     _inherits = {}
 383     _table = None
 384     _invalids = set()
 385     _log_create = False
 386
 387     CONCURRENCY_CHECK_FIELD = '__last_update'
 388     def log(self, cr, uid, id, message, secondary=False, context=None):
 389         return self.pool.get('res.log').create(cr, uid,
 390                 {
 391                     'name': message,
 392                     'res_model': self._name,
 393                     'secondary': secondary,
 394                     'res_id': id,
 395                     'context': context,
 396                 },
 397                 context=context
 398         )
 399
 400     def view_init(self, cr, uid, fields_list, context=None):
 401         """Override this method to do specific things when a view on the object is opened."""
 402         pass
 403
 404     def read_group(self, cr, uid, domain, fields, groupby, offset=0, limit=None, context=None):
 405         raise NotImplementedError(_('The read_group method is not implemented on this object !'))
 406
 407     def _field_create(self, cr, context={}):
 408         cr.execute("SELECT id FROM ir_model WHERE model=%s", (self._name,))
 409         if not cr.rowcount:
 410             cr.execute('SELECT nextval(%s)', ('ir_model_id_seq',))
 411             model_id = cr.fetchone()[0]
 412             cr.execute("INSERT INTO ir_model (id,model, name, info,state) VALUES (%s, %s, %s, %s, %s)", (model_id, self._name, self._description, self.__doc__, 'base'))
 413         else:
 414             model_id = cr.fetchone()[0]
 415         if 'module' in context:
 416             name_id = 'model_'+self._name.replace('.', '_')
 417             cr.execute('select * from ir_model_data where name=%s and res_id=%s and module=%s', (name_id, model_id, context['module']))
 418             if not cr.rowcount:
 419                 cr.execute("INSERT INTO ir_model_data (name,date_init,date_update,module,model,res_id) VALUES (%s, now(), now(), %s, %s, %s)", \
 420                     (name_id, context['module'], 'ir.model', model_id)
 421                 )
 422
 423         cr.commit()
 424
 425         cr.execute("SELECT * FROM ir_model_fields WHERE model=%s", (self._name,))
 426         cols = {}
 427         for rec in cr.dictfetchall():
 428             cols[rec['name']] = rec
 429
 430         for (k, f) in self._columns.items():
 431             vals = {
 432                 'model_id': model_id,
 433                 'model': self._name,
 434                 'name': k,
 435                 'field_description': f.string.replace("'", " "),
 436                 'ttype': f._type,
 437                 'relation': f._obj or '',
 438                 'view_load': (f.view_load and 1) or 0,
 439                 'select_level': tools.ustr(f.select or 0),
 440                 'readonly': (f.readonly and 1) or 0,
 441                 'required': (f.required and 1) or 0,
 442                 'selectable': (f.selectable and 1) or 0,
 443                 'relation_field': (f._type=='one2many' and isinstance(f, fields.one2many)) and f._fields_id or '',
 444             }
 445             # When its a custom field,it does not contain f.select
 446             if context.get('field_state', 'base') == 'manual':
 447                 if context.get('field_name', '') == k:
 448                     vals['select_level'] = context.get('select', '0')
 449                 #setting value to let the problem NOT occur next time
 450                 elif k in cols:
 451                     vals['select_level'] = cols[k]['select_level']
 452
 453             if k not in cols:
 454                 cr.execute('select nextval(%s)', ('ir_model_fields_id_seq',))
 455                 id = cr.fetchone()[0]
 456                 vals['id'] = id
 457                 cr.execute("""INSERT INTO ir_model_fields (
 458                     id, model_id, model, name, field_description, ttype,
 459                     relation,view_load,state,select_level,relation_field
 460                 ) VALUES (
 461                     %s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s
 462                 )""", (
 463                     id, vals['model_id'], vals['model'], vals['name'], vals['field_description'], vals['ttype'],
 464                      vals['relation'], bool(vals['view_load']), 'base',
 465                     vals['select_level'], vals['relation_field']
 466                 ))
 467                 if 'module' in context:
 468                     name1 = 'field_' + self._table + '_' + k
 469                     cr.execute("select name from ir_model_data where name=%s", (name1,))
 470                     if cr.fetchone():
 471                         name1 = name1 + "_" + str(id)
 472                     cr.execute("INSERT INTO ir_model_data (name,date_init,date_update,module,model,res_id) VALUES (%s, now(), now(), %s, %s, %s)", \
 473                         (name1, context['module'], 'ir.model.fields', id)
 474                     )
 475             else:
 476                 for key, val in vals.items():
 477                     if cols[k][key] != vals[key]:
 478                         cr.execute('update ir_model_fields set field_description=%s where model=%s and name=%s', (vals['field_description'], vals['model'], vals['name']))
 479                         cr.commit()
 480                         cr.execute("""UPDATE ir_model_fields SET
 481                             model_id=%s, field_description=%s, ttype=%s, relation=%s,
 482                             view_load=%s, select_level=%s, readonly=%s ,required=%s, selectable=%s, relation_field=%s
 483                         WHERE
 484                             model=%s AND name=%s""", (
 485                                 vals['model_id'], vals['field_description'], vals['ttype'],
 486                                 vals['relation'], bool(vals['view_load']),
 487                                 vals['select_level'], bool(vals['readonly']), bool(vals['required']), bool(vals['selectable']), vals['relation_field'], vals['model'], vals['name']
 488                             ))
 489                         continue
 490         cr.commit()
 491
 492     def _auto_init(self, cr, context={}):
 493         self._field_create(cr, context)
 494
 495     def __init__(self, cr):
 496         if not self._name and not hasattr(self, '_inherit'):
 497             name = type(self).__name__.split('.')[0]
 498             msg = "The class %s has to have a _name attribute" % name
 499
 500             logger = netsvc.Logger()
 501             logger.notifyChannel('orm', netsvc.LOG_ERROR, msg)
 502             raise except_orm('ValueError', msg)
 503
 504         if not self._description:
 505             self._description = self._name
 506         if not self._table:
 507             self._table = self._name.replace('.', '_')
 508
 509     def browse(self, cr, uid, select, context=None, list_class=None, fields_process={}):
 510         """
 511         Fetch records as objects allowing to use dot notation to browse fields and relations
 512
 513         :param cr: database cursor
 514         :param user: current user id
 515         :param select: id or list of ids
 516         :param context: context arguments, like lang, time zone
 517         :rtype: object or list of objects requested
 518
 519         """
 520         if not context:
 521             context = {}
 522         self._list_class = list_class or browse_record_list
 523         cache = {}
 524         # need to accepts ints and longs because ids coming from a method
 525         # launched by button in the interface have a type long...
 526         if isinstance(select, (int, long)):
 527             return browse_record(cr, uid, select, self, cache, context=context, list_class=self._list_class, fields_process=fields_process)
 528         elif isinstance(select, list):
 529             return self._list_class([browse_record(cr, uid, id, self, cache, context=context, list_class=self._list_class, fields_process=fields_process) for id in select], context)
 530         else:
 531             return browse_null()
 532
 533     def __export_row(self, cr, uid, row, fields, context=None):
 534         if context is None:
 535             context = {}
 536
 537         def check_type(field_type):
 538             if field_type == 'float':
 539                 return 0.0
 540             elif field_type == 'integer':
 541                 return 0
 542             elif field_type == 'boolean':
 543                 return False
 544             return ''
 545
 546         def selection_field(in_field):
 547             col_obj = self.pool.get(in_field.keys()[0])
 548             if f[i] in col_obj._columns.keys():
 549                 return  col_obj._columns[f[i]]
 550             elif f[i] in col_obj._inherits.keys():
 551                 selection_field(col_obj._inherits)
 552             else:
 553                 return False
 554
 555         lines = []
 556         data = map(lambda x: '', range(len(fields)))
 557         for fpos in range(len(fields)):
 558             done = []
 559             f = fields[fpos]
 560             if f:
 561                 r = row
 562                 i = 0
 563                 while i < len(f):
 564                     if f[i] == 'db_id':
 565                         r = r['id']
 566                     elif f[i] == 'id':
 567                         model_data = self.pool.get('ir.model.data')
 568                         data_ids = model_data.search(cr, uid, [('model', '=', r._table_name), ('res_id', '=', r['id'])])
 569                         if len(data_ids):
 570                             d = model_data.read(cr, uid, data_ids, ['name', 'module'])[0]
 571                             if d['module']:
 572                                 r = '%s.%s' % (d['module'], d['name'])
 573                             else:
 574                                 r = d['name']
 575                         else:
 576                             break
 577                     else:
 578                         r = r[f[i]]
 579                         # To display external name of selection field when its exported
 580                         if not context.get('import_comp', False):# Allow external name only if its not import compatible
 581                             cols = False
 582                             if f[i] in self._columns.keys():
 583                                 cols = self._columns[f[i]]
 584                             elif f[i] in self._inherit_fields.keys():
 585                                 cols = selection_field(self._inherits)
 586                             if cols and cols._type == 'selection':
 587                                 sel_list = cols.selection
 588                                 if r and type(sel_list) == type([]):
 589                                     r = [x[1] for x in sel_list if r==x[0]]
 590                                     r = r and r[0] or False
 591                     if not r:
 592                         if f[i] in self._columns:
 593                             r = check_type(self._columns[f[i]]._type)
 594                         elif f[i] in self._inherit_fields:
 595                             r = check_type(self._inherit_fields[f[i]][2]._type)
 596                         data[fpos] = r
 597                         break
 598                     if isinstance(r, (browse_record_list, list)):
 599                         first = True
 600                         fields2 = map(lambda x: (x[:i+1]==f[:i+1] and x[i+1:]) \
 601                                 or [], fields)
 602                         if fields2 in done:
 603                             break
 604                         done.append(fields2)
 605                         for row2 in r:
 606                             lines2 = self.__export_row(cr, uid, row2, fields2,
 607                                     context)
 608                             if first:
 609                                 for fpos2 in range(len(fields)):
 610                                     if lines2 and lines2[0][fpos2]:
 611                                         data[fpos2] = lines2[0][fpos2]
 612                                 if not data[fpos]:
 613                                     dt = ''
 614                                     for rr in r:
 615                                         if isinstance(rr.name, browse_record):
 616                                             rr = rr.name
 617                                         rr_name = self.pool.get(rr._table_name).name_get(cr, uid, [rr.id], context=context)
 618                                         rr_name = rr_name and rr_name[0] and rr_name[0][1] or ''
 619                                         dt += tools.ustr(rr_name or '') + ','
 620                                     data[fpos] = dt[:-1]
 621                                     break
 622                                 lines += lines2[1:]
 623                                 first = False
 624                             else:
 625                                 lines += lines2
 626                         break
 627                     i += 1
 628                 if i == len(f):
 629                     if isinstance(r, browse_record):
 630                         r = self.pool.get(r._table_name).name_get(cr, uid, [r.id], context=context)
 631                         r = r and r[0] and r[0][1] or ''
 632                     data[fpos] = tools.ustr(r or '')
 633         return [data] + lines
 634
 635     def export_data(self, cr, uid, ids, fields_to_export, context=None):
 636         """
 637         Export fields for selected objects
 638
 639         :param cr: database cursor
 640         :param uid: current user id
 641         :param ids: list of ids
 642         :param fields_to_export: list of fields
 643         :param context: context arguments, like lang, time zone, may contain import_comp(default: False) to make exported data compatible with import_data()
 644         :rtype: dictionary with a *datas* matrix
 645
 646         This method is used when exporting data via client menu
 647
 648         """
 649         if context is None:
 650             context = {}
 651         imp_comp = context.get('import_comp', False)
 652         cols = self._columns.copy()
 653         for f in self._inherit_fields:
 654             cols.update({f: self._inherit_fields[f][2]})
 655         fields_to_export = map(lambda x: x.split('/'), fields_to_export)
 656         fields_export = fields_to_export + []
 657         warning = ''
 658         warning_fields = []
 659         for field in fields_export:
 660             if imp_comp and len(field) > 1:
 661                 warning_fields.append('/'.join(map(lambda x: x in cols and cols[x].string or x,field)))
 662             elif len (field) <= 1:
 663                 if imp_comp and cols.get(field and field[0], False):
 664                     if ((isinstance(cols[field[0]], fields.function) and not cols[field[0]].store) \
 665                                      or isinstance(cols[field[0]], fields.related)\
 666                                      or isinstance(cols[field[0]], fields.one2many)):
 667                         warning_fields.append('/'.join(map(lambda x: x in cols and cols[x].string or x,field)))
 668         datas = []
 669         if imp_comp and len(warning_fields):
 670             warning = 'Following columns cannot be exported since you select to be import compatible.\n%s' % ('\n'.join(warning_fields))
 671             cr.rollback()
 672             return {'warning': warning}
 673         for row in self.browse(cr, uid, ids, context):
 674             datas += self.__export_row(cr, uid, row, fields_to_export, context)
 675         return {'datas': datas}
 676
 677     def import_data(self, cr, uid, fields, datas, mode='init', current_module='', noupdate=False, context=None, filename=None):
 678         """
 679         Import given data in given module
 680
 681         :param cr: database cursor
 682         :param uid: current user id
 683         :param ids: list of ids
 684         :param fields: list of fields
 685         :param data: data to import
 686         :param mode: 'init' or 'update' for record creation
 687         :param current_module: module name
 688         :param noupdate: flag for record creation
 689         :param context: context arguments, like lang, time zone,
 690         :param filename: optional file to store partial import state for recovery
 691         :rtype: tuple
 692
 693         This method is used when importing data via client menu
 694
 695         """
 696         if not context:
 697             context = {}
 698         fields = map(lambda x: x.split('/'), fields)
 699         logger = netsvc.Logger()
 700         ir_model_data_obj = self.pool.get('ir.model.data')
 701
 702         def _check_db_id(self, model_name, db_id):
 703             obj_model = self.pool.get(model_name)
 704             ids = obj_model.search(cr, uid, [('id', '=', int(db_id))])
 705             if not len(ids):
 706                 raise Exception(_("Database ID doesn't exist: %s : %s") %(model_name, db_id))
 707             return True
 708
 709         def process_liness(self, datas, prefix, current_module, model_name, fields_def, position=0):
 710             line = datas[position]
 711             row = {}
 712             translate = {}
 713             todo = []
 714             warning = []
 715             data_id = False
 716             data_res_id = False
 717             is_xml_id = False
 718             is_db_id = False
 719             ir_model_data_obj = self.pool.get('ir.model.data')
 720             #
 721             # Import normal fields
 722             #
 723             for i in range(len(fields)):
 724                 if i >= len(line):
 725                     raise Exception(_('Please check that all your lines have %d columns.') % (len(fields),))
 726                 if not line[i]:
 727                     continue
 728
 729                 field = fields[i]
 730                 if prefix and not prefix[0] in field:
 731                     continue
 732
 733                 if (len(field)==len(prefix)+1) and field[len(prefix)].endswith(':db_id'):
 734                         # Database ID
 735                     res = False
 736                     if line[i]:
 737                         field_name = field[0].split(':')[0]
 738                         model_rel = fields_def[field_name]['relation']
 739
 740                         if fields_def[field[len(prefix)][:-6]]['type'] == 'many2many':
 741                             res_id = []
 742                             for db_id in line[i].split(config.get('csv_internal_sep')):
 743                                 try:
 744                                     _check_db_id(self, model_rel, db_id)
 745                                     res_id.append(db_id)
 746                                 except Exception, e:
 747                                     warning += [tools.exception_to_unicode(e)]
 748                                     logger.notifyChannel("import", netsvc.LOG_ERROR,
 749                                               tools.exception_to_unicode(e))
 750                             if len(res_id):
 751                                 res = [(6, 0, res_id)]
 752                             else:
 753                                 try:
 754                                     _check_db_id(self, model_rel, line[i])
 755                                     res = line[i]
 756                                 except Exception, e:
 757                                     warning += [tools.exception_to_unicode(e)]
 758                                     logger.notifyChannel("import", netsvc.LOG_ERROR,
 759                                               tools.exception_to_unicode(e))
 760                         row[field_name] = res or False
 761                         continue
 762
 763                 if (len(field)==len(prefix)+1) and field[len(prefix)].endswith(':id'):
 764                     res_id = False
 765                     if line[i]:
 766                         if fields_def[field[len(prefix)][:-3]]['type'] == 'many2many':
 767                             res_id = []
 768                             for word in line[i].split(config.get('csv_internal_sep')):
 769                                 if '.' in word:
 770                                     module, xml_id = word.rsplit('.', 1)
 771                                 else:
 772                                     module, xml_id = current_module, word
 773                                 id = ir_model_data_obj._get_id(cr, uid, module,
 774                                         xml_id)
 775                                 res_id2 = ir_model_data_obj.read(cr, uid, [id],
 776                                         ['res_id'])[0]['res_id']
 777                                 if res_id2:
 778                                     res_id.append(res_id2)
 779                             if len(res_id):
 780                                 res_id = [(6, 0, res_id)]
 781                         else:
 782                             if '.' in line[i]:
 783                                 module, xml_id = line[i].rsplit('.', 1)
 784                             else:
 785                                 module, xml_id = current_module, line[i]
 786                             record_id = ir_model_data_obj._get_id(cr, uid, module, xml_id)
 787                             ir_model_data = ir_model_data_obj.read(cr, uid, [record_id], ['res_id'])
 788                             if ir_model_data:
 789                                 res_id = ir_model_data[0]['res_id']
 790                             else:
 791                                 raise ValueError('No references to %s.%s' % (module, xml_id))
 792                     row[field[-1][:-3]] = res_id or False
 793                     continue
 794                 if (len(field) == len(prefix)+1) and \
 795                         len(field[len(prefix)].split(':lang=')) == 2:
 796                     f, lang = field[len(prefix)].split(':lang=')
 797                     translate.setdefault(lang, {})[f] = line[i] or False
 798                     continue
 799                 if (len(field) == len(prefix)+1) and \
 800                         (prefix == field[0:len(prefix)]):
 801                     if field[len(prefix)] == "id":
 802                         # XML ID
 803                         db_id = False
 804                         is_xml_id = data_id = line[i]
 805                         d = data_id.split('.')
 806                         module = len(d) > 1 and d[0] or ''
 807                         name = len(d) > 1 and d[1] or d[0]
 808                         data_ids = ir_model_data_obj.search(cr, uid, [('module', '=', module), ('model', '=', model_name), ('name', '=', name)])
 809                         if len(data_ids):
 810                             d = ir_model_data_obj.read(cr, uid, data_ids, ['res_id'])[0]
 811                             db_id = d['res_id']
 812                         if is_db_id and not db_id:
 813                             data_ids = ir_model_data_obj.search(cr, uid, [('module', '=', module), ('model', '=', model_name), ('res_id', '=', is_db_id)])
 814                             if not len(data_ids):
 815                                 ir_model_data_obj.create(cr, uid, {'module': module, 'model': model_name, 'name': name, 'res_id': is_db_id})
 816                                 db_id = is_db_id
 817                         if is_db_id and int(db_id) != int(is_db_id):
 818                             warning += [_("Id is not the same than existing one: %s") % (is_db_id)]
 819                             logger.notifyChannel("import", netsvc.LOG_ERROR,
 820                                     _("Id is not the same than existing one: %s") % (is_db_id))
 821                         continue
 822
 823                     if field[len(prefix)] == "db_id":
 824                         # Database ID
 825                         try:
 826                             _check_db_id(self, model_name, line[i])
 827                             data_res_id = is_db_id = int(line[i])
 828                         except Exception, e:
 829                             warning += [tools.exception_to_unicode(e)]
 830                             logger.notifyChannel("import", netsvc.LOG_ERROR,
 831                                       tools.exception_to_unicode(e))
 832                             continue
 833                         data_ids = ir_model_data_obj.search(cr, uid, [('model', '=', model_name), ('res_id', '=', line[i])])
 834                         if len(data_ids):
 835                             d = ir_model_data_obj.read(cr, uid, data_ids, ['name', 'module'])[0]
 836                             data_id = d['name']
 837                             if d['module']:
 838                                 data_id = '%s.%s' % (d['module'], d['name'])
 839                             else:
 840                                 data_id = d['name']
 841                         if is_xml_id and not data_id:
 842                             data_id = is_xml_id
 843                         if is_xml_id and is_xml_id != data_id:
 844                             warning += [_("Id is not the same than existing one: %s") % (line[i])]
 845                             logger.notifyChannel("import", netsvc.LOG_ERROR,
 846                                     _("Id is not the same than existing one: %s") % (line[i]))
 847
 848                         continue
 849                     if fields_def[field[len(prefix)]]['type'] == 'integer':
 850                         res = line[i] and int(line[i])
 851                     elif fields_def[field[len(prefix)]]['type'] == 'boolean':
 852                         res = line[i].lower() not in ('0', 'false', 'off')
 853                     elif fields_def[field[len(prefix)]]['type'] == 'float':
 854                         res = line[i] and float(line[i])
 855                     elif fields_def[field[len(prefix)]]['type'] == 'selection':
 856                         res = False
 857                         if isinstance(fields_def[field[len(prefix)]]['selection'],
 858                                 (tuple, list)):
 859                             sel = fields_def[field[len(prefix)]]['selection']
 860                         else:
 861                             sel = fields_def[field[len(prefix)]]['selection'](self,
 862                                     cr, uid, context)
 863                         for key, val in sel:
 864                             if line[i] in [tools.ustr(key), tools.ustr(val)]: #Acepting key or value for selection field
 865                                 res = key
 866                                 break
 867                         if line[i] and not res:
 868                             logger.notifyChannel("import", netsvc.LOG_WARNING,
 869                                     _("key '%s' not found in selection field '%s'") % \
 870                                             (line[i], field[len(prefix)]))
 871
 872                             warning += [_("Key/value '%s' not found in selection field '%s'") % (line[i], field[len(prefix)])]
 873
 874                     elif fields_def[field[len(prefix)]]['type'] == 'many2one':
 875                         res = False
 876                         if line[i]:
 877                             relation = fields_def[field[len(prefix)]]['relation']
 878                             res2 = self.pool.get(relation).name_search(cr, uid,
 879                                     line[i], [], operator='=', context=context)
 880                             res = (res2 and res2[0][0]) or False
 881                             if not res:
 882                                 warning += [_("Relation not found: %s on '%s'") % (line[i], relation)]
 883                                 logger.notifyChannel("import", netsvc.LOG_WARNING,
 884                                         _("Relation not found: %s on '%s'") % (line[i], relation))
 885                     elif fields_def[field[len(prefix)]]['type'] == 'many2many':
 886                         res = []
 887                         if line[i]:
 888                             relation = fields_def[field[len(prefix)]]['relation']
 889                             for word in line[i].split(config.get('csv_internal_sep')):
 890                                 res2 = self.pool.get(relation).name_search(cr,
 891                                         uid, word, [], operator='=', context=context)
 892                                 res3 = (res2 and res2[0][0]) or False
 893                                 if not res3:
 894                                     warning += [_("Relation not found: %s on '%s'") % (line[i], relation)]
 895                                     logger.notifyChannel("import",
 896                                             netsvc.LOG_WARNING,
 897                                             _("Relation not found: %s on '%s'") % (line[i], relation))
 898                                 else:
 899                                     res.append(res3)
 900                             if len(res):
 901                                 res = [(6, 0, res)]
 902                     else:
 903                         res = line[i] or False
 904                     row[field[len(prefix)]] = res
 905                 elif (prefix==field[0:len(prefix)]):
 906                     if field[0] not in todo:
 907                         todo.append(field[len(prefix)])
 908             #
 909             # Import one2many, many2many fields
 910             #
 911             nbrmax = 1
 912             for field in todo:
 913                 relation_obj = self.pool.get(fields_def[field]['relation'])
 914                 newfd = relation_obj.fields_get(
 915                         cr, uid, context=context)
 916                 res = process_liness(self, datas, prefix + [field], current_module, relation_obj._name, newfd, position)
 917                 (newrow, max2, w2, translate2, data_id2, data_res_id2) = res
 918                 nbrmax = max(nbrmax, max2)
 919                 warning = warning + w2
 920                 reduce(lambda x, y: x and y, newrow)
 921                 row[field] = newrow and (reduce(lambda x, y: x or y, newrow.values()) and \
 922                         [(0, 0, newrow)]) or []
 923                 i = max2
 924                 while (position+i) < len(datas):
 925                     ok = True
 926                     for j in range(len(fields)):
 927                         field2 = fields[j]
 928                         if (len(field2) <= (len(prefix)+1)) and datas[position+i][j]:
 929                             ok = False
 930                     if not ok:
 931                         break
 932
 933                     (newrow, max2, w2, translate2, data_id2, data_res_id2) = process_liness(
 934                             self, datas, prefix+[field], current_module, relation_obj._name, newfd, position+i)
 935                     warning = warning + w2
 936                     if newrow and reduce(lambda x, y: x or y, newrow.values()):
 937                         row[field].append((0, 0, newrow))
 938                     i += max2
 939                     nbrmax = max(nbrmax, i)
 940
 941             if len(prefix) == 0:
 942                 for i in range(max(nbrmax, 1)):
 943                     #if datas:
 944                     datas.pop(0)
 945             result = (row, nbrmax, warning, translate, data_id, data_res_id)
 946             return result
 947
 948         fields_def = self.fields_get(cr, uid, context=context)
 949         done = 0
 950
 951         initial_size = len(datas)
 952         if config.get('import_partial', False) and filename:
 953             data = pickle.load(file(config.get('import_partial')))
 954             original_value = data.get(filename, 0)
 955         counter = 0
 956         while len(datas):
 957             counter += 1
 958             res = {}
 959             #try:
 960             (res, other, warning, translate, data_id, res_id) = \
 961                     process_liness(self, datas, [], current_module, self._name, fields_def)
 962             if len(warning):
 963                 cr.rollback()
 964                 return (-1, res, 'Line ' + str(counter) +' : ' + '!\n'.join(warning), '')
 965
 966             try:
 967                 id = ir_model_data_obj._update(cr, uid, self._name,
 968                      current_module, res, xml_id=data_id, mode=mode,
 969                      noupdate=noupdate, res_id=res_id, context=context)
 970             except Exception, e:
 971                 import psycopg2
 972                 import osv
 973                 cr.rollback()
 974                 if isinstance(e, psycopg2.IntegrityError):
 975                     msg = _('Insertion Failed! ')
 976                     for key in self.pool._sql_error.keys():
 977                         if key in e[0]:
 978                             msg = self.pool._sql_error[key]
 979                             break
 980                     return (-1, res, 'Line ' + str(counter) +' : ' + msg, '')
 981                 if isinstance(e, osv.orm.except_orm):
 982                     msg = _('Insertion Failed! ' + e[1])
 983                     return (-1, res, 'Line ' + str(counter) +' : ' + msg, '')
 984                 #Raising Uncaught exception
 985                 return (-1, res, 'Line ' + str(counter) +' : ' + str(e), '')
 986
 987             for lang in translate:
 988                 context2 = context.copy()
 989                 context2['lang'] = lang
 990                 self.write(cr, uid, [id], translate[lang], context2)
 991             if config.get('import_partial', False) and filename and (not (counter%100)):
 992                 data = pickle.load(file(config.get('import_partial')))
 993                 data[filename] = initial_size - len(datas) + original_value
 994                 pickle.dump(data, file(config.get('import_partial'), 'wb'))
 995                 if context.get('defer_parent_store_computation'):
 996                     self._parent_store_compute(cr)
 997                 cr.commit()
 998
 999             #except Exception, e:
1000             #    logger.notifyChannel("import", netsvc.LOG_ERROR, e)
1001             #    cr.rollback()
1002             #    try:
1003             #        return (-1, res, e[0], warning)
1004             #    except:
1005             #        return (-1, res, e[0], '')
1006             done += 1
1007         #
1008         # TODO: Send a request with the result and multi-thread !
1009         #
1010         if context.get('defer_parent_store_computation'):
1011             self._parent_store_compute(cr)
1012         return (done, 0, 0, 0)
1013
1014     def read(self, cr, user, ids, fields=None, context=None, load='_classic_read'):
1015         raise NotImplementedError(_('The read method is not implemented on this object !'))
1016
1017     def get_invalid_fields(self, cr, uid):
1018         return list(self._invalids)
1019
1020     def _validate(self, cr, uid, ids, context=None):
1021         context = context or {}
1022         lng = context.get('lang', False) or 'en_US'
1023         trans = self.pool.get('ir.translation')
1024         error_msgs = []
1025         for constraint in self._constraints:
1026             fun, msg, fields = constraint
1027             if not fun(self, cr, uid, ids):
1028                 # Check presence of __call__ directly instead of using
1029                 # callable() because it will be deprecated as of Python 3.0
1030                 if hasattr(msg, '__call__'):
1031                     txt_msg, params = msg(self, cr, uid, ids)
1032                     tmp_msg = trans._get_source(cr, uid, self._name, 'constraint', lng, source=txt_msg) or txt_msg
1033                     translated_msg = tmp_msg % params
1034                 else:
1035                     translated_msg = trans._get_source(cr, uid, self._name, 'constraint', lng, source=msg) or msg
1036                 error_msgs.append(
1037                         _("Error occurred while validating the field(s) %s: %s") % (','.join(fields), translated_msg)
1038                 )
1039                 self._invalids.update(fields)
1040         if error_msgs:
1041             cr.rollback()
1042             raise except_orm('ValidateError', '\n'.join(error_msgs))
1043         else:
1044             self._invalids.clear()
1045
1046     def default_get(self, cr, uid, fields_list, context=None):
1047         """
1048         Returns default values for the fields in fields_list.
1049
1050         :param fields_list: list of fields to get the default values for (example ['field1', 'field2',])
1051         :type fields_list: list
1052         :param context: usual context dictionary - it may contains keys in the form ``default_XXX``,
1053                         where XXX is a field name to set or override a default value.
1054         :return: dictionary of the default values (set on the object model class, through user preferences, or in the context)
1055         """
1056         # trigger view init hook
1057         self.view_init(cr, uid, fields_list, context)
1058
1059         if not context:
1060             context = {}
1061         defaults = {}
1062
1063         # get the default values for the inherited fields
1064         for t in self._inherits.keys():
1065             defaults.update(self.pool.get(t).default_get(cr, uid, fields_list,
1066                 context))
1067
1068         # get the default values defined in the object
1069         for f in fields_list:
1070             if f in self._defaults:
1071                 if callable(self._defaults[f]):
1072                     defaults[f] = self._defaults[f](self, cr, uid, context)
1073                 else:
1074                     defaults[f] = self._defaults[f]
1075
1076             fld_def = ((f in self._columns) and self._columns[f]) \
1077                     or ((f in self._inherit_fields) and self._inherit_fields[f][2]) \
1078                     or False
1079
1080             if isinstance(fld_def, fields.property):
1081                 property_obj = self.pool.get('ir.property')
1082                 prop_value = property_obj.get(cr, uid, f, self._name, context=context)
1083                 if prop_value:
1084                     if isinstance(prop_value, (browse_record, browse_null)):
1085                         defaults[f] = prop_value.id
1086                     else:
1087                         defaults[f] = prop_value
1088                 else:
1089                     if f not in defaults:
1090                         defaults[f] = False
1091
1092         # get the default values set by the user and override the default
1093         # values defined in the object
1094         ir_values_obj = self.pool.get('ir.values')
1095         res = ir_values_obj.get(cr, uid, 'default', False, [self._name])
1096         for id, field, field_value in res:
1097             if field in fields_list:
1098                 fld_def = (field in self._columns) and self._columns[field] or self._inherit_fields[field][2]
1099                 if fld_def._type in ('many2one', 'one2one'):
1100                     obj = self.pool.get(fld_def._obj)
1101                     if not obj.search(cr, uid, [('id', '=', field_value or False)]):
1102                         continue
1103                 if fld_def._type in ('many2many'):
1104                     obj = self.pool.get(fld_def._obj)
1105                     field_value2 = []
1106                     for i in range(len(field_value)):
1107                         if not obj.search(cr, uid, [('id', '=',
1108                             field_value[i])]):
1109                             continue
1110                         field_value2.append(field_value[i])
1111                     field_value = field_value2
1112                 if fld_def._type in ('one2many'):
1113                     obj = self.pool.get(fld_def._obj)
1114                     field_value2 = []
1115                     for i in range(len(field_value)):
1116                         field_value2.append({})
1117                         for field2 in field_value[i]:
1118                             if field2 in obj._columns.keys() and obj._columns[field2]._type in ('many2one', 'one2one'):
1119                                 obj2 = self.pool.get(obj._columns[field2]._obj)
1120                                 if not obj2.search(cr, uid,
1121                                         [('id', '=', field_value[i][field2])]):
1122                                     continue
1123                             elif field2 in obj._inherit_fields.keys() and obj._inherit_fields[field2][2]._type in ('many2one', 'one2one'):
1124                                 obj2 = self.pool.get(obj._inherit_fields[field2][2]._obj)
1125                                 if not obj2.search(cr, uid,
1126                                         [('id', '=', field_value[i][field2])]):
1127                                     continue
1128                             # TODO add test for many2many and one2many
1129                             field_value2[i][field2] = field_value[i][field2]
1130                     field_value = field_value2
1131                 defaults[field] = field_value
1132
1133         # get the default values from the context
1134         for key in context or {}:
1135             if key.startswith('default_') and (key[8:] in fields_list):
1136                 defaults[key[8:]] = context[key]
1137         return defaults
1138
1139
1140     def perm_read(self, cr, user, ids, context=None, details=True):
1141         raise NotImplementedError(_('The perm_read method is not implemented on this object !'))
1142
1143     def unlink(self, cr, uid, ids, context=None):
1144         raise NotImplementedError(_('The unlink method is not implemented on this object !'))
1145
1146     def write(self, cr, user, ids, vals, context=None):
1147         raise NotImplementedError(_('The write method is not implemented on this object !'))
1148
1149     def create(self, cr, user, vals, context=None):
1150         raise NotImplementedError(_('The create method is not implemented on this object !'))
1151
1152     def fields_get_keys(self, cr, user, context=None):
1153         res = self._columns.keys()
1154         for parent in self._inherits:
1155             res.extend(self.pool.get(parent).fields_get_keys(cr, user, context))
1156         return res
1157
1158     # returns the definition of each field in the object
1159     # the optional fields parameter can limit the result to some fields
1160     def fields_get(self, cr, user, allfields=None, context=None, write_access=True):
1161         if context is None:
1162             context = {}
1163         res = {}
1164         translation_obj = self.pool.get('ir.translation')
1165         for parent in self._inherits:
1166             res.update(self.pool.get(parent).fields_get(cr, user, allfields, context))
1167
1168         if self._columns.keys():
1169             for f in self._columns.keys():
1170                 if allfields and f not in allfields:
1171                     continue
1172                 res[f] = {'type': self._columns[f]._type}
1173                 # This additional attributes for M2M and function field is added
1174                 # because we need to display tooltip with this additional information
1175                 # when client is started in debug mode.
1176                 if isinstance(self._columns[f], fields.function):
1177                     res[f]['function'] = self._columns[f]._fnct and self._columns[f]._fnct.func_name or False
1178                     res[f]['store'] = self._columns[f].store
1179                     if isinstance(self._columns[f].store, dict):
1180                         res[f]['store'] = str(self._columns[f].store)
1181                     res[f]['fnct_search'] = self._columns[f]._fnct_search and self._columns[f]._fnct_search.func_name or False
1182                     res[f]['fnct_inv'] = self._columns[f]._fnct_inv and self._columns[f]._fnct_inv.func_name or False
1183                     res[f]['fnct_inv_arg'] = self._columns[f]._fnct_inv_arg or False
1184                     res[f]['func_obj'] = self._columns[f]._obj or False
1185                     res[f]['func_method'] = self._columns[f]._method
1186                 if isinstance(self._columns[f], fields.many2many):
1187                     res[f]['related_columns'] = list((self._columns[f]._id1, self._columns[f]._id2))
1188                     res[f]['third_table'] = self._columns[f]._rel
1189                 for arg in ('string', 'readonly', 'states', 'size', 'required', 'group_operator',
1190                         'change_default', 'translate', 'help', 'select', 'selectable'):
1191                     if getattr(self._columns[f], arg):
1192                         res[f][arg] = getattr(self._columns[f], arg)
1193                 if not write_access:
1194                     res[f]['readonly'] = True
1195                     res[f]['states'] = {}
1196                 for arg in ('digits', 'invisible', 'filters'):
1197                     if getattr(self._columns[f], arg, None):
1198                         res[f][arg] = getattr(self._columns[f], arg)
1199
1200                 res_trans = translation_obj._get_source(cr, user, self._name + ',' + f, 'field', context.get('lang', False) or 'en_US', self._columns[f].string)
1201                 if res_trans:
1202                     res[f]['string'] = res_trans
1203                 help_trans = translation_obj._get_source(cr, user, self._name + ',' + f, 'help', context.get('lang', False) or 'en_US')
1204                 if help_trans:
1205                     res[f]['help'] = help_trans
1206
1207                 if hasattr(self._columns[f], 'selection'):
1208                     if isinstance(self._columns[f].selection, (tuple, list)):
1209                         sel = self._columns[f].selection
1210                         # translate each selection option
1211                         sel2 = []
1212                         for (key, val) in sel:
1213                             val2 = None
1214                             if val:
1215                                 val2 = translation_obj._get_source(cr, user, self._name + ',' + f, 'selection', context.get('lang', False) or 'en_US', val)
1216                             sel2.append((key, val2 or val))
1217                         sel = sel2
1218                         res[f]['selection'] = sel
1219                     else:
1220                         # call the 'dynamic selection' function
1221                         res[f]['selection'] = self._columns[f].selection(self, cr,
1222                                 user, context)
1223                 if res[f]['type'] in ('one2many', 'many2many', 'many2one', 'one2one'):
1224                     res[f]['relation'] = self._columns[f]._obj
1225                     res[f]['domain'] = self._columns[f]._domain
1226                     res[f]['context'] = self._columns[f]._context
1227         else:
1228             #TODO : read the fields from the database
1229             pass
1230
1231         if allfields:
1232             # filter out fields which aren't in the fields list
1233             for r in res.keys():
1234                 if r not in allfields:
1235                     del res[r]
1236         return res
1237
1238     #
1239     # Overload this method if you need a window title which depends on the context
1240     #
1241     def view_header_get(self, cr, user, view_id=None, view_type='form', context=None):
1242         return False
1243
1244     def __view_look_dom(self, cr, user, node, view_id, context=None):
1245         if not context:
1246             context = {}
1247         result = False
1248         fields = {}
1249         childs = True
1250
1251         def encode(s):
1252             if isinstance(s, unicode):
1253                 return s.encode('utf8')
1254             return s
1255
1256         # return True if node can be displayed to current user
1257         def check_group(node):
1258             if node.get('groups'):
1259                 groups = node.get('groups').split(',')
1260                 access_pool = self.pool.get('ir.model.access')
1261                 can_see = any(access_pool.check_groups(cr, user, group) for group in groups)
1262                 if not can_see:
1263                     node.set('invisible', '1')
1264                     if 'attrs' in node.attrib:
1265                         del(node.attrib['attrs']) #avoid making field visible later
1266                 del(node.attrib['groups'])
1267                 return can_see
1268             else:
1269                 return True
1270
1271         if node.tag in ('field', 'node', 'arrow'):
1272             if node.get('object'):
1273                 attrs = {}
1274                 views = {}
1275                 xml = "<form>"
1276                 for f in node:
1277                     if f.tag in ('field'):
1278                         xml += etree.tostring(f, encoding="utf-8")
1279                 xml += "</form>"
1280                 new_xml = etree.fromstring(encode(xml))
1281                 ctx = context.copy()
1282                 ctx['base_model_name'] = self._name
1283                 xarch, xfields = self.pool.get(node.get('object', False)).__view_look_dom_arch(cr, user, new_xml, view_id, ctx)
1284                 views[str(f.tag)] = {
1285                     'arch': xarch,
1286                     'fields': xfields
1287                 }
1288                 attrs = {'views': views}
1289                 fields = views.get('field', False) and views['field'].get('fields', False)
1290             if node.get('name'):
1291                 attrs = {}
1292                 try:
1293                     if node.get('name') in self._columns:
1294                         column = self._columns[node.get('name')]
1295                     else:
1296                         column = self._inherit_fields[node.get('name')][2]
1297                 except:
1298                     column = False
1299
1300                 if column:
1301                     relation = self.pool.get(column._obj)
1302
1303                     childs = False
1304                     views = {}
1305                     for f in node:
1306                         if f.tag in ('form', 'tree', 'graph'):
1307                             node.remove(f)
1308                             ctx = context.copy()
1309                             ctx['base_model_name'] = self._name
1310                             xarch, xfields = relation.__view_look_dom_arch(cr, user, f, view_id, ctx)
1311                             views[str(f.tag)] = {
1312                                 'arch': xarch,
1313                                 'fields': xfields
1314                             }
1315                     attrs = {'views': views}
1316                     if node.get('widget') and node.get('widget') == 'selection':
1317                         # Prepare the cached selection list for the client. This needs to be
1318                         # done even when the field is invisible to the current user, because
1319                         # other events could need to change its value to any of the selectable ones
1320                         # (such as on_change events, refreshes, etc.)
1321
1322                         # If domain and context are strings, we keep them for client-side, otherwise
1323                         # we evaluate them server-side to consider them when generating the list of
1324                         # possible values
1325                         # TODO: find a way to remove this hack, by allow dynamic domains
1326                         dom = []
1327                         if column._domain and not isinstance(column._domain, basestring):
1328                             dom = column._domain
1329                         dom += eval(node.get('domain', '[]'), {'uid': user, 'time': time})
1330                         search_context = dict(context)
1331                         if column._context and not isinstance(column._context, basestring):
1332                             search_context.update(column._context)
1333                         attrs['selection'] = relation._name_search(cr, user, '', dom, context=search_context, limit=None, name_get_uid=1)
1334                         if (node.get('required') and not int(node.get('required'))) or not column.required:
1335                             attrs['selection'].append((False, ''))
1336                 fields[node.get('name')] = attrs
1337
1338         elif node.tag in ('form', 'tree'):
1339             result = self.view_header_get(cr, user, False, node.tag, context)
1340             if result:
1341                 node.set('string', result)
1342
1343         elif node.tag == 'calendar':
1344             for additional_field in ('date_start', 'date_delay', 'date_stop', 'color'):
1345                 if node.get(additional_field):
1346                     fields[node.get(additional_field)] = {}
1347
1348         if 'groups' in node.attrib:
1349             check_group(node)
1350
1351         # translate view
1352         if ('lang' in context) and not result:
1353             if node.get('string'):
1354                 trans = self.pool.get('ir.translation')._get_source(cr, user, self._name, 'view', context['lang'], node.get('string'))
1355                 if not trans and ('base_model_name' in context):
1356                     trans = self.pool.get('ir.translation')._get_source(cr, user, context['base_model_name'], 'view', context['lang'], node.get('string'))
1357                 if trans:
1358                     node.set('string', trans)
1359             if node.get('sum'):
1360                 trans = self.pool.get('ir.translation')._get_source(cr, user, self._name, 'view', context['lang'], node.get('sum'))
1361                 if trans:
1362                     node.set('sum', trans)
1363
1364         for f in node:
1365             if childs or (node.tag == 'field' and f.tag in ('filter','separator')):
1366                 fields.update(self.__view_look_dom(cr, user, f, view_id, context))
1367
1368         return fields
1369
1370     def _disable_workflow_buttons(self, cr, user, node):
1371         if user == 1:
1372             # admin user can always activate workflow buttons
1373             return node
1374
1375         # TODO handle the case of more than one workflow for a model or multiple
1376         # transitions with different groups and same signal
1377         usersobj = self.pool.get('res.users')
1378         buttons = (n for n in node.getiterator('button') if n.get('type') != 'object')
1379         for button in buttons:
1380             user_groups = usersobj.read(cr, user, [user], ['groups_id'])[0]['groups_id']
1381             cr.execute("""SELECT DISTINCT t.group_id
1382                         FROM wkf
1383                   INNER JOIN wkf_activity a ON a.wkf_id = wkf.id
1384                   INNER JOIN wkf_transition t ON (t.act_to = a.id)
1385                        WHERE wkf.osv = %s
1386                          AND t.signal = %s
1387                          AND t.group_id is NOT NULL
1388                    """, (self._name, button.get('name')))
1389             group_ids = [x[0] for x in cr.fetchall() if x[0]]
1390             can_click = not group_ids or bool(set(user_groups).intersection(group_ids))
1391             button.set('readonly', str(int(not can_click)))
1392         return node
1393
1394     def __view_look_dom_arch(self, cr, user, node, view_id, context=None):
1395         fields_def = self.__view_look_dom(cr, user, node, view_id, context=context)
1396         node = self._disable_workflow_buttons(cr, user, node)
1397         arch = etree.tostring(node, encoding="utf-8").replace('\t', '')
1398         fields = {}
1399         if node.tag == 'diagram':
1400             if node.getchildren()[0].tag == 'node':
1401                 node_fields = self.pool.get(node.getchildren()[0].get('object')).fields_get(cr, user, fields_def.keys(), context)
1402             if node.getchildren()[1].tag == 'arrow':
1403                 arrow_fields = self.pool.get(node.getchildren()[1].get('object')).fields_get(cr, user, fields_def.keys(), context)
1404             for key, value in node_fields.items():
1405                 fields[key] = value
1406             for key, value in arrow_fields.items():
1407                 fields[key] = value
1408         else:
1409             fields = self.fields_get(cr, user, fields_def.keys(), context)
1410         for field in fields_def:
1411             if field == 'id':
1412                 # sometime, the view may containt the (invisible) field 'id' needed for a domain (when 2 objects have cross references)
1413                 fields['id'] = {'readonly': True, 'type': 'integer', 'string': 'ID'}
1414             elif field in fields:
1415                 fields[field].update(fields_def[field])
1416             else:
1417                 cr.execute('select name, model from ir_ui_view where (id=%s or inherit_id=%s) and arch like %s', (view_id, view_id, '%%%s%%' % field))
1418                 res = cr.fetchall()[:]
1419                 model = res[0][1]
1420                 res.insert(0, ("Can't find field '%s' in the following view parts composing the view of object model '%s':" % (field, model), None))
1421                 msg = "\n * ".join([r[0] for r in res])
1422                 msg += "\n\nEither you wrongly customised this view, or some modules bringing those views are not compatible with your current data model"
1423                 netsvc.Logger().notifyChannel('orm', netsvc.LOG_ERROR, msg)
1424                 raise except_orm('View error', msg)
1425         return arch, fields
1426
1427     def __get_default_calendar_view(self):
1428         """Generate a default calendar view (For internal use only).
1429         """
1430
1431         arch = ('<?xml version="1.0" encoding="utf-8"?>\n'
1432                 '<calendar string="%s"') % (self._description)
1433
1434         if (self._date_name not in self._columns):
1435             date_found = False
1436             for dt in ['date', 'date_start', 'x_date', 'x_date_start']:
1437                 if dt in self._columns:
1438                     self._date_name = dt
1439                     date_found = True
1440                     break
1441
1442             if not date_found:
1443                 raise except_orm(_('Invalid Object Architecture!'), _("Insufficient fields for Calendar View!"))
1444
1445         if self._date_name:
1446             arch += ' date_start="%s"' % (self._date_name)
1447
1448         for color in ["user_id", "partner_id", "x_user_id", "x_partner_id"]:
1449             if color in self._columns:
1450                 arch += ' color="' + color + '"'
1451                 break
1452
1453         dt_stop_flag = False
1454
1455         for dt_stop in ["date_stop", "date_end", "x_date_stop", "x_date_end"]:
1456             if dt_stop in self._columns:
1457                 arch += ' date_stop="' + dt_stop + '"'
1458                 dt_stop_flag = True
1459                 break
1460
1461         if not dt_stop_flag:
1462             for dt_delay in ["date_delay", "planned_hours", "x_date_delay", "x_planned_hours"]:
1463                 if dt_delay in self._columns:
1464                     arch += ' date_delay="' + dt_delay + '"'
1465                     break
1466
1467         arch += ('>\n'
1468                  '  <field name="%s"/>\n'
1469                  '</calendar>') % (self._rec_name)
1470
1471         return arch
1472
1473     def __get_default_search_view(self, cr, uid, context={}):
1474
1475         def encode(s):
1476             if isinstance(s, unicode):
1477                 return s.encode('utf8')
1478             return s
1479
1480         view = self.fields_view_get(cr, uid, False, 'form', context)
1481
1482         root = etree.fromstring(encode(view['arch']))
1483         res = etree.XML("""<search string="%s"></search>""" % root.get("string", ""))
1484         node = etree.Element("group")
1485         res.append(node)
1486
1487         fields = root.xpath("//field[@select=1]")
1488         for field in fields:
1489             node.append(field)
1490
1491         return etree.tostring(res, encoding="utf-8").replace('\t', '')
1492
1493     #
1494     # if view_id, view_type is not required
1495     #
1496     def fields_view_get(self, cr, user, view_id=None, view_type='form', context=None, toolbar=False, submenu=False):
1497         """
1498         Get the detailed composition of the requested view like fields, model, view architecture
1499
1500         :param cr: database cursor
1501         :param user: current user id
1502         :param view_id: id of the view or None
1503         :param view_type: type of the view to return if view_id is None ('form', tree', ...)
1504         :param context: context arguments, like lang, time zone
1505         :param toolbar: true to include contextual actions
1506         :param submenu: example (portal_project module)
1507         :return: dictionary describing the composition of the requested view (including inherited views and extensions)
1508         :raise AttributeError:
1509                             * if the inherited view has unknown position to work with other than 'before', 'after', 'inside', 'replace'
1510                             * if some tag other than 'position' is found in parent view
1511         :raise Invalid ArchitectureError: if there is view type other than form, tree, calendar, search etc defined on the structure
1512
1513         """
1514         if not context:
1515             context = {}
1516
1517         def encode(s):
1518             if isinstance(s, unicode):
1519                 return s.encode('utf8')
1520             return s
1521
1522         def _inherit_apply(src, inherit):
1523             def _find(node, node2):
1524                 if node2.tag == 'xpath':
1525                     res = node.xpath(node2.get('expr'))
1526                     if res:
1527                         return res[0]
1528                     else:
1529                         return None
1530                 else:
1531                     for n in node.getiterator(node2.tag):
1532                         res = True
1533                         if node2.tag == 'field':
1534                             # only compare field names, a field can be only once in a given view
1535                             # at a given level (and for multilevel expressions, we should use xpath
1536                             # inheritance spec anyway)
1537                             if node2.get('name') == n.get('name'):
1538                                 return n
1539                             else:
1540                                 continue
1541                         for attr in node2.attrib:
1542                             if attr == 'position':
1543                                 continue
1544                             if n.get(attr):
1545                                 if n.get(attr) == node2.get(attr):
1546                                     continue
1547                             res = False
1548                         if res:
1549                             return n
1550                 return None
1551
1552             # End: _find(node, node2)
1553
1554             doc_dest = etree.fromstring(encode(inherit))
1555             toparse = [doc_dest]
1556
1557             while len(toparse):
1558                 node2 = toparse.pop(0)
1559                 if node2.tag == 'data':
1560                     toparse += [ c for c in doc_dest ]
1561                     continue
1562                 node = _find(src, node2)
1563                 if node is not None:
1564                     pos = 'inside'
1565                     if node2.get('position'):
1566                         pos = node2.get('position')
1567                     if pos == 'replace':
1568                         parent = node.getparent()
1569                         if parent is None:
1570                             src = copy.deepcopy(node2[0])
1571                         else:
1572                             for child in node2:
1573                                 node.addprevious(child)
1574                             node.getparent().remove(node)
1575                     elif pos == 'attributes':
1576                         for child in node2.getiterator('attribute'):
1577                             attribute = (child.get('name'), child.text and child.text.encode('utf8') or None)
1578                             if attribute[1]:
1579                                 node.set(attribute[0], attribute[1])
1580                             else:
1581                                 del(node.attrib[attribute[0]])
1582                     else:
1583                         sib = node.getnext()
1584                         for child in node2:
1585                             if pos == 'inside':
1586                                 node.append(child)
1587                             elif pos == 'after':
1588                                 if sib is None:
1589                                     node.addnext(child)
1590                                 else:
1591                                     sib.addprevious(child)
1592                             elif pos == 'before':
1593                                 node.addprevious(child)
1594                             else:
1595                                 raise AttributeError(_('Unknown position in inherited view %s !') % pos)
1596                 else:
1597                     attrs = ''.join([
1598                         ' %s="%s"' % (attr, node2.get(attr))
1599                         for attr in node2.attrib
1600                         if attr != 'position'
1601                     ])
1602                     tag = "<%s%s>" % (node2.tag, attrs)
1603                     raise AttributeError(_("Couldn't find tag '%s' in parent view !") % tag)
1604             return src
1605         # End: _inherit_apply(src, inherit)
1606
1607         result = {'type': view_type, 'model': self._name}
1608
1609         ok = True
1610         model = True
1611         sql_res = False
1612         while ok:
1613             view_ref = context.get(view_type + '_view_ref', False)
1614             if view_ref and not view_id:
1615                 if '.' in view_ref:
1616                     module, view_ref = view_ref.split('.', 1)
1617                     cr.execute("SELECT res_id FROM ir_model_data WHERE model='ir.ui.view' AND module=%s AND name=%s", (module, view_ref))
1618                     view_ref_res = cr.fetchone()
1619                     if view_ref_res:
1620                         view_id = view_ref_res[0]
1621
1622             if view_id:
1623                 query = "SELECT arch,name,field_parent,id,type,inherit_id FROM ir_ui_view WHERE id=%s"
1624                 params = (view_id,)
1625                 if model:
1626                     query += " AND model=%s"
1627                     params += (self._name,)
1628                 cr.execute(query, params)
1629             else:
1630                 cr.execute('''SELECT
1631                         arch,name,field_parent,id,type,inherit_id
1632                     FROM
1633                         ir_ui_view
1634                     WHERE
1635                         model=%s AND
1636                         type=%s AND
1637                         inherit_id IS NULL
1638                     ORDER BY priority''', (self._name, view_type))
1639             sql_res = cr.fetchone()
1640
1641             if not sql_res:
1642                 break
1643
1644             ok = sql_res[5]
1645             view_id = ok or sql_res[3]
1646             model = False
1647
1648         # if a view was found
1649         if sql_res:
1650             result['type'] = sql_res[4]
1651             result['view_id'] = sql_res[3]
1652             result['arch'] = sql_res[0]
1653
1654             def _inherit_apply_rec(result, inherit_id):
1655                 # get all views which inherit from (ie modify) this view
1656                 cr.execute('select arch,id from ir_ui_view where inherit_id=%s and model=%s order by priority', (inherit_id, self._name))
1657                 sql_inherit = cr.fetchall()
1658                 for (inherit, id) in sql_inherit:
1659                     result = _inherit_apply(result, inherit)
1660                     result = _inherit_apply_rec(result, id)
1661                 return result
1662
1663             inherit_result = etree.fromstring(encode(result['arch']))
1664             result['arch'] = _inherit_apply_rec(inherit_result, sql_res[3])
1665
1666             result['name'] = sql_res[1]
1667             result['field_parent'] = sql_res[2] or False
1668         else:
1669
1670             # otherwise, build some kind of default view
1671             if view_type == 'form':
1672                 res = self.fields_get(cr, user, context=context)
1673                 xml = '<?xml version="1.0" encoding="utf-8"?> ' \
1674                      '<form string="%s">' % (self._description,)
1675                 for x in res:
1676                     if res[x]['type'] not in ('one2many', 'many2many'):
1677                         xml += '<field name="%s"/>' % (x,)
1678                         if res[x]['type'] == 'text':
1679                             xml += "<newline/>"
1680                 xml += "</form>"
1681
1682             elif view_type == 'tree':
1683                 _rec_name = self._rec_name
1684                 if _rec_name not in self._columns:
1685                     _rec_name = self._columns.keys()[0]
1686                 xml = '<?xml version="1.0" encoding="utf-8"?>' \
1687                        '<tree string="%s"><field name="%s"/></tree>' \
1688                        % (self._description, self._rec_name)
1689
1690             elif view_type == 'calendar':
1691                 xml = self.__get_default_calendar_view()
1692
1693             elif view_type == 'search':
1694                 xml = self.__get_default_search_view(cr, user, context)
1695
1696             else:
1697                 xml = '<?xml version="1.0"?>' # what happens here, graph case?
1698                 raise except_orm(_('Invalid Architecture!'), _("There is no view of type '%s' defined for the structure!") % view_type)
1699             result['arch'] = etree.fromstring(encode(xml))
1700             result['name'] = 'default'
1701             result['field_parent'] = False
1702             result['view_id'] = 0
1703
1704         xarch, xfields = self.__view_look_dom_arch(cr, user, result['arch'], view_id, context=context)
1705         result['arch'] = xarch
1706         result['fields'] = xfields
1707
1708         if submenu:
1709             if context and context.get('active_id', False):
1710                 data_menu = self.pool.get('ir.ui.menu').browse(cr, user, context['active_id'], context).action
1711                 if data_menu:
1712                     act_id = data_menu.id
1713                     if act_id:
1714                         data_action = self.pool.get('ir.actions.act_window').browse(cr, user, [act_id], context)[0]
1715                         result['submenu'] = getattr(data_action, 'menus', False)
1716         if toolbar:
1717             def clean(x):
1718                 x = x[2]
1719                 for key in ('report_sxw_content', 'report_rml_content',
1720                         'report_sxw', 'report_rml',
1721                         'report_sxw_content_data', 'report_rml_content_data'):
1722                     if key in x:
1723                         del x[key]
1724                 return x
1725             ir_values_obj = self.pool.get('ir.values')
1726             resprint = ir_values_obj.get(cr, user, 'action',
1727                     'client_print_multi', [(self._name, False)], False,
1728                     context)
1729             resaction = ir_values_obj.get(cr, user, 'action',
1730                     'client_action_multi', [(self._name, False)], False,
1731                     context)
1732
1733             resrelate = ir_values_obj.get(cr, user, 'action',
1734                     'client_action_relate', [(self._name, False)], False,
1735                     context)
1736             resprint = map(clean, resprint)
1737             resaction = map(clean, resaction)
1738             resaction = filter(lambda x: not x.get('multi', False), resaction)
1739             resprint = filter(lambda x: not x.get('multi', False), resprint)
1740             resrelate = map(lambda x: x[2], resrelate)
1741
1742             for x in resprint + resaction + resrelate:
1743                 x['string'] = x['name']
1744
1745             result['toolbar'] = {
1746                 'print': resprint,
1747                 'action': resaction,
1748                 'relate': resrelate
1749             }
1750         return result
1751
1752     _view_look_dom_arch = __view_look_dom_arch
1753
1754     def search_count(self, cr, user, args, context=None):
1755         if not context:
1756             context = {}
1757         res = self.search(cr, user, args, context=context, count=True)
1758         if isinstance(res, list):
1759             return len(res)
1760         return res
1761
1762     def search(self, cr, user, args, offset=0, limit=None, order=None, context=None, count=False):
1763         """
1764         Search for records based on a search domain.
1765
1766         :param cr: database cursor
1767         :param user: current user id
1768         :param args: list of tuples specifying the search domain [('field_name', 'operator', value), ...]. Pass an empty list to match all records.
1769         :param offset: optional number of results to skip in the returned values (default: 0)
1770         :param limit: optional max number of records to return (default: **None**)
1771         :param order: optional columns to sort by (default: self._order=id )
1772         :param context: optional context arguments, like lang, time zone
1773         :type context: dictionary
1774         :param count: optional (default: **False**), if **True**, returns only the number of records matching the criteria, not their ids
1775         :return: id or list of ids of records matching the criteria
1776         :rtype: integer or list of integers
1777         :raise AccessError: * if user tries to bypass access rules for read on the requested object.
1778
1779         **Expressing a search domain (args)**
1780
1781         Each tuple in the search domain needs to have 3 elements, in the form: **('field_name', 'operator', value)**, where:
1782
1783             * **field_name** must be a valid name of field of the object model, possibly following many-to-one relationships using dot-notation, e.g 'street' or 'partner_id.country' are valid values.
1784             * **operator** must be a string with a valid comparison operator from this list: ``=, !=, >, >=, <, <=, like, ilike, in, not in, child_of, parent_left, parent_right``
1785               The semantics of most of these operators are obvious.
1786               The ``child_of`` operator will look for records who are children or grand-children of a given record,
1787               according to the semantics of this model (i.e following the relationship field named by
1788               ``self._parent_name``, by default ``parent_id``.
1789             * **value** must be a valid value to compare with the values of **field_name**, depending on its type.
1790
1791         Domain criteria can be combined using 3 logical operators than can be added between tuples:  '**&**' (logical AND, default), '**|**' (logical OR), '**!**' (logical NOT).
1792         These are **prefix** operators and the arity of the '**&**' and '**|**' operator is 2, while the arity of the '**!**' is just 1.
1793         Be very careful about this when you combine them the first time.
1794
1795         Here is an example of searching for Partners named *ABC* from Belgium and Germany whose language is not english ::
1796
1797             [('name','=','ABC'),'!',('language.code','=','en_US'),'|',('country_id.code','=','be'),('country_id.code','=','de'))
1798
1799         The '&' is omitted as it is the default, and of course we could have used '!=' for the language, but what this domain really represents is::
1800
1801             (name is 'ABC' AND (language is NOT english) AND (country is Belgium OR Germany))
1802
1803         """
1804         return self._search(cr, user, args, offset=offset, limit=limit, order=order, context=context, count=count)
1805
1806     def _search(self, cr, user, args, offset=0, limit=None, order=None, context=None, count=False, access_rights_uid=None):
1807         """
1808         Private implementation of search() method, allowing specifying the uid to use for the access right check.
1809         This is useful for example when filling in the selection list for a drop-down and avoiding access rights errors,
1810         by specifying ``access_rights_uid=1`` to bypass access rights check, but not ir.rules!
1811
1812         :param access_rights_uid: optional user ID to use when checking access rights
1813                                   (not for ir.rules, this is only for ir.model.access)
1814         """
1815         raise NotImplementedError(_('The search method is not implemented on this object !'))
1816
1817     def name_get(self, cr, user, ids, context=None):
1818         """
1819
1820         :param cr: database cursor
1821         :param user: current user id
1822         :type user: integer
1823         :param ids: list of ids
1824         :param context: context arguments, like lang, time zone
1825         :type context: dictionary
1826         :return: tuples with the text representation of requested objects for to-many relationships
1827
1828         """
1829         if not context:
1830             context = {}
1831         if not ids:
1832             return []
1833         if isinstance(ids, (int, long)):
1834             ids = [ids]
1835         return [(r['id'], tools.ustr(r[self._rec_name])) for r in self.read(cr, user, ids,
1836             [self._rec_name], context, load='_classic_write')]
1837
1838     def name_search(self, cr, user, name='', args=None, operator='ilike', context=None, limit=100):
1839         """
1840         Search for records and their display names according to a search domain.
1841
1842         :param cr: database cursor
1843         :param user: current user id
1844         :param name: object name to search
1845         :param args: list of tuples specifying search criteria [('field_name', 'operator', 'value'), ...]
1846         :param operator: operator for search criterion
1847         :param context: context arguments, like lang, time zone
1848         :type context: dictionary
1849         :param limit: optional max number of records to return
1850         :return: list of object names matching the search criteria, used to provide completion for to-many relationships
1851
1852         This method is equivalent of :py:meth:`~osv.osv.osv.search` on **name** + :py:meth:`~osv.osv.osv.name_get` on the result.
1853         See :py:meth:`~osv.osv.osv.search` for an explanation of the possible values for the search domain specified in **args**.
1854
1855         """
1856         return self._name_search(cr, user, name, args, operator, context, limit)
1857
1858     # private implementation of name_search, allows passing a dedicated user for the name_get part to
1859     # solve some access rights issues
1860     def _name_search(self, cr, user, name='', args=None, operator='ilike', context=None, limit=100, name_get_uid=None):
1861         if args is None:
1862             args = []
1863         if context is None:
1864             context = {}
1865         args = args[:]
1866         if name:
1867             args += [(self._rec_name, operator, name)]
1868         access_rights_uid = name_get_uid or user
1869         ids = self._search(cr, user, args, limit=limit, context=context, access_rights_uid=access_rights_uid)
1870         res = self.name_get(cr, access_rights_uid, ids, context)
1871         return res
1872
1873     def copy(self, cr, uid, id, default=None, context=None):
1874         raise NotImplementedError(_('The copy method is not implemented on this object !'))
1875
1876     def exists(self, cr, uid, id, context=None):
1877         raise NotImplementedError(_('The exists method is not implemented on this object !'))
1878
1879     def read_string(self, cr, uid, id, langs, fields=None, context=None):
1880         res = {}
1881         res2 = {}
1882         self.pool.get('ir.model.access').check(cr, uid, 'ir.translation', 'read', context=context)
1883         if not fields:
1884             fields = self._columns.keys() + self._inherit_fields.keys()
1885         #FIXME: collect all calls to _get_source into one SQL call.
1886         for lang in langs:
1887             res[lang] = {'code': lang}
1888             for f in fields:
1889                 if f in self._columns:
1890                     res_trans = self.pool.get('ir.translation')._get_source(cr, uid, self._name+','+f, 'field', lang)
1891                     if res_trans:
1892                         res[lang][f] = res_trans
1893                     else:
1894                         res[lang][f] = self._columns[f].string
1895         for table in self._inherits:
1896             cols = intersect(self._inherit_fields.keys(), fields)
1897             res2 = self.pool.get(table).read_string(cr, uid, id, langs, cols, context)
1898         for lang in res2:
1899             if lang in res:
1900                 res[lang]['code'] = lang
1901             for f in res2[lang]:
1902                 res[lang][f] = res2[lang][f]
1903         return res
1904
1905     def write_string(self, cr, uid, id, langs, vals, context=None):
1906         self.pool.get('ir.model.access').check(cr, uid, 'ir.translation', 'write', context=context)
1907         #FIXME: try to only call the translation in one SQL
1908         for lang in langs:
1909             for field in vals:
1910                 if field in self._columns:
1911                     src = self._columns[field].string
1912                     self.pool.get('ir.translation')._set_ids(cr, uid, self._name+','+field, 'field', lang, [0], vals[field], src)
1913         for table in self._inherits:
1914             cols = intersect(self._inherit_fields.keys(), vals)
1915             if cols:
1916                 self.pool.get(table).write_string(cr, uid, id, langs, vals, context)
1917         return True
1918
1919     def _check_removed_columns(self, cr, log=False):
1920         raise NotImplementedError()
1921
1922     def _add_missing_default_values(self, cr, uid, values, context=None):
1923         missing_defaults = []
1924         avoid_tables = [] # avoid overriding inherited values when parent is set
1925         for tables, parent_field in self._inherits.items():
1926             if parent_field in values:
1927                 avoid_tables.append(tables)
1928         for field in self._columns.keys():
1929             if not field in values:
1930                 missing_defaults.append(field)
1931         for field in self._inherit_fields.keys():
1932             if (field not in values) and (self._inherit_fields[field][0] not in avoid_tables):
1933                 missing_defaults.append(field)
1934
1935         if len(missing_defaults):
1936             # override defaults with the provided values, never allow the other way around
1937             defaults = self.default_get(cr, uid, missing_defaults, context)
1938             for dv in defaults:
1939                 if (dv in self._columns and self._columns[dv]._type == 'many2many') \
1940                      or (dv in self._inherit_fields and self._inherit_fields[dv][2]._type == 'many2many') \
1941                         and defaults[dv] and isinstance(defaults[dv][0], (int, long)):
1942                     defaults[dv] = [(6, 0, defaults[dv])]
1943                 if dv in self._columns and self._columns[dv]._type == 'one2many' \
1944                     or (dv in self._inherit_fields and self._inherit_fields[dv][2]._type == 'one2many') \
1945                         and isinstance(defaults[dv], (list, tuple)) and isinstance(defaults[dv][0], dict):
1946                     defaults[dv] = [(0, 0, x) for x in defaults[dv]]
1947             defaults.update(values)
1948             values = defaults
1949         return values
1950
1951 class orm_memory(orm_template):
1952
1953     _protected = ['read', 'write', 'create', 'default_get', 'perm_read', 'unlink', 'fields_get', 'fields_view_get', 'search', 'name_get', 'distinct_field_get', 'name_search', 'copy', 'import_data', 'search_count', 'exists']
1954     _inherit_fields = {}
1955     _max_count = 200
1956     _max_hours = 1
1957     _check_time = 20
1958
1959     def __init__(self, cr):
1960         super(orm_memory, self).__init__(cr)
1961         self.datas = {}
1962         self.next_id = 0
1963         self.check_id = 0
1964         cr.execute('delete from wkf_instance where res_type=%s', (self._name,))
1965
1966     def _check_access(self, uid, object_id, mode):
1967         if uid != 1 and self.datas[object_id]['internal.create_uid'] != uid:
1968             raise except_orm(_('AccessError'), '%s access is only allowed on your own records for osv_memory objects except for the super-user' % mode.capitalize())
1969
1970     def vaccum(self, cr, uid):
1971         self.check_id += 1
1972         if self.check_id % self._check_time:
1973             return True
1974         tounlink = []
1975         max = time.time() - self._max_hours * 60 * 60
1976         for id in self.datas:
1977             if self.datas[id]['internal.date_access'] < max:
1978                 tounlink.append(id)
1979         self.unlink(cr, 1, tounlink)
1980         if len(self.datas) > self._max_count:
1981             sorted = map(lambda x: (x[1]['internal.date_access'], x[0]), self.datas.items())
1982             sorted.sort()
1983             ids = map(lambda x: x[1], sorted[:len(self.datas)-self._max_count])
1984             self.unlink(cr, uid, ids)
1985         return True
1986
1987     def read(self, cr, user, ids, fields_to_read=None, context=None, load='_classic_read'):
1988         if not context:
1989             context = {}
1990         if not fields_to_read:
1991             fields_to_read = self._columns.keys()
1992         result = []
1993         if self.datas:
1994             ids_orig = ids
1995             if isinstance(ids, (int, long)):
1996                 ids = [ids]
1997             for id in ids:
1998                 r = {'id': id}
1999                 for f in fields_to_read:
2000                     record = self.datas.get(id)
2001                     if record:
2002                         self._check_access(user, id, 'read')
2003                         r[f] = record.get(f, False)
2004                         if r[f] and isinstance(self._columns[f], fields.binary) and context.get('bin_size', False):
2005                             r[f] = len(r[f])
2006                 result.append(r)
2007                 if id in self.datas:
2008                     self.datas[id]['internal.date_access'] = time.time()
2009             fields_post = filter(lambda x: x in self._columns and not getattr(self._columns[x], load), fields_to_read)
2010             for f in fields_post:
2011                 res2 = self._columns[f].get_memory(cr, self, ids, f, user, context=context, values=result)
2012                 for record in result:
2013                     record[f] = res2[record['id']]
2014             if isinstance(ids_orig, (int, long)):
2015                 return result[0]
2016         return result
2017
2018     def write(self, cr, user, ids, vals, context=None):
2019         if not ids:
2020             return True
2021         vals2 = {}
2022         upd_todo = []
2023         for field in vals:
2024             if self._columns[field]._classic_write:
2025                 vals2[field] = vals[field]
2026             else:
2027                 upd_todo.append(field)
2028         for object_id in ids:
2029             self._check_access(user, object_id, mode='write')
2030             self.datas[object_id].update(vals2)
2031             self.datas[object_id]['internal.date_access'] = time.time()
2032             for field in upd_todo:
2033                 self._columns[field].set_memory(cr, self, object_id, field, vals[field], user, context)
2034         self._validate(cr, user, [object_id], context)
2035         wf_service = netsvc.LocalService("workflow")
2036         wf_service.trg_write(user, self._name, object_id, cr)
2037         return object_id
2038
2039     def create(self, cr, user, vals, context=None):
2040         self.vaccum(cr, user)
2041         self.next_id += 1
2042         id_new = self.next_id
2043
2044         vals = self._add_missing_default_values(cr, user, vals, context)
2045
2046         vals2 = {}
2047         upd_todo = []
2048         for field in vals:
2049             if self._columns[field]._classic_write:
2050                 vals2[field] = vals[field]
2051             else:
2052                 upd_todo.append(field)
2053         self.datas[id_new] = vals2
2054         self.datas[id_new]['internal.date_access'] = time.time()
2055         self.datas[id_new]['internal.create_uid'] = user
2056
2057         for field in upd_todo:
2058             self._columns[field].set_memory(cr, self, id_new, field, vals[field], user, context)
2059         self._validate(cr, user, [id_new], context)
2060         if self._log_create and not (context and context.get('no_store_function', False)):
2061             message = self._description + \
2062                 " '" + \
2063                 self.name_get(cr, user, [id_new], context=context)[0][1] + \
2064                 "' "+ _("created.")
2065             self.log(cr, user, id_new, message, True, context=context)
2066         wf_service = netsvc.LocalService("workflow")
2067         wf_service.trg_create(user, self._name, id_new, cr)
2068         return id_new
2069
2070     def _where_calc(self, cr, user, args, active_test=True, context=None):
2071         if not context:
2072             context = {}
2073         args = args[:]
2074         res = []
2075         # if the object has a field named 'active', filter out all inactive
2076         # records unless they were explicitely asked for
2077         if 'active' in self._columns and (active_test and context.get('active_test', True)):
2078             if args:
2079                 active_in_args = False
2080                 for a in args:
2081                     if a[0] == 'active':
2082                         active_in_args = True
2083                 if not active_in_args:
2084                     args.insert(0, ('active', '=', 1))
2085             else:
2086                 args = [('active', '=', 1)]
2087         if args:
2088             import expression
2089             e = expression.expression(args)
2090             e.parse(cr, user, self, context)
2091             res = e.exp
2092         return res or []
2093
2094     def _search(self, cr, user, args, offset=0, limit=None, order=None, context=None, count=False, access_rights_uid=None):
2095         if not context:
2096             context = {}
2097
2098         # implicit filter on current user except for superuser
2099         if user != 1:
2100             if not args:
2101                 args = []
2102             args.insert(0, ('internal.create_uid', '=', user))
2103
2104         result = self._where_calc(cr, user, args, context=context)
2105         if result == []:
2106             return self.datas.keys()
2107
2108         res = []
2109         counter = 0
2110         #Find the value of dict
2111         f = False
2112         if result:
2113             for id, data in self.datas.items():
2114                 counter = counter + 1
2115                 data['id'] = id
2116                 if limit and (counter > int(limit)):
2117                     break
2118                 f = True
2119                 for arg in result:
2120                     if arg[1] == '=':
2121                         val = eval('data[arg[0]]'+'==' +' arg[2]', locals())
2122                     elif arg[1] in ['<', '>', 'in', 'not in', '<=', '>=', '<>']:
2123                         val = eval('data[arg[0]]'+arg[1] +' arg[2]', locals())
2124                     elif arg[1] in ['ilike']:
2125                         val = (str(data[arg[0]]).find(str(arg[2]))!=-1)
2126
2127                     f = f and val
2128
2129                 if f:
2130                     res.append(id)
2131         if count:
2132             return len(res)
2133         return res or []
2134
2135     def unlink(self, cr, uid, ids, context=None):
2136         for id in ids:
2137             self._check_access(uid, id, 'unlink')
2138             self.datas.pop(id, None)
2139         if len(ids):
2140             cr.execute('delete from wkf_instance where res_type=%s and res_id IN %s', (self._name, tuple(ids)))
2141         return True
2142
2143     def perm_read(self, cr, user, ids, context=None, details=True):
2144         result = []
2145         credentials = self.pool.get('res.users').name_get(cr, user, [user])[0]
2146         create_date = time.strftime('%Y-%m-%d %H:%M:%S')
2147         for id in ids:
2148             self._check_access(user, id, 'read')
2149             result.append({
2150                 'create_uid': credentials,
2151                 'create_date': create_date,
2152                 'write_uid': False,
2153                 'write_date': False,
2154                 'id': id,
2155                 'xmlid' : False,
2156             })
2157         return result
2158
2159     def _check_removed_columns(self, cr, log=False):
2160         # nothing to check in memory...
2161         pass
2162
2163     def exists(self, cr, uid, id, context=None):
2164         return id in self.datas
2165
2166 class orm(orm_template):
2167     _sql_constraints = []
2168     _table = None
2169     _protected = ['read', 'write', 'create', 'default_get', 'perm_read', 'unlink', 'fields_get', 'fields_view_get', 'search', 'name_get', 'distinct_field_get', 'name_search', 'copy', 'import_data', 'search_count', 'exists']
2170     __logger = logging.getLogger('orm')
2171     __schema = logging.getLogger('orm.schema')
2172     def read_group(self, cr, uid, domain, fields, groupby, offset=0, limit=None, context=None):
2173         """
2174         Get the list of records in list view grouped by the given ``groupby`` fields
2175
2176         :param cr: database cursor
2177         :param uid: current user id
2178         :param domain: list specifying search criteria [['field_name', 'operator', 'value'], ...]
2179         :param fields: list of fields present in the list view specified on the object
2180         :param groupby: list of fields on which to groupby the records
2181         :type fields_list: list (example ['field_name_1', ...])
2182         :param offset: optional number of records to skip
2183         :param limit: optional max number of records to return
2184         :param context: context arguments, like lang, time zone
2185         :return: list of dictionaries(one dictionary for each record) containing:
2186
2187                     * the values of fields grouped by the fields in ``groupby`` argument
2188                     * __domain: list of tuples specifying the search criteria
2189                     * __context: dictionary with argument like ``groupby``
2190         :rtype: [{'field_name_1': value, ...]
2191         :raise AccessError: * if user has no read rights on the requested object
2192                             * if user tries to bypass access rules for read on the requested object
2193
2194         """
2195         context = context or {}
2196         self.pool.get('ir.model.access').check(cr, uid, self._name, 'read', context=context)
2197         if not fields:
2198             fields = self._columns.keys()
2199
2200         query = self._where_calc(cr, uid, domain, context=context)
2201         self._apply_ir_rules(cr, uid, query, 'read', context=context)
2202
2203         # Take care of adding join(s) if groupby is an '_inherits'ed field
2204         groupby_list = groupby
2205         if groupby:
2206             if isinstance(groupby, list):
2207                 groupby = groupby[0]
2208             self._inherits_join_calc(groupby, query)
2209
2210         assert not groupby or groupby in fields, "Fields in 'groupby' must appear in the list of fields to read (perhaps it's missing in the list view?)"
2211
2212         fget = self.fields_get(cr, uid, fields)
2213         float_int_fields = filter(lambda x: fget[x]['type'] in ('float', 'integer'), fields)
2214         flist = ''
2215         group_by = groupby
2216         if groupby:
2217             if fget.get(groupby):
2218                 if fget[groupby]['type'] in ('date', 'datetime'):
2219                     flist = "to_char(%s,'yyyy-mm') as %s " % (groupby, groupby)
2220                     groupby = "to_char(%s,'yyyy-mm')" % (groupby)
2221                 else:
2222                     flist = groupby
2223             else:
2224                 # Don't allow arbitrary values, as this would be a SQL injection vector!
2225                 raise except_orm(_('Invalid group_by'),
2226                                  _('Invalid group_by specification: "%s".\nA group_by specification must be a list of valid fields.')%(groupby,))
2227
2228
2229         fields_pre = [f for f in float_int_fields if
2230                    f == self.CONCURRENCY_CHECK_FIELD
2231                 or (f in self._columns and getattr(self._columns[f], '_classic_write'))]
2232         for f in fields_pre:
2233             if f not in ['id', 'sequence']:
2234                 group_operator = fget[f].get('group_operator', 'sum')
2235                 if flist:
2236                     flist += ','
2237                 flist += group_operator+'('+f+') as '+f
2238
2239         gb = groupby and (' GROUP BY '+groupby) or ''
2240
2241         from_clause, where_clause, where_clause_params = query.get_sql()
2242         where_clause = where_clause and ' WHERE ' + where_clause
2243         limit_str = limit and ' limit %d' % limit or ''
2244         offset_str = offset and ' offset %d' % offset or ''
2245         cr.execute('SELECT min(%s.id) AS id,' % self._table + flist + ' FROM ' + from_clause + where_clause + gb + limit_str + offset_str, where_clause_params)
2246         alldata = {}
2247         groupby = group_by
2248         for r in cr.dictfetchall():
2249             for fld, val in r.items():
2250                 if val == None: r[fld] = False
2251             alldata[r['id']] = r
2252             del r['id']
2253         if groupby and fget[groupby]['type'] == 'many2one':
2254             data_ids = self.search(cr, uid, [('id', 'in', alldata.keys())], order=groupby, context=context)
2255             # the IDS of the records that has groupby field value = False or ''
2256             # should be added too
2257             data_ids += filter(lambda x:x not in data_ids, alldata.keys())
2258             data = self.read(cr, uid, data_ids, groupby and [groupby] or ['id'], context=context)
2259             # restore order of the search as read() uses the default _order (this is only for groups, so the size of data_read shoud be small):
2260             data.sort(lambda x,y: cmp(data_ids.index(x['id']), data_ids.index(y['id'])))
2261         else:
2262             data = self.read(cr, uid, alldata.keys(), groupby and [groupby] or ['id'], context=context)
2263             if groupby:
2264                 data.sort(lambda x,y:cmp(x[groupby],y[groupby]))
2265         for d in data:
2266             if groupby:
2267                 d['__domain'] = [(groupby, '=', alldata[d['id']][groupby] or False)] + domain
2268                 if not isinstance(groupby_list, (str, unicode)):
2269                     if groupby or not context.get('group_by_no_leaf', False):
2270                         d['__context'] = {'group_by': groupby_list[1:]}
2271             if groupby and groupby in fget:
2272                 if d[groupby] and fget[groupby]['type'] in ('date', 'datetime'):
2273                     dt = datetime.datetime.strptime(alldata[d['id']][groupby][:7], '%Y-%m')
2274                     days = calendar.monthrange(dt.year, dt.month)[1]
2275
2276                     d[groupby] = datetime.datetime.strptime(d[groupby][:10], '%Y-%m-%d').strftime('%B %Y')
2277                     d['__domain'] = [(groupby, '>=', alldata[d['id']][groupby] and datetime.datetime.strptime(alldata[d['id']][groupby][:7] + '-01', '%Y-%m-%d').strftime('%Y-%m-%d') or False),\
2278                                      (groupby, '<=', alldata[d['id']][groupby] and datetime.datetime.strptime(alldata[d['id']][groupby][:7] + '-' + str(days), '%Y-%m-%d').strftime('%Y-%m-%d') or False)] + domain
2279                 del alldata[d['id']][groupby]
2280             d.update(alldata[d['id']])
2281             del d['id']
2282         return data
2283
2284     def _inherits_join_add(self, parent_model_name, query):
2285         """
2286         Add missing table SELECT and JOIN clause to ``query`` for reaching the parent table (no duplicates)
2287
2288         :param parent_model_name: name of the parent model for which the clauses should be added
2289         :param query: query object on which the JOIN should be added
2290         """
2291         inherits_field = self._inherits[parent_model_name]
2292         parent_model = self.pool.get(parent_model_name)
2293         parent_table_name = parent_model._table
2294         quoted_parent_table_name = '"%s"' % parent_table_name
2295         if quoted_parent_table_name not in query.tables:
2296             query.tables.append(quoted_parent_table_name)
2297             query.where_clause.append('("%s".%s = %s.id)' % (self._table, inherits_field, parent_table_name))
2298
2299     def _inherits_join_calc(self, field, query):
2300         """
2301         Adds missing table select and join clause(s) to ``query`` for reaching
2302         the field coming from an '_inherits' parent table (no duplicates).
2303
2304         :param field: name of inherited field to reach
2305         :param query: query object on which the JOIN should be added
2306         :return: qualified name of field, to be used in SELECT clause
2307         """
2308         current_table = self
2309         while field in current_table._inherit_fields and not field in current_table._columns:
2310             parent_model_name = current_table._inherit_fields[field][0]
2311             parent_table = self.pool.get(parent_model_name)
2312             self._inherits_join_add(parent_model_name, query)
2313             current_table = parent_table
2314         return '"%s".%s' % (current_table._table, field)
2315
2316     def _parent_store_compute(self, cr):
2317         if not self._parent_store:
2318             return
2319         logger = netsvc.Logger()
2320         logger.notifyChannel('data', netsvc.LOG_INFO, 'Computing parent left and right for table %s...' % (self._table, ))
2321         def browse_rec(root, pos=0):
2322 # TODO: set order
2323             where = self._parent_name+'='+str(root)
2324             if not root:
2325                 where = self._parent_name+' IS NULL'
2326             if self._parent_order:
2327                 where += ' order by '+self._parent_order
2328             cr.execute('SELECT id FROM '+self._table+' WHERE '+where)
2329             pos2 = pos + 1
2330             childs = cr.fetchall()
2331             for id in childs:
2332                 pos2 = browse_rec(id[0], pos2)
2333             cr.execute('update '+self._table+' set parent_left=%s, parent_right=%s where id=%s', (pos, pos2, root))
2334             return pos2 + 1
2335         query = 'SELECT id FROM '+self._table+' WHERE '+self._parent_name+' IS NULL'
2336         if self._parent_order:
2337             query += ' order by ' + self._parent_order
2338         pos = 0
2339         cr.execute(query)
2340         for (root,) in cr.fetchall():
2341             pos = browse_rec(root, pos)
2342         return True
2343
2344     def _update_store(self, cr, f, k):
2345         logger = netsvc.Logger()
2346         logger.notifyChannel('data', netsvc.LOG_INFO, "storing computed values of fields.function '%s'" % (k,))
2347         ss = self._columns[k]._symbol_set
2348         update_query = 'UPDATE "%s" SET "%s"=%s WHERE id=%%s' % (self._table, k, ss[0])
2349         cr.execute('select id from '+self._table)
2350         ids_lst = map(lambda x: x[0], cr.fetchall())
2351         while ids_lst:
2352             iids = ids_lst[:40]
2353             ids_lst = ids_lst[40:]
2354             res = f.get(cr, self, iids, k, 1, {})
2355             for key, val in res.items():
2356                 if f._multi:
2357                     val = val[k]
2358                 # if val is a many2one, just write the ID
2359                 if type(val) == tuple:
2360                     val = val[0]
2361                 if (val<>False) or (type(val)<>bool):
2362                     cr.execute(update_query, (ss[1](val), key))
2363
2364     def _check_removed_columns(self, cr, log=False):
2365         # iterate on the database columns to drop the NOT NULL constraints
2366         # of fields which were required but have been removed (or will be added by another module)
2367         columns = [c for c in self._columns if not (isinstance(self._columns[c], fields.function) and not self._columns[c].store)]
2368         columns += ('id', 'write_uid', 'write_date', 'create_uid', 'create_date') # openerp access columns
2369         cr.execute("SELECT a.attname, a.attnotnull"
2370                    "  FROM pg_class c, pg_attribute a"
2371                    " WHERE c.relname=%s"
2372                    "   AND c.oid=a.attrelid"
2373                    "   AND a.attisdropped=%s"
2374                    "   AND pg_catalog.format_type(a.atttypid, a.atttypmod) NOT IN ('cid', 'tid', 'oid', 'xid')"
2375                    "   AND a.attname NOT IN %s", (self._table, False, tuple(columns))),
2376
2377         for column in cr.dictfetchall():
2378             if log:
2379                 self.__logger.debug("column %s is in the table %s but not in the corresponding object %s",
2380                                     column['attname'], self._table, self._name)
2381             if column['attnotnull']:
2382                 cr.execute('ALTER TABLE "%s" ALTER COLUMN "%s" DROP NOT NULL' % (self._table, column['attname']))
2383                 self.__schema.debug("Table '%s': column '%s': dropped NOT NULL constraint",
2384                                     self._table, column['attname'])
2385
2386     def _auto_init(self, cr, context={}):
2387         store_compute = False
2388         create = False
2389         todo_end = []
2390         self._field_create(cr, context=context)
2391         if getattr(self, '_auto', True):
2392             cr.execute("SELECT relname FROM pg_class WHERE relkind IN ('r','v') AND relname=%s", (self._table,))
2393             if not cr.rowcount:
2394                 cr.execute('CREATE TABLE "%s" (id SERIAL NOT NULL, PRIMARY KEY(id)) WITHOUT OIDS' % (self._table,))
2395                 cr.execute("COMMENT ON TABLE \"%s\" IS '%s'" % (self._table, self._description.replace("'", "''")))
2396                 create = True
2397
2398                 self.__schema.debug("Table '%s': created", self._table)
2399
2400             cr.commit()
2401             if self._parent_store:
2402                 cr.execute("""SELECT c.relname
2403                     FROM pg_class c, pg_attribute a
2404                     WHERE c.relname=%s AND a.attname=%s AND c.oid=a.attrelid
2405                     """, (self._table, 'parent_left'))
2406                 if not cr.rowcount:
2407                     cr.execute('ALTER TABLE "%s" ADD COLUMN "parent_left" INTEGER' % (self._table,))
2408                     cr.execute('ALTER TABLE "%s" ADD COLUMN "parent_right" INTEGER' % (self._table,))
2409                     if 'parent_left' not in self._columns:
2410                         self.__logger.error('create a column parent_left on object %s: fields.integer(\'Left Parent\', select=1)',
2411                                             self._table)
2412                         self.__schema.debug("Table '%s': added column '%s' with definition=%s",
2413                                             self._table, 'parent_left', 'INTEGER')
2414                     if 'parent_right' not in self._columns:
2415                         self.__logger.error('create a column parent_right on object %s: fields.integer(\'Right Parent\', select=1)',
2416                                             self._table)
2417                         self.__schema.debug("Table '%s': added column '%s' with definition=%s",
2418                                             self._table, 'parent_right', 'INTEGER')
2419                     if self._columns[self._parent_name].ondelete != 'cascade':
2420                         self.__logger.error("The column %s on object %s must be set as ondelete='cascade'",
2421                                             self._parent_name, self._name)
2422
2423                     cr.commit()
2424                     store_compute = True
2425
2426             if self._log_access:
2427                 logs = {
2428                     'create_uid': 'INTEGER REFERENCES res_users ON DELETE SET NULL',
2429                     'create_date': 'TIMESTAMP',
2430                     'write_uid': 'INTEGER REFERENCES res_users ON DELETE SET NULL',
2431                     'write_date': 'TIMESTAMP'
2432                 }
2433                 for k in logs:
2434                     cr.execute("""
2435                         SELECT c.relname
2436                           FROM pg_class c, pg_attribute a
2437                          WHERE c.relname=%s AND a.attname=%s AND c.oid=a.attrelid
2438                         """, (self._table, k))
2439                     if not cr.rowcount:
2440                         cr.execute('ALTER TABLE "%s" ADD COLUMN "%s" %s' % (self._table, k, logs[k]))
2441                         cr.commit()
2442                         self.__schema.debug("Table '%s': added column '%s' with definition=%s",
2443                                             self._table, k, logs[k])
2444
2445             self._check_removed_columns(cr, log=False)
2446
2447             # iterate on the "object columns"
2448             todo_update_store = []
2449             update_custom_fields = context.get('update_custom_fields', False)
2450             for k in self._columns:
2451                 if k in ('id', 'write_uid', 'write_date', 'create_uid', 'create_date'):
2452                     continue
2453                     #raise _('Can not define a column %s. Reserved keyword !') % (k,)
2454                 #Not Updating Custom fields
2455                 if k.startswith('x_') and not update_custom_fields:
2456                     continue
2457                 f = self._columns[k]
2458
2459                 if isinstance(f, fields.one2many):
2460                     cr.execute("SELECT relname FROM pg_class WHERE relkind='r' AND relname=%s", (f._obj,))
2461
2462                     if self.pool.get(f._obj):
2463                         if f._fields_id not in self.pool.get(f._obj)._columns.keys():
2464                             if not self.pool.get(f._obj)._inherits or (f._fields_id not in self.pool.get(f._obj)._inherit_fields.keys()):
2465                                 raise except_orm('Programming Error', ("There is no reference field '%s' found for '%s'") % (f._fields_id, f._obj,))
2466
2467                     if cr.fetchone():
2468                         cr.execute("SELECT count(1) as c FROM pg_class c,pg_attribute a WHERE c.relname=%s AND a.attname=%s AND c.oid=a.attrelid", (f._obj, f._fields_id))
2469                         res = cr.fetchone()[0]
2470                         if not res:
2471                             cr.execute('ALTER TABLE "%s" ADD FOREIGN KEY (%s) REFERENCES "%s" ON DELETE SET NULL' % (self._obj, f._fields_id, f._table))
2472                             self.__schema.debug("Table '%s': added foreign key '%s' with definition=REFERENCES \"%s\" ON DELETE SET NULL",
2473                                 self._obj, f._fields_id, f._table)
2474                 elif isinstance(f, fields.many2many):
2475                     cr.execute("SELECT relname FROM pg_class WHERE relkind IN ('r','v') AND relname=%s", (f._rel,))
2476                     if not cr.dictfetchall():
2477                         if not self.pool.get(f._obj):
2478                             raise except_orm('Programming Error', ('There is no reference available for %s') % (f._obj,))
2479                         ref = self.pool.get(f._obj)._table
2480 #                        ref = f._obj.replace('.', '_')
2481                         cr.execute('CREATE TABLE "%s" ("%s" INTEGER NOT NULL REFERENCES "%s" ON DELETE CASCADE, "%s" INTEGER NOT NULL REFERENCES "%s" ON DELETE CASCADE) WITH OIDS' % (f._rel, f._id1, self._table, f._id2, ref))
2482                         cr.execute('CREATE INDEX "%s_%s_index" ON "%s" ("%s")' % (f._rel, f._id1, f._rel, f._id1))
2483                         cr.execute('CREATE INDEX "%s_%s_index" ON "%s" ("%s")' % (f._rel, f._id2, f._rel, f._id2))
2484                         cr.execute("COMMENT ON TABLE \"%s\" IS 'RELATION BETWEEN %s AND %s'" % (f._rel, self._table, ref))
2485                         cr.commit()
2486                         self.__schema.debug("Create table '%s': relation between '%s' and '%s'",
2487                                             f._rel, self._table, ref)
2488                 else:
2489                     cr.execute("SELECT c.relname,a.attname,a.attlen,a.atttypmod,a.attnotnull,a.atthasdef,t.typname,CASE WHEN a.attlen=-1 THEN a.atttypmod-4 ELSE a.attlen END as size " \
2490                                "FROM pg_class c,pg_attribute a,pg_type t " \
2491                                "WHERE c.relname=%s " \
2492                                "AND a.attname=%s " \
2493                                "AND c.oid=a.attrelid " \
2494                                "AND a.atttypid=t.oid", (self._table, k))
2495                     res = cr.dictfetchall()
2496                     if not res and hasattr(f, 'oldname'):
2497                         cr.execute("SELECT c.relname,a.attname,a.attlen,a.atttypmod,a.attnotnull,a.atthasdef,t.typname,CASE WHEN a.attlen=-1 THEN a.atttypmod-4 ELSE a.attlen END as size " \
2498                             "FROM pg_class c,pg_attribute a,pg_type t " \
2499                             "WHERE c.relname=%s " \
2500                             "AND a.attname=%s " \
2501                             "AND c.oid=a.attrelid " \
2502                             "AND a.atttypid=t.oid", (self._table, f.oldname))
2503                         res_old = cr.dictfetchall()
2504                         if res_old and len(res_old) == 1:
2505                             cr.execute('ALTER TABLE "%s" RENAME "%s" TO "%s"' % (self._table, f.oldname, k))
2506                             res = res_old
2507                             res[0]['attname'] = k
2508                             self.__schema.debug("Table '%s': renamed column '%s' to '%s'",
2509                                                 self._table, f.oldname, k)
2510
2511                     if len(res) == 1:
2512                         f_pg_def = res[0]
2513                         f_pg_type = f_pg_def['typname']
2514                         f_pg_size = f_pg_def['size']
2515                         f_pg_notnull = f_pg_def['attnotnull']
2516                         if isinstance(f, fields.function) and not f.store and\
2517                                 not getattr(f, 'nodrop', False):
2518                             self.__logger.info('column %s (%s) in table %s removed: converted to a function !\n',
2519                                                k, f.string, self._table)
2520                             cr.execute('ALTER TABLE "%s" DROP COLUMN "%s" CASCADE' % (self._table, k))
2521                             cr.commit()
2522                             self.__schema.debug("Table '%s': dropped column '%s' with cascade",
2523                                                  self._table, k)
2524                             f_obj_type = None
2525                         else:
2526                             f_obj_type = get_pg_type(f) and get_pg_type(f)[0]
2527
2528                         if f_obj_type:
2529                             ok = False
2530                             casts = [
2531                                 ('text', 'char', 'VARCHAR(%d)' % (f.size or 0,), '::VARCHAR(%d)'%(f.size or 0,)),
2532                                 ('varchar', 'text', 'TEXT', ''),
2533                                 ('int4', 'float', get_pg_type(f)[1], '::'+get_pg_type(f)[1]),
2534                                 ('date', 'datetime', 'TIMESTAMP', '::TIMESTAMP'),
2535                                 ('timestamp', 'date', 'date', '::date'),
2536                                 ('numeric', 'float', get_pg_type(f)[1], '::'+get_pg_type(f)[1]),
2537                                 ('float8', 'float', get_pg_type(f)[1], '::'+get_pg_type(f)[1]),
2538                             ]
2539                             if f_pg_type == 'varchar' and f._type == 'char' and f_pg_size < f.size:
2540                                 cr.execute('ALTER TABLE "%s" RENAME COLUMN "%s" TO temp_change_size' % (self._table, k))
2541                                 cr.execute('ALTER TABLE "%s" ADD COLUMN "%s" VARCHAR(%d)' % (self._table, k, f.size))
2542                                 cr.execute('UPDATE "%s" SET "%s"=temp_change_size::VARCHAR(%d)' % (self._table, k, f.size))
2543                                 cr.execute('ALTER TABLE "%s" DROP COLUMN temp_change_size CASCADE' % (self._table,))
2544                                 cr.commit()
2545                                 self.__schema.debug("Table '%s': column '%s' (type varchar) changed size from %s to %s",
2546                                     self._table, k, f_pg_size, f.size)
2547                             for c in casts:
2548                                 if (f_pg_type==c[0]) and (f._type==c[1]):
2549                                     if f_pg_type != f_obj_type:
2550                                         ok = True
2551                                         cr.execute('ALTER TABLE "%s" RENAME COLUMN "%s" TO temp_change_size' % (self._table, k))
2552                                         cr.execute('ALTER TABLE "%s" ADD COLUMN "%s" %s' % (self._table, k, c[2]))
2553                                         cr.execute(('UPDATE "%s" SET "%s"=temp_change_size'+c[3]) % (self._table, k))
2554                                         cr.execute('ALTER TABLE "%s" DROP COLUMN temp_change_size CASCADE' % (self._table,))
2555                                         cr.commit()
2556                                         self.__schema.debug("Table '%s': column '%s' changed type from %s to %s",
2557                                             self._table, k, c[0], c[1])
2558                                     break
2559
2560                             if f_pg_type != f_obj_type:
2561                                 if not ok:
2562                                     i = 0
2563                                     while True:
2564                                         newname = self._table + '_moved' + str(i)
2565                                         cr.execute("SELECT count(1) FROM pg_class c,pg_attribute a " \
2566                                             "WHERE c.relname=%s " \
2567                                             "AND a.attname=%s " \
2568                                             "AND c.oid=a.attrelid ", (self._table, newname))
2569                                         if not cr.fetchone()[0]:
2570                                             break
2571                                         i += 1
2572                                     if f_pg_notnull:
2573                                         cr.execute('ALTER TABLE "%s" ALTER COLUMN "%s" DROP NOT NULL' % (self._table, k))
2574                                     cr.execute('ALTER TABLE "%s" RENAME COLUMN "%s" TO "%s"' % (self._table, k, newname))
2575                                     cr.execute('ALTER TABLE "%s" ADD COLUMN "%s" %s' % (self._table, k, get_pg_type(f)[1]))
2576                                     cr.execute("COMMENT ON COLUMN %s.%s IS '%s'" % (self._table, k, f.string.replace("'", "''")))
2577                                     self.__schema.debug("Table '%s': column '%s' has changed type (DB=%s, def=%s), data moved to column %s !",
2578                                         self._table, k, f_pg_type, f._type, newname)
2579
2580                             # if the field is required and hasn't got a NOT NULL constraint
2581                             if f.required and f_pg_notnull == 0:
2582                                 # set the field to the default value if any
2583                                 if k in self._defaults:
2584                                     if callable(self._defaults[k]):
2585                                         default = self._defaults[k](self, cr, 1, context)
2586                                     else:
2587                                         default = self._defaults[k]
2588
2589                                     if (default is not None):
2590                                         ss = self._columns[k]._symbol_set
2591                                         query = 'UPDATE "%s" SET "%s"=%s WHERE "%s" is NULL' % (self._table, k, ss[0], k)
2592                                         cr.execute(query, (ss[1](default),))
2593                                 # add the NOT NULL constraint
2594                                 cr.commit()
2595                                 try:
2596                                     cr.execute('ALTER TABLE "%s" ALTER COLUMN "%s" SET NOT NULL' % (self._table, k))
2597                                     cr.commit()
2598                                     self.__schema.debug("Table '%s': column '%s': added NOT NULL constraint",
2599                                                         self._table, k)
2600                                 except Exception:
2601                                     msg = "Table '%s': unable to set a NOT NULL constraint on column '%s' !\n"\
2602                                         "If you want to have it, you should update the records and execute manually:\n"\
2603                                         "ALTER TABLE %s ALTER COLUMN %s SET NOT NULL"
2604                                     self.__schema.warn(msg, self._table, k, self._table, k)
2605                                 cr.commit()
2606                             elif not f.required and f_pg_notnull == 1:
2607                                 cr.execute('ALTER TABLE "%s" ALTER COLUMN "%s" DROP NOT NULL' % (self._table, k))
2608                                 cr.commit()
2609                                 self.__schema.debug("Table '%s': column '%s': dropped NOT NULL constraint",
2610                                                     self._table, k)
2611                             # Verify index
2612                             indexname = '%s_%s_index' % (self._table, k)
2613                             cr.execute("SELECT indexname FROM pg_indexes WHERE indexname = %s and tablename = %s", (indexname, self._table))
2614                             res2 = cr.dictfetchall()
2615                             if not res2 and f.select:
2616                                 cr.execute('CREATE INDEX "%s_%s_index" ON "%s" ("%s")' % (self._table, k, self._table, k))
2617                                 cr.commit()
2618                                 if f._type == 'text':
2619                                     # FIXME: for fields.text columns we should try creating GIN indexes instead (seems most suitable for an ERP context)
2620                                     msg = "Table '%s': Adding (b-tree) index for text column '%s'."\
2621                                         "This is probably useless (does not work for fulltext search) and prevents INSERTs of long texts"\
2622                                         " because there is a length limit for indexable btree values!\n"\
2623                                         "Use a search view instead if you simply want to make the field searchable."
2624                                     self.__schema.warn(msg, self._table, k, f._type)
2625                             if res2 and not f.select:
2626                                 cr.execute('DROP INDEX "%s_%s_index"' % (self._table, k))
2627                                 cr.commit()
2628                                 msg = "Table '%s': dropping index for column '%s' of type '%s' as it is not required anymore"
2629                                 self.__schema.warn(msg, self._table, k, f._type)
2630
2631                             if isinstance(f, fields.many2one):
2632                                 ref = self.pool.get(f._obj)._table
2633                                 if ref != 'ir_actions':
2634                                     cr.execute('SELECT confdeltype, conname FROM pg_constraint as con, pg_class as cl1, pg_class as cl2, '
2635                                                 'pg_attribute as att1, pg_attribute as att2 '
2636                                             'WHERE con.conrelid = cl1.oid '
2637                                                 'AND cl1.relname = %s '
2638                                                 'AND con.confrelid = cl2.oid '
2639                                                 'AND cl2.relname = %s '
2640                                                 'AND array_lower(con.conkey, 1) = 1 '
2641                                                 'AND con.conkey[1] = att1.attnum '
2642                                                 'AND att1.attrelid = cl1.oid '
2643                                                 'AND att1.attname = %s '
2644                                                 'AND array_lower(con.confkey, 1) = 1 '
2645                                                 'AND con.confkey[1] = att2.attnum '
2646                                                 'AND att2.attrelid = cl2.oid '
2647                                                 'AND att2.attname = %s '
2648                                                 "AND con.contype = 'f'", (self._table, ref, k, 'id'))
2649                                     res2 = cr.dictfetchall()
2650                                     if res2:
2651                                         if res2[0]['confdeltype'] != POSTGRES_CONFDELTYPES.get(f.ondelete.upper(), 'a'):
2652                                             cr.execute('ALTER TABLE "' + self._table + '" DROP CONSTRAINT "' + res2[0]['conname'] + '"')
2653                                             cr.execute('ALTER TABLE "' + self._table + '" ADD FOREIGN KEY ("' + k + '") REFERENCES "' + ref + '" ON DELETE ' + f.ondelete)
2654                                             cr.commit()
2655                                             self.__schema.debug("Table '%s': column '%s': XXX",
2656                                                 self._table, k)
2657                     elif len(res) > 1:
2658                         netsvc.Logger().notifyChannel('orm', netsvc.LOG_ERROR, "Programming error, column %s->%s has multiple instances !" % (self._table, k))
2659                     if not res:
2660                         if not isinstance(f, fields.function) or f.store:
2661                             # add the missing field
2662                             cr.execute('ALTER TABLE "%s" ADD COLUMN "%s" %s' % (self._table, k, get_pg_type(f)[1]))
2663                             cr.execute("COMMENT ON COLUMN %s.%s IS '%s'" % (self._table, k, f.string.replace("'", "''")))
2664                             self.__schema.debug("Table '%s': added column '%s' with definition=%s",
2665                                 self._table, k, get_pg_type(f)[1])
2666
2667                             # initialize it
2668                             if not create and k in self._defaults:
2669                                 if callable(self._defaults[k]):
2670                                     default = self._defaults[k](self, cr, 1, context)
2671                                 else:
2672                                     default = self._defaults[k]
2673
2674                                 ss = self._columns[k]._symbol_set
2675                                 query = 'UPDATE "%s" SET "%s"=%s' % (self._table, k, ss[0])
2676                                 cr.execute(query, (ss[1](default),))
2677                                 cr.commit()
2678                                 netsvc.Logger().notifyChannel('data', netsvc.LOG_DEBUG, "Table '%s': setting default value of new column %s" % (self._table, k))
2679
2680                             if isinstance(f, fields.function):
2681                                 order = 10
2682                                 if f.store is not True:
2683                                     order = f.store[f.store.keys()[0]][2]
2684                                 todo_update_store.append((order, f, k))
2685
2686                             # and add constraints if needed
2687                             if isinstance(f, fields.many2one):
2688                                 if not self.pool.get(f._obj):
2689                                     raise except_orm('Programming Error', ('There is no reference available for %s') % (f._obj,))
2690                                 ref = self.pool.get(f._obj)._table
2691 #                                ref = f._obj.replace('.', '_')
2692                                 # ir_actions is inherited so foreign key doesn't work on it
2693                                 if ref != 'ir_actions':
2694                                     cr.execute('ALTER TABLE "%s" ADD FOREIGN KEY ("%s") REFERENCES "%s" ON DELETE %s' % (self._table, k, ref, f.ondelete))
2695                                     self.__schema.debug("Table '%s': added foreign key '%s' with definition=REFERENCES \"%s\" ON DELETE %s",
2696                                         self._table, k, ref, f.ondelete)
2697                             if f.select:
2698                                 cr.execute('CREATE INDEX "%s_%s_index" ON "%s" ("%s")' % (self._table, k, self._table, k))
2699                             if f.required:
2700                                 try:
2701                                     cr.commit()
2702                                     cr.execute('ALTER TABLE "%s" ALTER COLUMN "%s" SET NOT NULL' % (self._table, k))
2703                                     self.__schema.debug("Table '%s': column '%s': added a NOT NULL constraint",
2704                                         self._table, k)
2705                                 except Exception:
2706                                     msg = "WARNING: unable to set column %s of table %s not null !\n"\
2707                                         "Try to re-run: openerp-server.py --update=module\n"\
2708                                         "If it doesn't work, update records and execute manually:\n"\
2709                                         "ALTER TABLE %s ALTER COLUMN %s SET NOT NULL"
2710                                     self.__logger.warn(msg, k, self._table, self._table, k)
2711                             cr.commit()
2712             for order, f, k in todo_update_store:
2713                 todo_end.append((order, self._update_store, (f, k)))
2714
2715         else:
2716             cr.execute("SELECT relname FROM pg_class WHERE relkind IN ('r','v') AND relname=%s", (self._table,))
2717             create = not bool(cr.fetchone())
2718
2719         cr.commit()     # start a new transaction
2720
2721         for (key, con, _) in self._sql_constraints:
2722             conname = '%s_%s' % (self._table, key)
2723
2724             cr.execute("SELECT conname, pg_catalog.pg_get_constraintdef(oid, true) as condef FROM pg_constraint where conname=%s", (conname,))
2725             existing_constraints = cr.dictfetchall()
2726
2727             sql_actions = {
2728                 'drop': {
2729                     'execute': False,
2730                     'query': 'ALTER TABLE "%s" DROP CONSTRAINT "%s"' % (self._table, conname, ),
2731                     'msg_ok': "Table '%s': dropped constraint '%s'. Reason: its definition changed from '%%s' to '%s'" % (
2732                         self._table, conname, con),
2733                     'msg_err': "Table '%s': unable to drop \'%s\' constraint !" % (self._table, con),
2734                     'order': 1,
2735                 },
2736                 'add': {
2737                     'execute': False,
2738                     'query': 'ALTER TABLE "%s" ADD CONSTRAINT "%s" %s' % (self._table, conname, con,),
2739                     'msg_ok': "Table '%s': added constraint '%s' with definition=%s" % (self._table, conname, con),
2740                     'msg_err': "Table '%s': unable to add \'%s\' constraint !\n If you want to have it, you should update the records and execute manually:\n%%s" % (
2741                         self._table, con),
2742                     'order': 2,
2743                 },
2744             }
2745
2746             if not existing_constraints:
2747                 # constraint does not exists:
2748                 sql_actions['add']['execute'] = True
2749                 sql_actions['add']['msg_err'] = sql_actions['add']['msg_err'] % (sql_actions['add']['query'], )
2750             elif con.lower() not in [item['condef'].lower() for item in existing_constraints]:
2751                 # constraint exists but its definition has changed:
2752                 sql_actions['drop']['execute'] = True
2753                 sql_actions['drop']['msg_ok'] = sql_actions['drop']['msg_ok'] % (existing_constraints[0]['condef'].lower(), )
2754                 sql_actions['add']['execute'] = True
2755                 sql_actions['add']['msg_err'] = sql_actions['add']['msg_err'] % (sql_actions['add']['query'], )
2756
2757             # we need to add the constraint:
2758             sql_actions = [item for item in sql_actions.values()]
2759             sql_actions.sort(key=lambda x: x['order'])
2760             for sql_action in [action for action in sql_actions if action['execute']]:
2761                 try:
2762                     cr.execute(sql_action['query'])
2763                     cr.commit()
2764                     self.__schema.debug(sql_action['msg_ok'])
2765                 except:
2766                     self.__schema.warn(sql_action['msg_err'])
2767                     cr.rollback()
2768
2769         if create:
2770             if hasattr(self, "_sql"):
2771                 for line in self._sql.split(';'):
2772                     line2 = line.replace('\n', '').strip()
2773                     if line2:
2774                         cr.execute(line2)
2775                         cr.commit()
2776         if store_compute:
2777             self._parent_store_compute(cr)
2778             cr.commit()
2779         return todo_end
2780
2781     def __init__(self, cr):
2782         super(orm, self).__init__(cr)
2783
2784         if not hasattr(self, '_log_access'):
2785             # if not access is not specify, it is the same value as _auto
2786             self._log_access = getattr(self, "_auto", True)
2787
2788         self._columns = self._columns.copy()
2789         for store_field in self._columns:
2790             f = self._columns[store_field]
2791             if hasattr(f, 'digits_change'):
2792                 f.digits_change(cr)
2793             if not isinstance(f, fields.function):
2794                 continue
2795             if not f.store:
2796                 continue
2797             if self._columns[store_field].store is True:
2798                 sm = {self._name: (lambda self, cr, uid, ids, c={}: ids, None, 10, None)}
2799             else:
2800                 sm = self._columns[store_field].store
2801             for object, aa in sm.items():
2802                 if len(aa) == 4:
2803                     (fnct, fields2, order, length) = aa
2804                 elif len(aa) == 3:
2805                     (fnct, fields2, order) = aa
2806                     length = None
2807                 else:
2808                     raise except_orm('Error',
2809                         ('Invalid function definition %s in object %s !\nYou must use the definition: store={object:(fnct, fields, priority, time length)}.' % (store_field, self._name)))
2810                 self.pool._store_function.setdefault(object, [])
2811                 ok = True
2812                 for x, y, z, e, f, l in self.pool._store_function[object]:
2813                     if (x==self._name) and (y==store_field) and (e==fields2):
2814                         if f == order:
2815                             ok = False
2816                 if ok:
2817                     self.pool._store_function[object].append( (self._name, store_field, fnct, fields2, order, length))
2818                     self.pool._store_function[object].sort(lambda x, y: cmp(x[4], y[4]))
2819
2820         for (key, _, msg) in self._sql_constraints:
2821             self.pool._sql_error[self._table+'_'+key] = msg
2822
2823         # Load manual fields
2824
2825         cr.execute("SELECT id FROM ir_model_fields WHERE name=%s AND model=%s", ('state', 'ir.model.fields'))
2826         if cr.fetchone():
2827             cr.execute('SELECT * FROM ir_model_fields WHERE model=%s AND state=%s', (self._name, 'manual'))
2828             for field in cr.dictfetchall():
2829                 if field['name'] in self._columns:
2830                     continue
2831                 attrs = {
2832                     'string': field['field_description'],
2833                     'required': bool(field['required']),
2834                     'readonly': bool(field['readonly']),
2835                     'domain': field['domain'] or None,
2836                     'size': field['size'],
2837                     'ondelete': field['on_delete'],
2838                     'translate': (field['translate']),
2839                     #'select': int(field['select_level'])
2840                 }
2841
2842                 if field['ttype'] == 'selection':
2843                     self._columns[field['name']] = getattr(fields, field['ttype'])(eval(field['selection']), **attrs)
2844                 elif field['ttype'] == 'reference':
2845                     self._columns[field['name']] = getattr(fields, field['ttype'])(selection=eval(field['selection']), **attrs)
2846                 elif field['ttype'] == 'many2one':
2847                     self._columns[field['name']] = getattr(fields, field['ttype'])(field['relation'], **attrs)
2848                 elif field['ttype'] == 'one2many':
2849                     self._columns[field['name']] = getattr(fields, field['ttype'])(field['relation'], field['relation_field'], **attrs)
2850                 elif field['ttype'] == 'many2many':
2851                     _rel1 = field['relation'].replace('.', '_')
2852                     _rel2 = field['model'].replace('.', '_')
2853                     _rel_name = 'x_%s_%s_%s_rel' % (_rel1, _rel2, field['name'])
2854                     self._columns[field['name']] = getattr(fields, field['ttype'])(field['relation'], _rel_name, 'id1', 'id2', **attrs)
2855                 else:
2856                     self._columns[field['name']] = getattr(fields, field['ttype'])(**attrs)
2857         self._inherits_check()
2858         self._inherits_reload()
2859         if not self._sequence:
2860             self._sequence = self._table + '_id_seq'
2861         for k in self._defaults:
2862             assert (k in self._columns) or (k in self._inherit_fields), 'Default function defined in %s but field %s does not exist !' % (self._name, k,)
2863         for f in self._columns:
2864             self._columns[f].restart()
2865
2866     #
2867     # Update objects that uses this one to update their _inherits fields
2868     #
2869
2870     def _inherits_reload_src(self):
2871         for obj in self.pool.obj_pool.values():
2872             if self._name in obj._inherits:
2873                 obj._inherits_reload()
2874
2875     def _inherits_reload(self):
2876         res = {}
2877         for table in self._inherits:
2878             res.update(self.pool.get(table)._inherit_fields)
2879             for col in self.pool.get(table)._columns.keys():
2880                 res[col] = (table, self._inherits[table], self.pool.get(table)._columns[col])
2881             for col in self.pool.get(table)._inherit_fields.keys():
2882                 res[col] = (table, self._inherits[table], self.pool.get(table)._inherit_fields[col][2])
2883         self._inherit_fields = res
2884         self._inherits_reload_src()
2885
2886     def _inherits_check(self):
2887         for table, field_name in self._inherits.items():
2888             if field_name not in self._columns:
2889                 logging.getLogger('init').info('Missing many2one field definition for _inherits reference "%s" in "%s", using default one.' % (field_name, self._name))
2890                 self._columns[field_name] = fields.many2one(table, string="Automatically created field to link to parent %s" % table,
2891                                                              required=True, ondelete="cascade")
2892             elif not self._columns[field_name].required or self._columns[field_name].ondelete.lower() != "cascade":
2893                 logging.getLogger('init').warning('Field definition for _inherits reference "%s" in "%s" must be marked as "required" with ondelete="cascade", forcing it.' % (field_name, self._name))
2894                 self._columns[field_name].required = True
2895                 self._columns[field_name].ondelete = "cascade"
2896
2897     #def __getattr__(self, name):
2898     #    """
2899     #    Proxies attribute accesses to the `inherits` parent so we can call methods defined on the inherited parent
2900     #    (though inherits doesn't use Python inheritance).
2901     #    Handles translating between local ids and remote ids.
2902     #    Known issue: doesn't work correctly when using python's own super(), don't involve inherit-based inheritance
2903     #                 when you have inherits.
2904     #    """
2905     #    for model, field in self._inherits.iteritems():
2906     #        proxy = self.pool.get(model)
2907     #        if hasattr(proxy, name):
2908     #            attribute = getattr(proxy, name)
2909     #            if not hasattr(attribute, '__call__'):
2910     #                return attribute
2911     #            break
2912     #    else:
2913     #        return super(orm, self).__getattr__(name)
2914
2915     #    def _proxy(cr, uid, ids, *args, **kwargs):
2916     #        objects = self.browse(cr, uid, ids, kwargs.get('context', None))
2917     #        lst = [obj[field].id for obj in objects if obj[field]]
2918     #        return getattr(proxy, name)(cr, uid, lst, *args, **kwargs)
2919
2920     #    return _proxy
2921
2922
2923     def fields_get(self, cr, user, fields=None, context=None):
2924         """
2925         Get the description of list of fields
2926
2927         :param cr: database cursor
2928         :param user: current user id
2929         :param fields: list of fields
2930         :param context: context arguments, like lang, time zone
2931         :return: dictionary of field dictionaries, each one describing a field of the business object
2932         :raise AccessError: * if user has no create/write rights on the requested object
2933
2934         """
2935         ira = self.pool.get('ir.model.access')
2936         write_access = ira.check(cr, user, self._name, 'write', raise_exception=False, context=context) or \
2937                        ira.check(cr, user, self._name, 'create', raise_exception=False, context=context)
2938         return super(orm, self).fields_get(cr, user, fields, context, write_access)
2939
2940     def read(self, cr, user, ids, fields=None, context=None, load='_classic_read'):
2941         """
2942         Read records with given ids with the given fields
2943
2944         :param cr: database cursor
2945         :param user: current user id
2946         :param ids: id or list of the ids of the records to read
2947         :param fields: optional list of field names to return (default: all fields would be returned)
2948         :type fields: list (example ['field_name_1', ...])
2949         :param context: (optional) context arguments, like lang, time zone
2950         :return: list of dictionaries((dictionary per record asked)) with requested field values
2951         :rtype: [{‘name_of_the_field’: value, ...}, ...]
2952         :raise AccessError: * if user has no read rights on the requested object
2953                             * if user tries to bypass access rules for read on the requested object
2954
2955         """
2956         if not context:
2957             context = {}
2958         self.pool.get('ir.model.access').check(cr, user, self._name, 'read', context=context)
2959         if not fields:
2960             fields = self._columns.keys() + self._inherit_fields.keys()
2961         if isinstance(ids, (int, long)):
2962             select = [ids]
2963         else:
2964             select = ids
2965         select = map(lambda x: isinstance(x, dict) and x['id'] or x, select)
2966         result = self._read_flat(cr, user, select, fields, context, load)
2967
2968         for r in result:
2969             for key, v in r.items():
2970                 if v is None:
2971                     r[key] = False
2972
2973         if isinstance(ids, (int, long, dict)):
2974             return result and result[0] or False
2975         return result
2976
2977     def _read_flat(self, cr, user, ids, fields_to_read, context=None, load='_classic_read'):
2978         if not context:
2979             context = {}
2980         if not ids:
2981             return []
2982         if fields_to_read == None:
2983             fields_to_read = self._columns.keys()
2984
2985         # Construct a clause for the security rules.
2986         # 'tables' hold the list of tables necessary for the SELECT including the ir.rule clauses,
2987         # or will at least contain self._table.
2988         rule_clause, rule_params, tables = self.pool.get('ir.rule').domain_get(cr, user, self._name, 'read', context=context)
2989
2990         # all inherited fields + all non inherited fields for which the attribute whose name is in load is True
2991         fields_pre = [f for f in fields_to_read if
2992                            f == self.CONCURRENCY_CHECK_FIELD
2993                         or (f in self._columns and getattr(self._columns[f], '_classic_write'))
2994                      ] + self._inherits.values()
2995
2996         res = []
2997         if len(fields_pre):
2998             def convert_field(f):
2999                 f_qual = "%s.%s" % (self._table, f) # need fully-qualified references in case len(tables) > 1
3000                 if f in ('create_date', 'write_date'):
3001                     return "date_trunc('second', %s) as %s" % (f_qual, f)
3002                 if f == self.CONCURRENCY_CHECK_FIELD:
3003                     if self._log_access:
3004                         return "COALESCE(%s.write_date, %s.create_date, now())::timestamp AS %s" % (self._table, self._table, f,)
3005                     return "now()::timestamp AS %s" % (f,)
3006                 if isinstance(self._columns[f], fields.binary) and context.get('bin_size', False):
3007                     return 'length(%s) as "%s"' % (f_qual, f)
3008                 return f_qual
3009
3010             fields_pre2 = map(convert_field, fields_pre)
3011             order_by = self._parent_order or self._order
3012             select_fields = ','.join(fields_pre2 + [self._table + '.id'])
3013             query = 'SELECT %s FROM %s WHERE %s.id IN %%s' % (select_fields, ','.join(tables), self._table)
3014             if rule_clause:
3015                 query += " AND " + (' OR '.join(rule_clause))
3016             query += " ORDER BY " + order_by
3017             for sub_ids in cr.split_for_in_conditions(ids):
3018                 if rule_clause:
3019                     cr.execute(query, [tuple(sub_ids)] + rule_params)
3020                     if cr.rowcount != len(sub_ids):
3021                         raise except_orm(_('AccessError'),
3022                                 _('You try to bypass an access rule while reading (Document type: %s).') % self._description)
3023                 else:
3024                     cr.execute(query, (tuple(sub_ids),))
3025                 res.extend(cr.dictfetchall())
3026         else:
3027             res = map(lambda x: {'id': x}, ids)
3028
3029 #        if not res:
3030 #            res = map(lambda x: {'id': x}, ids)
3031 #            for record in res:
3032 #                for f in fields_to_read:
3033 #                    field_val = False
3034 #                    if f in self._columns.keys():
3035 #                        ftype = self._columns[f]._type
3036 #                    elif f in self._inherit_fields.keys():
3037 #                        ftype = self._inherit_fields[f][2]._type
3038 #                    else:
3039 #                        continue
3040 #                    if ftype in ('one2many', 'many2many'):
3041 #                        field_val = []
3042 #                    record.update({f:field_val})
3043
3044         for f in fields_pre:
3045             if f == self.CONCURRENCY_CHECK_FIELD:
3046                 continue
3047             if self._columns[f].translate:
3048                 ids = [x['id'] for x in res]
3049                 #TODO: optimize out of this loop
3050                 res_trans = self.pool.get('ir.translation')._get_ids(cr, user, self._name+','+f, 'model', context.get('lang', False) or 'en_US', ids)
3051                 for r in res:
3052                     r[f] = res_trans.get(r['id'], False) or r[f]
3053
3054         for table in self._inherits:
3055             col = self._inherits[table]
3056             cols = intersect(self._inherit_fields.keys(), set(fields_to_read) - set(self._columns.keys()))
3057             if not cols:
3058                 continue
3059             res2 = self.pool.get(table).read(cr, user, [x[col] for x in res], cols, context, load)
3060
3061             res3 = {}
3062             for r in res2:
3063                 res3[r['id']] = r
3064                 del r['id']
3065
3066             for record in res:
3067                 if not record[col]: # if the record is deleted from _inherits table?
3068                     continue
3069                 record.update(res3[record[col]])
3070                 if col not in fields_to_read:
3071                     del record[col]
3072
3073         # all fields which need to be post-processed by a simple function (symbol_get)
3074         fields_post = filter(lambda x: x in self._columns and self._columns[x]._symbol_get, fields_to_read)
3075         if fields_post:
3076             for r in res:
3077                 for f in fields_post:
3078                     r[f] = self._columns[f]._symbol_get(r[f])
3079         ids = [x['id'] for x in res]
3080
3081         # all non inherited fields for which the attribute whose name is in load is False
3082         fields_post = filter(lambda x: x in self._columns and not getattr(self._columns[x], load), fields_to_read)
3083
3084         # Compute POST fields
3085         todo = {}
3086         for f in fields_post:
3087             todo.setdefault(self._columns[f]._multi, [])
3088             todo[self._columns[f]._multi].append(f)
3089         for key, val in todo.items():
3090             if key:
3091                 res2 = self._columns[val[0]].get(cr, self, ids, val, user, context=context, values=res)
3092                 for pos in val:
3093                     for record in res:
3094                         if isinstance(res2[record['id']], str): res2[record['id']] = eval(res2[record['id']]) #TOCHECK : why got string instend of dict in python2.6
3095                         multi_fields = res2.get(record['id'],{})
3096                         if multi_fields:
3097                             record[pos] = multi_fields.get(pos,[])
3098             else:
3099                 for f in val:
3100                     res2 = self._columns[f].get(cr, self, ids, f, user, context=context, values=res)
3101                     for record in res:
3102                         if res2:
3103                             record[f] = res2[record['id']]
3104                         else:
3105                             record[f] = []
3106         readonly = None
3107         for vals in res:
3108             for field in vals.copy():
3109                 fobj = None
3110                 if field in self._columns:
3111                     fobj = self._columns[field]
3112
3113                 if not fobj:
3114                     continue
3115                 groups = fobj.read
3116                 if groups:
3117                     edit = False
3118                     for group in groups:
3119                         module = group.split(".")[0]
3120                         grp = group.split(".")[1]
3121                         cr.execute("select count(*) from res_groups_users_rel where gid IN (select res_id from ir_model_data where name=%s and module=%s and model=%s) and uid=%s"  \
3122                                    (grp, module, 'res.groups', user))
3123                         readonly = cr.fetchall()
3124                         if readonly[0][0] >= 1:
3125                             edit = True
3126                             break
3127                         elif readonly[0][0] == 0:
3128                             edit = False
3129                         else:
3130                             edit = False
3131
3132                     if not edit:
3133                         if type(vals[field]) == type([]):
3134                             vals[field] = []
3135                         elif type(vals[field]) == type(0.0):
3136                             vals[field] = 0
3137                         elif type(vals[field]) == type(''):
3138                             vals[field] = '=No Permission='
3139                         else:
3140                             vals[field] = False
3141         return res
3142
3143     def perm_read(self, cr, user, ids, context=None, details=True):
3144         """
3145         Returns some metadata about the given records.
3146
3147         :param details: if True, \*_uid fields are replaced with the name of the user
3148         :return: list of ownership dictionaries for each requested record
3149         :rtype: list of dictionaries with the following keys:
3150
3151                     * id: object id
3152                     * create_uid: user who created the record
3153                     * create_date: date when the record was created
3154                     * write_uid: last user who changed the record
3155                     * write_date: date of the last change to the record
3156                     * xmlid: XML ID to use to refer to this record (if there is one), in format ``module.name``
3157         """
3158         if not context:
3159             context = {}
3160         if not ids:
3161             return []
3162         fields = ''
3163         uniq = isinstance(ids, (int, long))
3164         if uniq:
3165             ids = [ids]
3166         fields = ['id']
3167         if self._log_access:
3168             fields += ['create_uid', 'create_date', 'write_uid', 'write_date']
3169         quoted_table = '"%s"' % self._table
3170         fields_str = ",".join('%s.%s'%(quoted_table, field) for field in fields)
3171         query = '''SELECT %s, __imd.module, __imd.name
3172                    FROM %s LEFT JOIN ir_model_data __imd
3173                        ON (__imd.model = %%s and __imd.res_id = %s.id)
3174                    WHERE %s.id IN %%s''' % (fields_str, quoted_table, quoted_table, quoted_table)
3175         cr.execute(query, (self._name, tuple(ids)))
3176         res = cr.dictfetchall()
3177         for r in res:
3178             for key in r:
3179                 r[key] = r[key] or False
3180                 if details and key in ('write_uid', 'create_uid'):
3181                     if r[key]:
3182                         r[key] = self.pool.get('res.users').name_get(cr, user, [r[key]])[0]
3183             r['xmlid'] = ("%(module)s.%(name)s" % r) if r['name'] else False
3184             del r['name'], r['module']
3185         if uniq:
3186             return res[ids[0]]
3187         return res
3188
3189     def _check_concurrency(self, cr, ids, context):
3190         if not context:
3191             return
3192         if not (context.get(self.CONCURRENCY_CHECK_FIELD) and self._log_access):
3193             return
3194         check_clause = "(id = %s AND %s < COALESCE(write_date, create_date, now())::timestamp)"
3195         for sub_ids in cr.split_for_in_conditions(ids):
3196             ids_to_check = []
3197             for id in sub_ids:
3198                 id_ref = "%s,%s" % (self._name, id)
3199                 update_date = context[self.CONCURRENCY_CHECK_FIELD].pop(id_ref, None)
3200                 if update_date:
3201                     ids_to_check.extend([id, update_date])
3202             if not ids_to_check:
3203                 continue
3204             cr.execute("SELECT id FROM %s WHERE %s" % (self._table, " OR ".join([check_clause]*(len(ids_to_check)/2))), tuple(ids_to_check))
3205             res = cr.fetchone()
3206             if res:
3207                 # mention the first one only to keep the error message readable
3208                 raise except_orm('ConcurrencyException', _('A document was modified since you last viewed it (%s:%d)') % (self._description, res[0]))
3209
3210     def check_access_rule(self, cr, uid, ids, operation, context=None):
3211         """Verifies that the operation given by ``operation`` is allowed for the user
3212            according to ir.rules.
3213
3214            :param operation: one of ``write``, ``unlink``
3215            :raise except_orm: * if current ir.rules do not permit this operation.
3216            :return: None if the operation is allowed
3217         """
3218         where_clause, where_params, tables = self.pool.get('ir.rule').domain_get(cr, uid, self._name, operation, context=context)
3219         if where_clause:
3220             where_clause = ' and ' + ' and '.join(where_clause)
3221             for sub_ids in cr.split_for_in_conditions(ids):
3222                 cr.execute('SELECT ' + self._table + '.id FROM ' + ','.join(tables) +
3223                            ' WHERE ' + self._table + '.id IN %s' + where_clause,
3224                            [sub_ids] + where_params)
3225                 if cr.rowcount != len(sub_ids):
3226                     raise except_orm(_('AccessError'),
3227                                      _('Operation prohibited by access rules, or performed on an already deleted document (Operation: %s, Document type: %s).')
3228                                      % (operation, self._name))
3229
3230     def unlink(self, cr, uid, ids, context=None):
3231         """
3232         Delete records with given ids
3233
3234         :param cr: database cursor
3235         :param uid: current user id
3236         :param ids: id or list of ids
3237         :param context: (optional) context arguments, like lang, time zone
3238         :return: True
3239         :raise AccessError: * if user has no unlink rights on the requested object
3240                             * if user tries to bypass access rules for unlink on the requested object
3241         :raise UserError: if the record is default property for other records
3242
3243         """
3244         if not ids:
3245             return True
3246         if isinstance(ids, (int, long)):
3247             ids = [ids]
3248
3249         result_store = self._store_get_values(cr, uid, ids, None, context)
3250
3251         self._check_concurrency(cr, ids, context)
3252
3253         self.pool.get('ir.model.access').check(cr, uid, self._name, 'unlink', context=context)
3254
3255         properties = self.pool.get('ir.property')
3256         domain = [('res_id', '=', False),
3257                   ('value_reference', 'in', ['%s,%s' % (self._name, i) for i in ids]),
3258                  ]
3259         if properties.search(cr, uid, domain, context=context):
3260             raise except_orm(_('Error'), _('Unable to delete this document because it is used as a default property'))
3261
3262         wf_service = netsvc.LocalService("workflow")
3263         for oid in ids:
3264             wf_service.trg_delete(uid, self._name, oid, cr)
3265
3266
3267         self.check_access_rule(cr, uid, ids, 'unlink', context=context)
3268         for sub_ids in cr.split_for_in_conditions(ids):
3269             cr.execute('delete from ' + self._table + ' ' \
3270                        'where id IN %s', (sub_ids,))
3271         for order, object, store_ids, fields in result_store:
3272             if object != self._name:
3273                 obj = self.pool.get(object)
3274                 cr.execute('select id from '+obj._table+' where id IN %s', (tuple(store_ids),))
3275                 rids = map(lambda x: x[0], cr.fetchall())
3276                 if rids:
3277                     obj._store_set_values(cr, uid, rids, fields, context)
3278         return True
3279
3280     #
3281     # TODO: Validate
3282     #
3283     def write(self, cr, user, ids, vals, context=None):
3284         """
3285         Update records with given ids with the given field values
3286
3287         :param cr: database cursor
3288         :param user: current user id
3289         :type user: integer
3290         :param ids: object id or list of object ids to update according to **vals**
3291         :param vals: field values to update, e.g {'field_name': new_field_value, ...}
3292         :type vals: dictionary
3293         :param context: (optional) context arguments, e.g. {'lang': 'en_us', 'tz': 'UTC', ...}
3294         :type context: dictionary
3295         :return: True
3296         :raise AccessError: * if user has no write rights on the requested object
3297                             * if user tries to bypass access rules for write on the requested object
3298         :raise ValidateError: if user tries to enter invalid value for a field that is not in selection
3299         :raise UserError: if a loop would be created in a hierarchy of objects a result of the operation (such as setting an object as its own parent)
3300
3301         **Note**: The type of field values to pass in ``vals`` for relationship fields is specific:
3302
3303             + For a many2many field, a list of tuples is expected.
3304               Here is the list of tuple that are accepted, with the corresponding semantics ::
3305
3306                  (0, 0,  { values })    link to a new record that needs to be created with the given values dictionary
3307                  (1, ID, { values })    update the linked record with id = ID (write *values* on it)
3308                  (2, ID)                remove and delete the linked record with id = ID (calls unlink on ID, that will delete the object completely, and the link to it as well)
3309                  (3, ID)                cut the link to the linked record with id = ID (delete the relationship between the two objects but does not delete the target object itself)
3310                  (4, ID)                link to existing record with id = ID (adds a relationship)
3311                  (5)                    unlink all (like using (3,ID) for all linked records)
3312                  (6, 0, [IDs])          replace the list of linked IDs (like using (5) then (4,ID) for each ID in the list of IDs)
3313
3314                  Example:
3315                     [(6, 0, [8, 5, 6, 4])] sets the many2many to ids [8, 5, 6, 4]
3316
3317             + For a one2many field, a lits of tuples is expected.
3318               Here is the list of tuple that are accepted, with the corresponding semantics ::
3319
3320                  (0, 0,  { values })    link to a new record that needs to be created with the given values dictionary
3321                  (1, ID, { values })    update the linked record with id = ID (write *values* on it)
3322                  (2, ID)                remove and delete the linked record with id = ID (calls unlink on ID, that will delete the object completely, and the link to it as well)
3323
3324                  Example:
3325                     [(0, 0, {'field_name':field_value_record1, ...}), (0, 0, {'field_name':field_value_record2, ...})]
3326
3327             + For a many2one field, simply use the ID of target record, which must already exist, or ``False`` to remove the link.
3328             + For a reference field, use a string with the model name, a comma, and the target object id (example: ``'product.product, 5'``)
3329
3330         """
3331         readonly = None
3332         for field in vals.copy():
3333             fobj = None
3334             if field in self._columns:
3335                 fobj = self._columns[field]
3336             else:
3337                 fobj = self._inherit_fields[field][2]
3338             if not fobj:
3339                 continue
3340             groups = fobj.write
3341
3342             if groups:
3343                 edit = False
3344                 for group in groups:
3345                     module = group.split(".")[0]
3346                     grp = group.split(".")[1]
3347                     cr.execute("select count(*) from res_groups_users_rel where gid IN (select res_id from ir_model_data where name=%s and module=%s and model=%s) and uid=%s", \
3348                                (grp, module, 'res.groups', user))
3349                     readonly = cr.fetchall()
3350                     if readonly[0][0] >= 1:
3351                         edit = True
3352                         break
3353                     elif readonly[0][0] == 0:
3354                         edit = False
3355                     else:
3356                         edit = False
3357
3358                 if not edit:
3359                     vals.pop(field)
3360
3361         if not context:
3362             context = {}
3363         if not ids:
3364             return True
3365         if isinstance(ids, (int, long)):
3366             ids = [ids]
3367
3368         self._check_concurrency(cr, ids, context)
3369         self.pool.get('ir.model.access').check(cr, user, self._name, 'write', context=context)
3370
3371         result = self._store_get_values(cr, user, ids, vals.keys(), context) or []
3372
3373         # No direct update of parent_left/right
3374         vals.pop('parent_left', None)
3375         vals.pop('parent_right', None)
3376
3377         parents_changed = []
3378         if self._parent_store and (self._parent_name in vals):
3379             # The parent_left/right computation may take up to
3380             # 5 seconds. No need to recompute the values if the
3381             # parent is the same. Get the current value of the parent
3382             parent_val = vals[self._parent_name]
3383             if parent_val:
3384                 query = "SELECT id FROM %s WHERE id IN %%s AND (%s != %%s OR %s IS NULL)" % \
3385                                 (self._table, self._parent_name, self._parent_name)
3386                 cr.execute(query, (tuple(ids), parent_val))
3387             else:
3388                 query = "SELECT id FROM %s WHERE id IN %%s AND (%s IS NOT NULL)" % \
3389                                 (self._table, self._parent_name)
3390                 cr.execute(query, (tuple(ids),))
3391             parents_changed = map(operator.itemgetter(0), cr.fetchall())
3392
3393         upd0 = []
3394         upd1 = []
3395         upd_todo = []
3396         updend = []
3397         direct = []
3398         totranslate = context.get('lang', False) and (context['lang'] != 'en_US')
3399         for field in vals:
3400             if field in self._columns:
3401                 if self._columns[field]._classic_write and not (hasattr(self._columns[field], '_fnct_inv')):
3402                     if (not totranslate) or not self._columns[field].translate:
3403                         upd0.append('"'+field+'"='+self._columns[field]._symbol_set[0])
3404                         upd1.append(self._columns[field]._symbol_set[1](vals[field]))
3405                     direct.append(field)
3406                 else:
3407                     upd_todo.append(field)
3408             else:
3409                 updend.append(field)
3410             if field in self._columns \
3411                     and hasattr(self._columns[field], 'selection') \
3412                     and vals[field]:
3413                 if self._columns[field]._type == 'reference':
3414                     val = vals[field].split(',')[0]
3415                 else:
3416                     val = vals[field]
3417                 if isinstance(self._columns[field].selection, (tuple, list)):
3418                     if val not in dict(self._columns[field].selection):
3419                         raise except_orm(_('ValidateError'),
3420                         _('The value "%s" for the field "%s" is not in the selection') \
3421                                 % (vals[field], field))
3422                 else:
3423                     if val not in dict(self._columns[field].selection(
3424                         self, cr, user, context=context)):
3425                         raise except_orm(_('ValidateError'),
3426                         _('The value "%s" for the field "%s" is not in the selection') \
3427                                 % (vals[field], field))
3428
3429         if self._log_access:
3430             upd0.append('write_uid=%s')
3431             upd0.append('write_date=now()')
3432             upd1.append(user)
3433
3434         if len(upd0):
3435             self.check_access_rule(cr, user, ids, 'write', context=context)
3436             for sub_ids in cr.split_for_in_conditions(ids):
3437                 cr.execute('update ' + self._table + ' set ' + ','.join(upd0) + ' ' \
3438                            'where id IN %s', upd1 + [sub_ids])
3439
3440             if totranslate:
3441                 # TODO: optimize
3442                 for f in direct:
3443                     if self._columns[f].translate:
3444                         src_trans = self.pool.get(self._name).read(cr, user, ids, [f])[0][f]
3445                         if not src_trans:
3446                             src_trans = vals[f]
3447                             # Inserting value to DB
3448                             self.write(cr, user, ids, {f: vals[f]})
3449                         self.pool.get('ir.translation')._set_ids(cr, user, self._name+','+f, 'model', context['lang'], ids, vals[f], src_trans)
3450
3451
3452         # call the 'set' method of fields which are not classic_write
3453         upd_todo.sort(lambda x, y: self._columns[x].priority-self._columns[y].priority)
3454
3455         # default element in context must be removed when call a one2many or many2many
3456         rel_context = context.copy()
3457         for c in context.items():
3458             if c[0].startswith('default_'):
3459                 del rel_context[c[0]]
3460
3461         for field in upd_todo:
3462             for id in ids:
3463                 result += self._columns[field].set(cr, self, id, field, vals[field], user, context=rel_context) or []
3464
3465         for table in self._inherits:
3466             col = self._inherits[table]
3467             nids = []
3468             for sub_ids in cr.split_for_in_conditions(ids):
3469                 cr.execute('select distinct "'+col+'" from "'+self._table+'" ' \
3470                            'where id IN %s', (sub_ids,))
3471                 nids.extend([x[0] for x in cr.fetchall()])
3472
3473             v = {}
3474             for val in updend:
3475                 if self._inherit_fields[val][0] == table:
3476                     v[val] = vals[val]
3477             if v:
3478                 self.pool.get(table).write(cr, user, nids, v, context)
3479
3480         self._validate(cr, user, ids, context)
3481
3482         # TODO: use _order to set dest at the right position and not first node of parent
3483         # We can't defer parent_store computation because the stored function
3484         # fields that are computer may refer (directly or indirectly) to
3485         # parent_left/right (via a child_of domain)
3486         if parents_changed:
3487             if self.pool._init:
3488                 self.pool._init_parent[self._name] = True
3489             else:
3490                 order = self._parent_order or self._order
3491                 parent_val = vals[self._parent_name]
3492                 if parent_val:
3493                     clause, params = '%s=%%s' % (self._parent_name,), (parent_val,)
3494                 else:
3495                     clause, params = '%s IS NULL' % (self._parent_name,), ()
3496                 cr.execute('SELECT parent_right, id FROM %s WHERE %s ORDER BY %s' % (self._table, clause, order), params)
3497                 parents = cr.fetchall()
3498
3499                 for id in parents_changed:
3500                     cr.execute('SELECT parent_left, parent_right FROM %s WHERE id=%%s' % (self._table,), (id,))
3501                     pleft, pright = cr.fetchone()
3502                     distance = pright - pleft + 1
3503
3504                     # Find Position of the element
3505                     position = None
3506                     for (parent_pright, parent_id) in parents:
3507                         if parent_id == id:
3508                             break
3509                         position = parent_pright + 1
3510
3511                     # It's the first node of the parent
3512                     if not position:
3513                         if not parent_val:
3514                             position = 1
3515                         else:
3516                             cr.execute('select parent_left from '+self._table+' where id=%s', (parent_val,))
3517                             position = cr.fetchone()[0] + 1
3518
3519                     if pleft < position <= pright:
3520                         raise except_orm(_('UserError'), _('Recursivity Detected.'))
3521
3522                     if pleft < position:
3523                         cr.execute('update '+self._table+' set parent_left=parent_left+%s where parent_left>=%s', (distance, position))
3524                         cr.execute('update '+self._table+' set parent_right=parent_right+%s where parent_right>=%s', (distance, position))
3525                         cr.execute('update '+self._table+' set parent_left=parent_left+%s, parent_right=parent_right+%s where parent_left>=%s and parent_left<%s', (position-pleft, position-pleft, pleft, pright))
3526                     else:
3527                         cr.execute('update '+self._table+' set parent_left=parent_left+%s where parent_left>=%s', (distance, position))
3528                         cr.execute('update '+self._table+' set parent_right=parent_right+%s where parent_right>=%s', (distance, position))
3529                         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))
3530
3531         result += self._store_get_values(cr, user, ids, vals.keys(), context)
3532         result.sort()
3533
3534         done = {}
3535         for order, object, ids, fields in result:
3536             key = (object, tuple(fields))
3537             done.setdefault(key, {})
3538             # avoid to do several times the same computation
3539             todo = []
3540             for id in ids:
3541                 if id not in done[key]:
3542                     done[key][id] = True
3543                     todo.append(id)
3544             self.pool.get(object)._store_set_values(cr, user, todo, fields, context)
3545
3546         wf_service = netsvc.LocalService("workflow")
3547         for id in ids:
3548             wf_service.trg_write(user, self._name, id, cr)
3549         return True
3550
3551     #
3552     # TODO: Should set perm to user.xxx
3553     #
3554     def create(self, cr, user, vals, context=None):
3555         """
3556         Create new record with specified value
3557
3558         :param cr: database cursor
3559         :param user: current user id
3560         :type user: integer
3561         :param vals: field values for new record, e.g {'field_name': field_value, ...}
3562         :type vals: dictionary
3563         :param context: optional context arguments, e.g. {'lang': 'en_us', 'tz': 'UTC', ...}
3564         :type context: dictionary
3565         :return: id of new record created
3566         :raise AccessError: * if user has no create rights on the requested object
3567                             * if user tries to bypass access rules for create on the requested object
3568         :raise ValidateError: if user tries to enter invalid value for a field that is not in selection
3569         :raise UserError: if a loop would be created in a hierarchy of objects a result of the operation (such as setting an object as its own parent)
3570
3571         **Note**: The type of field values to pass in ``vals`` for relationship fields is specific.
3572         Please see the description of the :py:meth:`~osv.osv.osv.write` method for details about the possible values and how
3573         to specify them.
3574
3575         """
3576         if not context:
3577             context = {}
3578         self.pool.get('ir.model.access').check(cr, user, self._name, 'create', context=context)
3579
3580         vals = self._add_missing_default_values(cr, user, vals, context)
3581
3582         tocreate = {}
3583         for v in self._inherits:
3584             if self._inherits[v] not in vals:
3585                 tocreate[v] = {}
3586             else:
3587                 tocreate[v] = {'id': vals[self._inherits[v]]}
3588         (upd0, upd1, upd2) = ('', '', [])
3589         upd_todo = []
3590         for v in vals.keys():
3591             if v in self._inherit_fields:
3592                 (table, col, col_detail) = self._inherit_fields[v]
3593                 tocreate[table][v] = vals[v]
3594                 del vals[v]
3595             else:
3596                 if (v not in self._inherit_fields) and (v not in self._columns):
3597                     del vals[v]
3598
3599         # Try-except added to filter the creation of those records whose filds are readonly.
3600         # Example : any dashboard which has all the fields readonly.(due to Views(database views))
3601         try:
3602             cr.execute("SELECT nextval('"+self._sequence+"')")
3603         except:
3604             raise except_orm(_('UserError'),
3605                         _('You cannot perform this operation. New Record Creation is not allowed for this object as this object is for reporting purpose.'))
3606
3607         id_new = cr.fetchone()[0]
3608         for table in tocreate:
3609             if self._inherits[table] in vals:
3610                 del vals[self._inherits[table]]
3611
3612             record_id = tocreate[table].pop('id', None)
3613
3614             if record_id is None or not record_id:
3615                 record_id = self.pool.get(table).create(cr, user, tocreate[table], context=context)
3616             else:
3617                 self.pool.get(table).write(cr, user, [record_id], tocreate[table], context=context)
3618
3619             upd0 += ',' + self._inherits[table]
3620             upd1 += ',%s'
3621             upd2.append(record_id)
3622
3623         #Start : Set bool fields to be False if they are not touched(to make search more powerful)
3624         bool_fields = [x for x in self._columns.keys() if self._columns[x]._type=='boolean']
3625
3626         for bool_field in bool_fields:
3627             if bool_field not in vals:
3628                 vals[bool_field] = False
3629         #End
3630         for field in vals.copy():
3631             fobj = None
3632             if field in self._columns:
3633                 fobj = self._columns[field]
3634             else:
3635                 fobj = self._inherit_fields[field][2]
3636             if not fobj:
3637                 continue
3638             groups = fobj.write
3639             if groups:
3640                 edit = False
3641                 for group in groups:
3642                     module = group.split(".")[0]
3643                     grp = group.split(".")[1]
3644                     cr.execute("select count(*) from res_groups_users_rel where gid IN (select res_id from ir_model_data where name='%s' and module='%s' and model='%s') and uid=%s" % \
3645                                (grp, module, 'res.groups', user))
3646                     readonly = cr.fetchall()
3647                     if readonly[0][0] >= 1:
3648                         edit = True
3649                         break
3650                     elif readonly[0][0] == 0:
3651                         edit = False
3652                     else:
3653                         edit = False
3654
3655                 if not edit:
3656                     vals.pop(field)
3657         for field in vals:
3658             if self._columns[field]._classic_write:
3659                 upd0 = upd0 + ',"' + field + '"'
3660                 upd1 = upd1 + ',' + self._columns[field]._symbol_set[0]
3661                 upd2.append(self._columns[field]._symbol_set[1](vals[field]))
3662             else:
3663                 if not isinstance(self._columns[field], fields.related):
3664                     upd_todo.append(field)
3665             if field in self._columns \
3666                     and hasattr(self._columns[field], 'selection') \
3667                     and vals[field]:
3668                 if self._columns[field]._type == 'reference':
3669                     val = vals[field].split(',')[0]
3670                 else:
3671                     val = vals[field]
3672                 if isinstance(self._columns[field].selection, (tuple, list)):
3673                     if val not in dict(self._columns[field].selection):
3674                         raise except_orm(_('ValidateError'),
3675                         _('The value "%s" for the field "%s" is not in the selection') \
3676                                 % (vals[field], field))
3677                 else:
3678                     if val not in dict(self._columns[field].selection(
3679                         self, cr, user, context=context)):
3680                         raise except_orm(_('ValidateError'),
3681                         _('The value "%s" for the field "%s" is not in the selection') \
3682                                 % (vals[field], field))
3683         if self._log_access:
3684             upd0 += ',create_uid,create_date'
3685             upd1 += ',%s,now()'
3686             upd2.append(user)
3687         cr.execute('insert into "'+self._table+'" (id'+upd0+") values ("+str(id_new)+upd1+')', tuple(upd2))
3688         self.check_access_rule(cr, user, [id_new], 'create', context=context)
3689         upd_todo.sort(lambda x, y: self._columns[x].priority-self._columns[y].priority)
3690
3691         if self._parent_store and not context.get('defer_parent_store_computation'):
3692             if self.pool._init:
3693                 self.pool._init_parent[self._name] = True
3694             else:
3695                 parent = vals.get(self._parent_name, False)
3696                 if parent:
3697                     cr.execute('select parent_right from '+self._table+' where '+self._parent_name+'=%s order by '+(self._parent_order or self._order), (parent,))
3698                     pleft_old = None
3699                     result_p = cr.fetchall()
3700                     for (pleft,) in result_p:
3701                         if not pleft:
3702                             break
3703                         pleft_old = pleft
3704                     if not pleft_old:
3705                         cr.execute('select parent_left from '+self._table+' where id=%s', (parent,))
3706                         pleft_old = cr.fetchone()[0]
3707                     pleft = pleft_old
3708                 else:
3709                     cr.execute('select max(parent_right) from '+self._table)
3710                     pleft = cr.fetchone()[0] or 0
3711                 cr.execute('update '+self._table+' set parent_left=parent_left+2 where parent_left>%s', (pleft,))
3712                 cr.execute('update '+self._table+' set parent_right=parent_right+2 where parent_right>%s', (pleft,))
3713                 cr.execute('update '+self._table+' set parent_left=%s,parent_right=%s where id=%s', (pleft+1, pleft+2, id_new))
3714
3715         # default element in context must be remove when call a one2many or many2many
3716         rel_context = context.copy()
3717         for c in context.items():
3718             if c[0].startswith('default_'):
3719                 del rel_context[c[0]]
3720
3721         result = []
3722         for field in upd_todo:
3723             result += self._columns[field].set(cr, self, id_new, field, vals[field], user, rel_context) or []
3724         self._validate(cr, user, [id_new], context)
3725
3726         if not context.get('no_store_function', False):
3727             result += self._store_get_values(cr, user, [id_new], vals.keys(), context)
3728             result.sort()
3729             done = []
3730             for order, object, ids, fields2 in result:
3731                 if not (object, ids, fields2) in done:
3732                     self.pool.get(object)._store_set_values(cr, user, ids, fields2, context)
3733                     done.append((object, ids, fields2))
3734
3735         if self._log_create and not (context and context.get('no_store_function', False)):
3736             message = self._description + \
3737                 " '" + \
3738                 self.name_get(cr, user, [id_new], context=context)[0][1] + \
3739                 "' " + _("created.")
3740             self.log(cr, user, id_new, message, True, context=context)
3741         wf_service = netsvc.LocalService("workflow")
3742         wf_service.trg_create(user, self._name, id_new, cr)
3743         return id_new
3744
3745     def _store_get_values(self, cr, uid, ids, fields, context):
3746         result = {}
3747         fncts = self.pool._store_function.get(self._name, [])
3748         for fnct in range(len(fncts)):
3749             if fncts[fnct][3]:
3750                 ok = False
3751                 if not fields:
3752                     ok = True
3753                 for f in (fields or []):
3754                     if f in fncts[fnct][3]:
3755                         ok = True
3756                         break
3757                 if not ok:
3758                     continue
3759
3760             result.setdefault(fncts[fnct][0], {})
3761
3762             # uid == 1 for accessing objects having rules defined on store fields
3763             ids2 = fncts[fnct][2](self, cr, 1, ids, context)
3764             for id in filter(None, ids2):
3765                 result[fncts[fnct][0]].setdefault(id, [])
3766                 result[fncts[fnct][0]][id].append(fnct)
3767         dict = {}
3768         for object in result:
3769             k2 = {}
3770             for id, fnct in result[object].items():
3771                 k2.setdefault(tuple(fnct), [])
3772                 k2[tuple(fnct)].append(id)
3773             for fnct, id in k2.items():
3774                 dict.setdefault(fncts[fnct[0]][4], [])
3775                 dict[fncts[fnct[0]][4]].append((fncts[fnct[0]][4], object, id, map(lambda x: fncts[x][1], fnct)))
3776         result2 = []
3777         tmp = dict.keys()
3778         tmp.sort()
3779         for k in tmp:
3780             result2 += dict[k]
3781         return result2
3782
3783     def _store_set_values(self, cr, uid, ids, fields, context):
3784         if not ids:
3785             return True
3786         field_flag = False
3787         field_dict = {}
3788         if self._log_access:
3789             cr.execute('select id,write_date from '+self._table+' where id IN %s', (tuple(ids),))
3790             res = cr.fetchall()
3791             for r in res:
3792                 if r[1]:
3793                     field_dict.setdefault(r[0], [])
3794                     res_date = time.strptime((r[1])[:19], '%Y-%m-%d %H:%M:%S')
3795                     write_date = datetime.datetime.fromtimestamp(time.mktime(res_date))
3796                     for i in self.pool._store_function.get(self._name, []):
3797                         if i[5]:
3798                             up_write_date = write_date + datetime.timedelta(hours=i[5])
3799                             if datetime.datetime.now() < up_write_date:
3800                                 if i[1] in fields:
3801                                     field_dict[r[0]].append(i[1])
3802                                     if not field_flag:
3803                                         field_flag = True
3804         todo = {}
3805         keys = []
3806         for f in fields:
3807             if self._columns[f]._multi not in keys:
3808                 keys.append(self._columns[f]._multi)
3809             todo.setdefault(self._columns[f]._multi, [])
3810             todo[self._columns[f]._multi].append(f)
3811         for key in keys:
3812             val = todo[key]
3813             if key:
3814                 # uid == 1 for accessing objects having rules defined on store fields
3815                 result = self._columns[val[0]].get(cr, self, ids, val, 1, context=context)
3816                 for id, value in result.items():
3817                     if field_flag:
3818                         for f in value.keys():
3819                             if f in field_dict[id]:
3820                                 value.pop(f)
3821                     upd0 = []
3822                     upd1 = []
3823                     for v in value:
3824                         if v not in val:
3825                             continue
3826                         if self._columns[v]._type in ('many2one', 'one2one'):
3827                             try:
3828                                 value[v] = value[v][0]
3829                             except:
3830                                 pass
3831                         upd0.append('"'+v+'"='+self._columns[v]._symbol_set[0])
3832                         upd1.append(self._columns[v]._symbol_set[1](value[v]))
3833                     upd1.append(id)
3834                     if upd0 and upd1:
3835                         cr.execute('update "' + self._table + '" set ' + \
3836                             ','.join(upd0) + ' where id = %s', upd1)
3837
3838             else:
3839                 for f in val:
3840                     # uid == 1 for accessing objects having rules defined on store fields
3841                     result = self._columns[f].get(cr, self, ids, f, 1, context=context)
3842                     for r in result.keys():
3843                         if field_flag:
3844                             if r in field_dict.keys():
3845                                 if f in field_dict[r]:
3846                                     result.pop(r)
3847                     for id, value in result.items():
3848                         if self._columns[f]._type in ('many2one', 'one2one'):
3849                             try:
3850                                 value = value[0]
3851                             except:
3852                                 pass
3853                         cr.execute('update "' + self._table + '" set ' + \
3854                             '"'+f+'"='+self._columns[f]._symbol_set[0] + ' where id = %s', (self._columns[f]._symbol_set[1](value), id))
3855         return True
3856
3857     #
3858     # TODO: Validate
3859     #
3860     def perm_write(self, cr, user, ids, fields, context=None):
3861         raise NotImplementedError(_('This method does not exist anymore'))
3862
3863     # TODO: ameliorer avec NULL
3864     def _where_calc(self, cr, user, domain, active_test=True, context=None):
3865         """Computes the WHERE clause needed to implement an OpenERP domain.
3866         :param domain: the domain to compute
3867         :type domain: list
3868         :param active_test: whether the default filtering of records with ``active``
3869                             field set to ``False`` should be applied.
3870         :return: the query expressing the given domain as provided in domain
3871         :rtype: osv.query.Query
3872         """
3873         if not context:
3874             context = {}
3875         domain = domain[:]
3876         # if the object has a field named 'active', filter out all inactive
3877         # records unless they were explicitely asked for
3878         if 'active' in self._columns and (active_test and context.get('active_test', True)):
3879             if domain:
3880                 active_in_args = False
3881                 for a in domain:
3882                     if a[0] == 'active':
3883                         active_in_args = True
3884                 if not active_in_args:
3885                     domain.insert(0, ('active', '=', 1))
3886             else:
3887                 domain = [('active', '=', 1)]
3888
3889         if domain:
3890             import expression
3891             e = expression.expression(domain)
3892             e.parse(cr, user, self, context)
3893             tables = e.get_tables()
3894             where_clause, where_params = e.to_sql()
3895             where_clause = where_clause and [where_clause] or []
3896         else:
3897             where_clause, where_params, tables = [], [], ['"%s"' % self._table]
3898
3899         return Query(tables, where_clause, where_params)
3900
3901     def _check_qorder(self, word):
3902         if not regex_order.match(word):
3903             raise except_orm(_('AccessError'), _('Invalid "order" specified. A valid "order" specification is a comma-separated list of valid field names (optionally followed by asc/desc for the direction)'))
3904         return True
3905
3906     def _apply_ir_rules(self, cr, uid, query, mode='read', context=None):
3907         """Add what's missing in ``query`` to implement all appropriate ir.rules
3908           (using the ``model_name``'s rules or the current model's rules if ``model_name`` is None)
3909
3910            :param query: the current query object
3911         """
3912         def apply_rule(added_clause, added_params, added_tables, parent_model=None, child_object=None):
3913             if added_clause:
3914                 if parent_model and child_object:
3915                     # as inherited rules are being applied, we need to add the missing JOIN
3916                     # to reach the parent table (if it was not JOINed yet in the query)
3917                     child_object._inherits_join_add(parent_model, query)
3918                 query.where_clause += added_clause
3919                 query.where_clause_params += added_params
3920                 for table in added_tables:
3921                     if table not in query.tables:
3922                         query.tables.append(table)
3923                 return True
3924             return False
3925
3926         # apply main rules on the object
3927         rule_obj = self.pool.get('ir.rule')
3928         apply_rule(*rule_obj.domain_get(cr, uid, self._name, mode, context=context))
3929
3930         # apply ir.rules from the parents (through _inherits)
3931         for inherited_model in self._inherits:
3932             kwargs = dict(parent_model=inherited_model, child_object=self) #workaround for python2.5
3933             apply_rule(*rule_obj.domain_get(cr, uid, inherited_model, mode, context=context), **kwargs)
3934
3935     def _generate_m2o_order_by(self, order_field, query):
3936         """
3937         Add possibly missing JOIN to ``query`` and generate the ORDER BY clause for m2o fields,
3938         either native m2o fields or function/related fields that are stored, including
3939         intermediate JOINs for inheritance if required.
3940
3941         :return: the qualified field name to use in an ORDER BY clause to sort by ``order_field``
3942         """
3943         if order_field not in self._columns and order_field in self._inherit_fields:
3944             # also add missing joins for reaching the table containing the m2o field
3945             qualified_field = self._inherits_join_calc(order_field, query)
3946             order_field_column = self._inherit_fields[order_field][2]
3947         else:
3948             qualified_field = '"%s"."%s"' % (self._table, order_field)
3949             order_field_column = self._columns[order_field]
3950
3951         assert order_field_column._type == 'many2one', 'Invalid field passed to _generate_m2o_order_by()'
3952         assert order_field_column._classic_write or getattr(order_field_column, 'store', False), "Many2one function/related fields must be stored to be used as ordering fields"
3953
3954         # figure out the applicable order_by for the m2o
3955         dest_model = self.pool.get(order_field_column._obj)
3956         m2o_order = dest_model._order
3957         if not regex_order.match(m2o_order):
3958             # _order is complex, can't use it here, so we default to _rec_name
3959             m2o_order = dest_model._rec_name
3960         else:
3961             # extract the first field name, to be able to qualify it and add desc/asc
3962             m2o_order = m2o_order.split(",",1)[0].strip().split(" ",1)[0]
3963
3964         # Join the dest m2o table if it's not joined yet. We use [LEFT] OUTER join here
3965         # as we don't want to exclude results that have NULL values for the m2o
3966         src_table, src_field = qualified_field.replace('"','').split('.', 1)
3967         query.join((src_table, dest_model._table, src_field, 'id'), outer=True)
3968         return '"%s"."%s"' % (dest_model._table, m2o_order)
3969
3970
3971     def _generate_order_by(self, order_spec, query):
3972         """
3973         Attempt to consruct an appropriate ORDER BY clause based on order_spec, which must be
3974         a comma-separated list of valid field names, optionally followed by an ASC or DESC direction.
3975
3976         :raise" except_orm in case order_spec is malformed
3977         """
3978         order_by_clause = self._order
3979         if order_spec:
3980             order_by_elements = []
3981             self._check_qorder(order_spec)
3982             for order_part in order_spec.split(','):
3983                 order_split = order_part.strip().split(' ')
3984                 order_field = order_split[0].strip()
3985                 order_direction = order_split[1].strip() if len(order_split) == 2 else ''
3986                 if order_field in self._columns:
3987                     order_column = self._columns[order_field]
3988                     if order_column._classic_read:
3989                         order_by_clause = '"%s"."%s"' % (self._table, order_field)
3990                     elif order_column._type == 'many2one':
3991                         order_by_clause = self._generate_m2o_order_by(order_field, query)
3992                     else:
3993                         continue # ignore non-readable or "non-joignable" fields
3994                 elif order_field in self._inherit_fields:
3995                     parent_obj = self.pool.get(self._inherit_fields[order_field][0])
3996                     order_column = parent_obj._columns[order_field]
3997                     if order_column._classic_read:
3998                         order_by_clause = self._inherits_join_calc(order_field, query)
3999                     elif order_column._type == 'many2one':
4000                         order_by_clause = self._generate_m2o_order_by(order_field, query)
4001                     else:
4002                         continue # ignore non-readable or "non-joignable" fields
4003                 order_by_elements.append("%s %s" % (order_by_clause, order_direction))
4004             order_by_clause = ",".join(order_by_elements)
4005
4006         return order_by_clause and (' ORDER BY %s ' % order_by_clause) or ''
4007
4008     def _search(self, cr, user, args, offset=0, limit=None, order=None, context=None, count=False, access_rights_uid=None):
4009         """
4010         Private implementation of search() method, allowing specifying the uid to use for the access right check.
4011         This is useful for example when filling in the selection list for a drop-down and avoiding access rights errors,
4012         by specifying ``access_rights_uid=1`` to bypass access rights check, but not ir.rules!
4013         This is ok at the security level because this method is private and not callable through XML-RPC.
4014
4015         :param access_rights_uid: optional user ID to use when checking access rights
4016                                   (not for ir.rules, this is only for ir.model.access)
4017         """
4018         if context is None:
4019             context = {}
4020         self.pool.get('ir.model.access').check(cr, access_rights_uid or user, self._name, 'read', context=context)
4021
4022         query = self._where_calc(cr, user, args, context=context)
4023         self._apply_ir_rules(cr, user, query, 'read', context=context)
4024         order_by = self._generate_order_by(order, query)
4025         from_clause, where_clause, where_clause_params = query.get_sql()
4026
4027         limit_str = limit and ' limit %d' % limit or ''
4028         offset_str = offset and ' offset %d' % offset or ''
4029         where_str = where_clause and (" WHERE %s" % where_clause) or ''
4030
4031         if count:
4032             cr.execute('SELECT count("%s".id) FROM ' % self._table + from_clause + where_str + limit_str + offset_str, where_clause_params)
4033             res = cr.fetchall()
4034             return res[0][0]
4035         cr.execute('SELECT "%s".id FROM ' % self._table + from_clause + where_str + order_by + limit_str + offset_str, where_clause_params)
4036         res = cr.fetchall()
4037         return [x[0] for x in res]
4038
4039     # returns the different values ever entered for one field
4040     # this is used, for example, in the client when the user hits enter on
4041     # a char field
4042     def distinct_field_get(self, cr, uid, field, value, args=None, offset=0, limit=None):
4043         if not args:
4044             args = []
4045         if field in self._inherit_fields:
4046             return self.pool.get(self._inherit_fields[field][0]).distinct_field_get(cr, uid, field, value, args, offset, limit)
4047         else:
4048             return self._columns[field].search(cr, self, args, field, value, offset, limit, uid)
4049
4050     def copy_data(self, cr, uid, id, default=None, context=None):
4051         """
4052         Copy given record's data with all its fields values
4053
4054         :param cr: database cursor
4055         :param user: current user id
4056         :param id: id of the record to copy
4057         :param default: field values to override in the original values of the copied record
4058         :type default: dictionary
4059         :param context: context arguments, like lang, time zone
4060         :type context: dictionary
4061         :return: dictionary containing all the field values
4062         """
4063
4064         if context is None:
4065             context = {}
4066         if default is None:
4067             default = {}
4068         if 'state' not in default:
4069             if 'state' in self._defaults:
4070                 if callable(self._defaults['state']):
4071                     default['state'] = self._defaults['state'](self, cr, uid, context)
4072                 else:
4073                     default['state'] = self._defaults['state']
4074
4075         context_wo_lang = context
4076         if 'lang' in context:
4077             del context_wo_lang['lang']
4078         data = self.read(cr, uid, [id], context=context_wo_lang)[0]
4079
4080         fields = self.fields_get(cr, uid, context=context)
4081         for f in fields:
4082             ftype = fields[f]['type']
4083
4084             if self._log_access and f in ('create_date', 'create_uid', 'write_date', 'write_uid'):
4085                 del data[f]
4086
4087             if f in default:
4088                 data[f] = default[f]
4089             elif ftype == 'function':
4090                 del data[f]
4091             elif ftype == 'many2one':
4092                 try:
4093                     data[f] = data[f] and data[f][0]
4094                 except:
4095                     pass
4096             elif ftype in ('one2many', 'one2one'):
4097                 res = []
4098                 rel = self.pool.get(fields[f]['relation'])
4099                 if data[f]:
4100                     # duplicate following the order of the ids
4101                     # because we'll rely on it later for copying
4102                     # translations in copy_translation()!
4103                     data[f].sort()
4104                     for rel_id in data[f]:
4105                         # the lines are first duplicated using the wrong (old)
4106                         # parent but then are reassigned to the correct one thanks
4107                         # to the (0, 0, ...)
4108                         d = rel.copy_data(cr, uid, rel_id, context=context)
4109                         res.append((0, 0, d))
4110                 data[f] = res
4111             elif ftype == 'many2many':
4112                 data[f] = [(6, 0, data[f])]
4113
4114         del data['id']
4115
4116         # make sure we don't break the current parent_store structure and
4117         # force a clean recompute!
4118         for parent_column in ['parent_left', 'parent_right']:
4119             data.pop(parent_column, None)
4120
4121         for v in self._inherits:
4122             del data[self._inherits[v]]
4123         return data
4124
4125     def copy_translations(self, cr, uid, old_id, new_id, context=None):
4126         trans_obj = self.pool.get('ir.translation')
4127         fields = self.fields_get(cr, uid, context=context)
4128
4129         translation_records = []
4130         for field_name, field_def in fields.items():
4131             # we must recursively copy the translations for o2o and o2m
4132             if field_def['type'] in ('one2one', 'one2many'):
4133                 target_obj = self.pool.get(field_def['relation'])
4134                 old_record, new_record = self.read(cr, uid, [old_id, new_id], [field_name], context=context)
4135                 # here we rely on the order of the ids to match the translations
4136                 # as foreseen in copy_data()
4137                 old_childs = sorted(old_record[field_name])
4138                 new_childs = sorted(new_record[field_name])
4139                 for (old_child, new_child) in zip(old_childs, new_childs):
4140                     # recursive copy of translations here
4141                     target_obj.copy_translations(cr, uid, old_child, new_child, context=context)
4142             # and for translatable fields we keep them for copy
4143             elif field_def.get('translate'):
4144                 trans_name = ''
4145                 if field_name in self._columns:
4146                     trans_name = self._name + "," + field_name
4147                 elif field_name in self._inherit_fields:
4148                     trans_name = self._inherit_fields[field_name][0] + "," + field_name
4149                 if trans_name:
4150                     trans_ids = trans_obj.search(cr, uid, [
4151                             ('name', '=', trans_name),
4152                             ('res_id', '=', old_id)
4153                     ])
4154                     translation_records.extend(trans_obj.read(cr, uid, trans_ids, context=context))
4155
4156         for record in translation_records:
4157             del record['id']
4158             record['res_id'] = new_id
4159             trans_obj.create(cr, uid, record, context=context)
4160
4161
4162     def copy(self, cr, uid, id, default=None, context=None):
4163         """
4164         Duplicate record with given id updating it with default values
4165
4166         :param cr: database cursor
4167         :param uid: current user id
4168         :param id: id of the record to copy
4169         :param default: dictionary of field values to override in the original values of the copied record, e.g: ``{'field_name': overriden_value, ...}``
4170         :type default: dictionary
4171         :param context: context arguments, like lang, time zone
4172         :type context: dictionary
4173         :return: True
4174
4175         """
4176         data = self.copy_data(cr, uid, id, default, context)
4177         new_id = self.create(cr, uid, data, context)
4178         self.copy_translations(cr, uid, id, new_id, context)
4179         return new_id
4180
4181     def exists(self, cr, uid, ids, context=None):
4182         if type(ids) in (int, long):
4183             ids = [ids]
4184         query = 'SELECT count(1) FROM "%s"' % (self._table)
4185         cr.execute(query + "WHERE ID IN %s", (tuple(ids),))
4186         return cr.fetchone()[0] == len(ids)
4187
4188     def check_recursion(self, cr, uid, ids, parent=None):
4189         """
4190         Verifies that there is no loop in a hierarchical structure of records,
4191         by following the parent relationship using the **parent** field until a loop
4192         is detected or until a top-level record is found.
4193
4194         :param cr: database cursor
4195         :param uid: current user id
4196         :param ids: list of ids of records to check
4197         :param parent: optional parent field name (default: ``self._parent_name = parent_id``)
4198         :return: **True** if the operation can proceed safely, or **False** if an infinite loop is detected.
4199         """
4200
4201         if not parent:
4202             parent = self._parent_name
4203         ids_parent = ids[:]
4204         query = 'SELECT distinct "%s" FROM "%s" WHERE id IN %%s' % (parent, self._table)
4205         while ids_parent:
4206             ids_parent2 = []
4207             for i in range(0, len(ids), cr.IN_MAX):
4208                 sub_ids_parent = ids_parent[i:i+cr.IN_MAX]
4209                 cr.execute(query, (tuple(sub_ids_parent),))
4210                 ids_parent2.extend(filter(None, map(lambda x: x[0], cr.fetchall())))
4211             ids_parent = ids_parent2
4212             for i in ids_parent:
4213                 if i in ids:
4214                     return False
4215         return True
4216
4217     def get_xml_id(self, cr, uid, ids, *args, **kwargs):
4218         """Find out the XML ID of any database record, if there
4219         is one. This method works as a possible implementation
4220         for a function field, to be able to add it to any
4221         model object easily, referencing it as ``osv.osv.get_xml_id``.
4222
4223         **Synopsis**: ``get_xml_id(cr, uid, ids) -> { 'id': 'module.xml_id' }``
4224
4225         :return: the fully qualified XML ID of the given object,
4226                  defaulting to an empty string when there's none
4227                  (to be usable as a function field).
4228         """
4229         result = dict.fromkeys(ids, '')
4230         model_data_obj = self.pool.get('ir.model.data')
4231         data_ids = model_data_obj.search(cr, uid,
4232                 [('model', '=', self._name), ('res_id', 'in', ids)])
4233         data_results = model_data_obj.read(cr, uid, data_ids,
4234                 ['name', 'module', 'res_id'])
4235         for record in data_results:
4236             result[record['res_id']] = '%(module)s.%(name)s' % record
4237         return result
4238
4239 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
4240