addons/base_module_record/base_module_record.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2004-2010 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 from xml.dom import minidom
  23 from osv.osv import osv_pool
  24 from osv import fields,osv
  25 import netsvc
  26 import pooler
  27 import string
  28 import tools
  29
  30 #objects_proxy = netsvc.ExportService.getService('object').__class__
  31 class recording_objects_proxy(osv_pool):
  32     def execute(self, *args, **argv):
  33         if args[3] == 'create':
  34             _old_args = args[4].copy()
  35         elif args[3] == 'write':
  36             _old_args = args[5].copy()
  37         elif len(args) >= 5 and isinstance(args[4], dict):
  38             _old_args = args[4].copy()
  39         elif len(args) > 5 and args[3] != 'write' and isinstance(args[5], dict):
  40             _old_args = args[5].copy()
  41         else:
  42             _old_args = None
  43         res = super(recording_objects_proxy, self).execute(*args, **argv)
  44         pool = pooler.get_pool(args[0])
  45         mod = pool.get('ir.module.record')
  46
  47         if mod and mod.recording:
  48             if args[3] not in ('default_get','read','fields_view_get','fields_get','search','search_count','name_search','name_get','get','request_get', 'get_sc', 'unlink'):
  49                 if _old_args is not None:
  50                     if args[3] != 'write' and args[3] != 'create' and len(args) > 5 and isinstance(args[5], dict):
  51                        args=list(args)
  52                        args[5]=_old_args
  53                        args=tuple(args)
  54                        mod.recording_data.append(('osv_memory_action', args, argv ,None))
  55                     else:
  56                        if args[3] == 'create':
  57                            args[4].update(_old_args)
  58                        elif args[3] == 'write':
  59                            args[5].update(_old_args)
  60                        mod.recording_data.append(('query', args, argv,res))
  61         return res
  62
  63     def exec_workflow(self, *args, **argv):
  64         res = super(recording_objects_proxy, self).exec_workflow(*args, **argv)
  65         pool = pooler.get_pool(args[0])
  66         mod = pool.get('ir.module.record')
  67         if mod and mod.recording:
  68             mod.recording_data.append(('workflow', args, argv))
  69         return res
  70
  71 recording_objects_proxy()
  72
  73 class xElement(minidom.Element):
  74     """dom.Element with compact print
  75     The Element in minidom has a problem: if printed, adds whitespace
  76     around the text nodes. The standard will not ignore that whitespace.
  77     This class simply prints the contained nodes in their compact form, w/o
  78     added spaces.
  79     """
  80     def writexml(self, writer, indent="", addindent="", newl=""):
  81         writer.write(indent)
  82         minidom.Element.writexml(self, writer, indent='', addindent='', newl='')
  83         writer.write(newl)
  84
  85 def doc_createXElement(xdoc, tagName):
  86         e = xElement(tagName)
  87         e.ownerDocument = xdoc
  88         return e
  89
  90 import yaml
  91 from tools import yaml_tag
  92 # Please do not override yaml_tag here: modify it in server bin/tools/yaml_tag.py
  93
  94 class base_module_record(osv.osv):
  95     _name = "ir.module.record"
  96     _columns = {
  97
  98     }
  99     def __init__(self, *args, **kwargs):
 100         self.recording = 0
 101         self.recording_data = []
 102         self.depends = {}
 103         super(base_module_record, self).__init__(*args, **kwargs)
 104
 105     # To Be Improved
 106     def _create_id(self, cr, uid, model, data):
 107         i = 0
 108         while True:
 109             try:
 110                 name = filter(lambda x: x in string.letters, (data.get('name','') or '').lower())
 111             except:
 112                 name=''
 113 #            name=data.get('name','') or ''.lower()
 114             val = model.replace('.','_')+'_'+ name + str(i)
 115             i+=1
 116             if val not in self.ids.values():
 117                 break
 118         return val
 119
 120     def _get_id(self, cr, uid, model, id):
 121         if type(id)==type(()):
 122             id=id[0]
 123         if (model,id) in self.ids:
 124             res_id = self.ids[(model,id)]
 125             return res_id, False
 126         dt = self.pool.get('ir.model.data')
 127         dtids = dt.search(cr, uid, [('model','=',model), ('res_id','=',id)])
 128         if not dtids:
 129             return False, None
 130         obj = dt.browse(cr, uid, dtids[0])
 131         self.depends[obj.module] = True
 132         return obj.module+'.'+obj.name, obj.noupdate
 133
 134     def _create_record(self, cr, uid, doc, model, data, record_id, noupdate=False):
 135         data_pool = self.pool.get('ir.model.data')
 136         model_pool = self.pool.get(model)
 137
 138         record = doc.createElement('record')
 139         record.setAttribute("id", record_id)
 140         record.setAttribute("model", model)
 141         record_list = [record]
 142
 143         lids  = data_pool.search(cr, uid, [('model','=',model)])
 144         res = data_pool.read(cr, uid, lids[:1], ['module'])
 145         if res:
 146             self.depends[res[0]['module']]=True
 147         fields = model_pool.fields_get(cr, uid)
 148         for key,val in data.items():
 149             if not (val or (fields[key]['type']=='boolean')):
 150                 continue
 151             if fields[key]['type'] in ('integer','float'):
 152                 field = doc.createElement('field')
 153                 field.setAttribute("name", key)
 154                 field.setAttribute("eval", val and str(val) or 'False' )
 155                 record.appendChild(field)
 156             elif fields[key]['type'] in ('boolean',):
 157                 field = doc.createElement('field')
 158                 field.setAttribute("name", key)
 159                 field.setAttribute("eval", val and '1' or '0' )
 160                 record.appendChild(field)
 161             elif fields[key]['type'] in ('many2one',):
 162                 field = doc.createElement('field')
 163                 field.setAttribute("name", key)
 164                 if type(val) in (type(''),type(u'')):
 165                     id = val
 166                 else:
 167                     id,update = self._get_id(cr, uid, fields[key]['relation'], val)
 168                     noupdate = noupdate or update
 169                 if not id:
 170                     relation_pool = self.pool.get(fields[key]['relation'])
 171
 172                     field.setAttribute("model", fields[key]['relation'])
 173                     fld_nm = relation_pool._rec_name
 174                     name = relation_pool.read(cr, uid, val,[fld_nm])[fld_nm] or False
 175                     field.setAttribute("search", str([(str(fld_nm) ,'=', name)]))
 176                 else:
 177                     field.setAttribute("ref", id)
 178                 record.appendChild(field)
 179             elif fields[key]['type'] in ('one2many',):
 180                 for valitem in (val or []):
 181                     if valitem[0] in (0,1):
 182                         if key in model_pool._columns:
 183                             fname = model_pool._columns[key]._fields_id
 184                         else:
 185                             fname = model_pool._inherit_fields[key][2]._fields_id
 186                         if valitem[0] == 0:
 187                             newid = self._create_id(cr, uid, fields[key]['relation'], valitem[2])
 188                             valitem[1]=newid
 189                         else:
 190                             newid,update = self._get_id(cr, uid, fields[key]['relation'], valitem[1])
 191                             if not newid:
 192                                 newid = self._create_id(cr, uid, fields[key]['relation'], valitem[2])
 193                                 valitem[1]=newid
 194                         self.ids[(fields[key]['relation'], valitem[1])] = newid
 195
 196                         childrecord, update = self._create_record(cr, uid, doc, fields[key]['relation'],valitem[2], newid)
 197                         noupdate = noupdate or update
 198                         record_list += childrecord
 199                     else:
 200                         pass
 201             elif fields[key]['type'] in ('many2many',):
 202                 res = []
 203                 for valitem in (val or []):
 204                     if valitem[0]==6:
 205                         for id2 in valitem[2]:
 206                             id,update = self._get_id(cr, uid, fields[key]['relation'], id2)
 207                             self.ids[(fields[key]['relation'],id2)] = id
 208                             noupdate = noupdate or update
 209                             res.append(id)
 210                         field = doc.createElement('field')
 211                         field.setAttribute("name", key)
 212                         field.setAttribute("eval", "[(6,0,["+','.join(map(lambda x: "ref('%s')" % (x,), res))+'])]')
 213                         record.appendChild(field)
 214             else:
 215                 field = doc_createXElement(doc, 'field')
 216                 field.setAttribute("name", key)
 217                 field.appendChild(doc.createTextNode(val))
 218                 record.appendChild(field)
 219
 220         return record_list, noupdate
 221
 222     def _create_yaml_record(self, cr, uid, model, data, record_id):
 223         record={'model': model, 'id': str(record_id)}
 224
 225         model_pool = self.pool.get(model)
 226         data_pool = self.pool.get('ir.model.data')
 227         lids  = data_pool.search(cr, uid, [('model','=',model)])
 228
 229         res = data_pool.read(cr, uid, lids[:1], ['module'])
 230         attrs={}
 231         if res:
 232             self.depends[res[0]['module']]=True
 233         fields = model_pool.fields_get(cr, uid)
 234         defaults={}
 235         try:
 236             defaults[model] = model_pool.default_get(cr, uid, data)
 237         except:
 238             defaults[model]={}
 239         for key,val in data.items():
 240             if ((key in defaults[model]) and (val ==  defaults[model][key])) and not(fields[key].get('required',False)):
 241                 continue
 242             if fields[key]['type'] in ('integer','float'):
 243                 if not val:
 244                     val=0.0
 245                 attrs[key] = val
 246             elif not (val or (fields[key]['type']=='function')):
 247                 continue
 248             elif fields[key]['type'] in ('boolean',):
 249                 if not val:
 250                     continue
 251                 attrs[key] = val
 252             elif fields[key]['type'] in ('many2one',):
 253                 if type(val) in (type(''), type(u'')):
 254                     id = val
 255                 else:
 256                     id, update = self._get_id(cr, uid, fields[key]['relation'], val)
 257                 attrs[key] = str(id)
 258             elif fields[key]['type'] in ('one2many',):
 259                 items=[[]]
 260                 for valitem in (val or []):
 261                     if valitem[0] in (0,1):
 262                         if key in model_pool._columns:
 263                             fname = model_pool._columns[key]._fields_id
 264                         else:
 265                             fname = model_pool._inherit_fields[key][2]._fields_id
 266                         del valitem[2][fname] #delete parent_field from child's fields list
 267
 268                         childrecord = self._create_yaml_record(cr, uid, fields[key]['relation'],valitem[2], None)
 269                         items[0].append(childrecord['attrs'])
 270                 attrs[key] = items
 271             elif fields[key]['type'] in ('many2many',):
 272                 if (key in defaults[model]) and (val[0][2] ==  defaults[model][key]):
 273                     continue
 274                 res = []
 275                 for valitem in (val or []):
 276                     if valitem[0]==6:
 277                         for id2 in valitem[2]:
 278                             id,update = self._get_id(cr, uid, fields[key]['relation'], id2)
 279                             self.ids[(fields[key]['relation'],id2)] = id
 280                             res.append(str(id))
 281                         m2m=[res]
 282                 if m2m[0]:
 283                     attrs[key] = m2m
 284             else:
 285                 try:
 286                     attrs[key]=str(val)
 287                 except:
 288                     attrs[key]=tools.ustr(val)
 289                 attrs[key]=attrs[key].replace('"','\'')
 290         record['attrs'] = attrs
 291         return record
 292
 293     def get_copy_data(self, cr, uid, model, id, result):
 294         res = []
 295         obj=self.pool.get(model)
 296         data=obj.read(cr, uid,[id])
 297         if type(data)==type([]):
 298             del data[0]['id']
 299             data=data[0]
 300         else:
 301             del data['id']
 302
 303         mod_fields = obj.fields_get(cr, uid)
 304         for f in filter(lambda a: isinstance(obj._columns[a], fields.function)\
 305                     and (not obj._columns[a].store),obj._columns):
 306             del data[f]
 307
 308         for key,val in data.items():
 309             if result.has_key(key):
 310                 continue
 311             if mod_fields[key]['type'] == 'many2one':
 312                 if type(data[key])==type(True) or type(data[key])==type(1):
 313                     result[key]=data[key]
 314                 elif not data[key]:
 315                     result[key] = False
 316                 else:
 317                     result[key]=data[key][0]
 318
 319             elif mod_fields[key]['type'] in ('one2many',):
 320 #                continue # due to this start stop recording will not record one2many field
 321                 rel = mod_fields[key]['relation']
 322                 if len(data[key]):
 323                     res1=[]
 324                     for rel_id in data[key]:
 325                         res=[0,0]
 326                         res.append(self.get_copy_data(cr, uid,rel,rel_id,{}))
 327                         res1.append(res)
 328                     result[key]=res1
 329                 else:
 330                     result[key]=data[key]
 331
 332             elif mod_fields[key]['type'] == 'many2many':
 333                 result[key]=[(6,0,data[key])]
 334
 335             else:
 336                 result[key]=data[key]
 337         for k,v in obj._inherits.items():
 338             del result[v]
 339         return result
 340
 341     def _create_function(self, cr, uid, doc, model, name, record_id):
 342         record = doc.createElement('function')
 343         record.setAttribute("name", name)
 344         record.setAttribute("model", model)
 345         record_list = [record]
 346
 347         value = doc.createElement('value')
 348         value.setAttribute('eval', '[ref(\'%s\')]' % (record_id, ))
 349         value.setAttribute('model', model)
 350
 351         record.appendChild(value)
 352         return record_list, False
 353
 354     def _generate_object_xml(self, cr, uid, rec, recv, doc, result=None):
 355         record_list = []
 356         noupdate = False
 357         if rec[3]=='write':
 358             for id in rec[4]:
 359                 id,update = self._get_id(cr, uid, rec[2], id)
 360                 noupdate = noupdate or update
 361                 if not id:
 362                     continue
 363                 record,update = self._create_record(cr, uid, doc, rec[2], rec[5], id)
 364                 noupdate = noupdate or update
 365                 record_list += record
 366
 367         elif rec[4] in ('menu_create',):
 368             for id in rec[5]:
 369                 id,update = self._get_id(cr, uid, rec[3], id)
 370                 noupdate = noupdate or update
 371                 if not id:
 372                     continue
 373                 record,update = self._create_function(cr, uid, doc, rec[3], rec[4], id)
 374                 noupdate = noupdate or update
 375                 record_list += record
 376
 377         elif rec[3]=='create':
 378             id = self._create_id(cr, uid, rec[2],rec[4])
 379             record,noupdate = self._create_record(cr, uid, doc, rec[2], rec[4], id)
 380             self.ids[(rec[2], result)] = id
 381             record_list += record
 382
 383         elif rec[3]=='copy':
 384             data=self.get_copy_data(cr,uid,rec[2],rec[4],rec[5])
 385             copy_rec=(rec[0],rec[1],rec[2],rec[3],rec[4],data,rec[5])
 386             rec=copy_rec
 387             rec_data=[(self.recording_data[0][0],rec,self.recording_data[0][2],self.recording_data[0][3])]
 388             self.recording_data=rec_data
 389             id = self._create_id(cr, uid, rec[2],rec[5])
 390             record,noupdate = self._create_record(cr, uid, doc, rec[2], rec[5], id)
 391             self.ids[(rec[2], result)] = id
 392             record_list += record
 393
 394         return record_list,noupdate
 395
 396     def _generate_object_yaml(self, cr, uid, rec, result=None):
 397         if self.mode=="create":
 398             yml_id = self._create_id(cr, uid, rec[2],rec[4])
 399             self.ids[(rec[2], result)] = yml_id
 400             record = self._create_yaml_record(cr, uid, rec[2], rec[4], yml_id)
 401             return record
 402         if self.mode=="workflow":
 403             id,update = self._get_id(cr, uid, rec[2], rec[4])
 404             data = {}
 405             data['model'] = rec[2]
 406             data['action'] = rec[3]
 407             data['ref'] = id
 408             return data
 409         if self.mode=="write":
 410             id,update = self._get_id(cr, uid, rec[2],rec[4][0])
 411             record = self._create_yaml_record(cr, uid, rec[2], rec[5], id)
 412             return record
 413         data=self.get_copy_data(cr,uid,rec[2],rec[4],rec[5])
 414         copy_rec=(rec[0],rec[1],rec[2],rec[3],rec[4],data,rec[5])
 415         rec=copy_rec
 416         rec_data=[(self.recording_data[0][0],rec,self.recording_data[0][2],self.recording_data[0][3])]
 417         self.recording_data=rec_data
 418         id = self._create_id(cr, uid, rec[2],rec[5])
 419         record = self._create_yaml_record(cr, uid, str(rec[2]), rec[5], id)
 420         self.ids[(rec[2], result)] = id
 421         return record
 422
 423     def _generate_function_yaml(self, cr, uid, args):
 424         db, uid, model, action, ids, context = args
 425         temp_context = context.copy()
 426         active_id = temp_context['active_id']
 427         active_model = temp_context['active_model']
 428         active_id, update = self._get_id(cr, uid, active_model, active_id)
 429         if not active_id:
 430             active_id = 1
 431         rec_id, noupdate = self._get_id(cr, uid, model, ids[0])
 432         temp_context['active_id'] = "ref('%s')"%unicode(active_id)
 433         temp_context['active_ids'][0] = "ref('%s')"%str(active_id)
 434         function={}
 435         function['model'] = model
 436         function['action'] = action
 437         attrs = "self.%s(cr, uid, [ref('%s')], {" %(action, rec_id, )
 438         for k, v in temp_context.iteritems():
 439             if isinstance(v, str):
 440                 f= "'"+k+"': "+"'%s'"%v + ", "
 441             else:
 442                 v=str(v).replace('"', '')
 443                 f= "'"+k+"': "+"%s"%v + ", "
 444             attrs = attrs + f
 445         attrs=str(attrs)+'})'
 446         function['attrs'] = attrs
 447         return function
 448
 449     def _generate_assert_xml(self, rec, doc):
 450         pass
 451
 452     def generate_xml(self, cr, uid):
 453         # Create the minidom document
 454         if len(self.recording_data):
 455             self.ids = {}
 456             doc = minidom.Document()
 457             terp = doc.createElement("openerp")
 458             doc.appendChild(terp)
 459             for rec in self.recording_data:
 460                 if rec[0]=='workflow':
 461                     rec_id,noupdate = self._get_id(cr, uid, rec[1][2], rec[1][4])
 462                     if not rec_id:
 463                         continue
 464                     data = doc.createElement("data")
 465                     terp.appendChild(data)
 466                     wkf = doc.createElement('workflow')
 467                     data.appendChild(wkf)
 468                     wkf.setAttribute("model", rec[1][2])
 469                     wkf.setAttribute("action", rec[1][3])
 470                     if noupdate:
 471                         data.setAttribute("noupdate", "1")
 472                     wkf.setAttribute("ref", rec_id)
 473                 if rec[0]=='query':
 474                     res_list,noupdate = self._generate_object_xml(cr, uid, rec[1], rec[2], doc, rec[3])
 475                     data = doc.createElement("data")
 476                     if noupdate:
 477                         data.setAttribute("noupdate", "1")
 478                     if res_list:
 479                         terp.appendChild(data)
 480                     for res in res_list:
 481                         data.appendChild(res)
 482                 elif rec[0]=='assert':
 483                         pass
 484             return doc.toprettyxml(indent="\t").encode('utf-8')
 485
 486     def generate_yaml(self, cr, uid):
 487         self.ids = {}
 488         if len(self.recording_data):
 489             yaml_file='''\n'''
 490
 491             for rec in self.recording_data:
 492                 if rec[1][3] == 'create':
 493                     self.mode="create"
 494                 elif rec[1][3] == 'write':
 495                     self.mode="write"
 496                 elif rec[1][3] == 'copy':
 497                     self.mode="copy"
 498                 elif rec[0] == 'workflow':
 499                     self.mode="workflow"
 500                 elif rec[0] == 'osv_memory_action':
 501                     self.mode='osv_memory_action'
 502                 else:
 503                     continue
 504                 if self.mode == "workflow":
 505                     record = self._generate_object_yaml(cr, uid, rec[1],rec[0])
 506                     yaml_file += "!comment Performing a workflow action %s on module %s"%(record['action'], record['model']) + '''\n'''
 507                     object = yaml.load(unicode('''\n !workflow %s \n'''%record,'iso-8859-1'))
 508                     yaml_file += str(object) + '''\n\n'''
 509                 elif self.mode == 'osv_memory_action':
 510                     osv_action = self._generate_function_yaml(cr, uid, rec[1])
 511                     yaml_file += "!comment Performing an osv_memory action %s on module %s"%(osv_action['action'], osv_action['model']) + '''\n'''
 512                     osv_action = yaml.load(unicode('''\n !python %s \n'''%osv_action,'iso-8859-1'))
 513                     yaml_file += str(osv_action) + '''\n'''
 514                     attrs = yaml.dump(osv_action.attrs, default_flow_style=False)
 515                     attrs = attrs.replace("''", '"')
 516                     attrs = attrs.replace("'", '')
 517                     yaml_file += attrs + '''\n\n'''
 518                 else:
 519                     record = self._generate_object_yaml(cr, uid, rec[1], rec[3])
 520                     if self.mode == "create" or self.mode == "copy":
 521                         yaml_file += "!comment Creating a %s record"%(record['model']) + '''\n'''
 522                     else:
 523                         yaml_file += "!comment Modifying a %s record"%(record['model']) + '''\n'''
 524                     object = yaml.load(unicode('''\n !record %s \n'''%record,'iso-8859-1'))
 525                     yaml_file += str(object) + '''\n'''
 526                     attrs = yaml.dump(object.attrs, default_flow_style=False)
 527                     yaml_file += attrs + '''\n\n'''
 528
 529         yaml_result=''''''
 530         for line in yaml_file.split('\n'):
 531             line=line.replace("''","'")
 532             if (line.find('!record') == 0) or (line.find('!workflow') == 0) or (line.find('!python') == 0):
 533                 line = "- \n" + "  " + line
 534             elif line.find('!comment') == 0:
 535                 line=line.replace('!comment','- \n ')
 536             elif line.find('- -') != -1:
 537                 line=line.replace('- -','  -')
 538                 line = "    " + line
 539             else:
 540                 line = "    " + line
 541             yaml_result += line + '''\n'''
 542
 543         return yaml_result
 544
 545 base_module_record()
 546 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
 547