← Back to branch summary

~jgrandguillaume-c2c/openobject-addons/multi-company-cost-price

« back to all changes in this revision

Viewing changes to base_module_record/base_module_record.py

  • Committer: Joël Grand-Guillaume
  • Date: 2010-04-08 09:00:10 UTC
  • mfrom: (2533.3.664)
  • Revision ID: joel.grandguillaume@camptocamp.com-20100408090010-c0pqjan341s18bxs
[MRG] Merge from last trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
base_module_record/base_module_record.py
27
27
import string
28
28
import tools
29
29
 
30
 
objects_proxy = netsvc.ExportService.getService('object').__class__
31
 
class recording_objects_proxy(objects_proxy):
 
30
#objects_proxy = netsvc.ExportService.getService('object').__class__
 
31
class recording_objects_proxy(osv_pool):
32
32
    def execute(self, *args, **argv):
33
33
        if len(args) >= 6 and isinstance(args[5], dict):
34
34
            _old_args = args[5].copy()
38
38
        pool = pooler.get_pool(args[0])
39
39
        mod = pool.get('ir.module.record')
40
40
        if mod and mod.recording:
41
 
            if args[4] in ('copy','write','unlink','create'):
 
41
            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'):
42
42
                if _old_args is not None:
43
43
                    args[5].update(_old_args)
44
44
                    if args[5]:
72
72
        e.ownerDocument = xdoc
73
73
        return e
74
74
 
 
75
import yaml
 
76
            
 
77
class record(yaml.YAMLObject):
 
78
    yaml_tag = u'!record'
 
79
    def __init__(self, model, id=None, attrs={}):
 
80
        self.model = model
 
81
        self.id = id
 
82
        self.attrs=attrs
 
83
    def __repr__(self):
 
84
        return '!record {model: %s, id: %s}:' % (str(self.model,), str(self.id,))
 
85
 
 
86
class workflow(yaml.YAMLObject):
 
87
    yaml_tag = u'!workflow'
 
88
    def __init__(self, model, action, ref=None):
 
89
        self.model = model
 
90
        self.ref = ref
 
91
        self.action=action
 
92
    def __repr__(self):
 
93
        return '!workflow {model: %s, action: %s, ref: %s}' % (str(self.model,), str(self.action,), str(self.ref,))
 
94
        
 
95
class ref(yaml.YAMLObject):
 
96
    yaml_tag = u'!ref'
 
97
    def __init__(self, expr="False"):
 
98
        self.expr = expr
 
99
    def __repr__(self):
 
100
        return 'ref(%s)' % (str(self.expr,))
 
101
 
 
102
class eval(yaml.YAMLObject):
 
103
    yaml_tag = u'!eval'
 
104
    def __init__(self, expr="False"):
 
105
        self.expr = expr
 
106
    def __repr__(self):
 
107
        return 'eval(%s)' % (str(self.expr,))
 
108
 
75
109
class base_module_record(osv.osv):
76
110
    _name = "ir.module.record"
77
111
    _columns = {
105
139
        dt = self.pool.get('ir.model.data')
106
140
        dtids = dt.search(cr, uid, [('model','=',model), ('res_id','=',id)])
107
141
        if not dtids:
108
 
            return None, None
 
142
            return False, None
109
143
        obj = dt.browse(cr, uid, dtids[0])
110
144
        self.depends[obj.module] = True
111
145
        return obj.module+'.'+obj.name, obj.noupdate
112
146
 
113
147
    def _create_record(self, cr, uid, doc, model, data, record_id, noupdate=False):
 
148
        
 
149
        data_pool = self.pool.get('ir.model.data')
 
150
        model_pool = self.pool.get(model)
 
151
        
114
152
        record = doc.createElement('record')
115
153
        record.setAttribute("id", record_id)
116
154
        record.setAttribute("model", model)
117
155
        record_list = [record]
118
 
        lids  = self.pool.get('ir.model.data').search(cr, uid, [('model','=',model)])
119
 
        res = self.pool.get('ir.model.data').read(cr, uid, lids[:1], ['module'])
 
156
        lids  = data_pool.search(cr, uid, [('model','=',model)])
 
157
        res = data_pool.read(cr, uid, lids[:1], ['module'])
120
158
        if res:
121
159
            self.depends[res[0]['module']]=True
122
 
        fields = self.pool.get(model).fields_get(cr, uid)
 
160
        fields = model_pool.fields_get(cr, uid)
123
161
        for key,val in data.items():
124
162
            if not (val or (fields[key]['type']=='boolean')):
125
163
                continue
142
180
                    id,update = self._get_id(cr, uid, fields[key]['relation'], val)
143
181
                    noupdate = noupdate or update
144
182
                if not id:
 
183
                    relation_pool = self.pool.get(fields[key]['relation'])
 
184
                    
145
185
                    field.setAttribute("model", fields[key]['relation'])
146
 
                    fld_nm = self.pool.get(fields[key]['relation'])._rec_name
147
 
                    name = self.pool.get(fields[key]['relation']).read(cr, uid, val,[fld_nm])[fld_nm] or False
 
186
                    fld_nm = relation_pool._rec_name
 
187
                    name = relation_pool.read(cr, uid, val,[fld_nm])[fld_nm] or False
148
188
                    field.setAttribute("search", str([(str(fld_nm) ,'=', name)]))
149
189
                else:
150
190
                    field.setAttribute("ref", id)
152
192
            elif fields[key]['type'] in ('one2many',):
153
193
                for valitem in (val or []):
154
194
                    if valitem[0] in (0,1):
155
 
                        if key in self.pool.get(model)._columns:
156
 
                            fname = self.pool.get(model)._columns[key]._fields_id
 
195
                        if key in model_pool._columns:
 
196
                            fname = model_pool._columns[key]._fields_id
157
197
                        else:
158
 
                            fname = self.pool.get(model)._inherit_fields[key][2]._fields_id
 
198
                            fname = model_pool._inherit_fields[key][2]._fields_id
159
199
                        valitem[2][fname] = record_id
160
200
                        newid,update = self._get_id(cr, uid, fields[key]['relation'], valitem[1])
161
201
                        if not newid:
188
228
 
189
229
        return record_list, noupdate
190
230
 
 
231
    def _create_yaml_record(self, cr, uid, model, data, record_id):
 
232
        record={'model': model, 'id': str(record_id)}
 
233
        
 
234
        model_pool = self.pool.get(model)
 
235
        data_pool = self.pool.get('ir.model.data')
 
236
        
 
237
        lids  = data_pool.search(cr, uid, [('model','=',model)])
 
238
        res = data_pool.read(cr, uid, lids[:1], ['module'])
 
239
        attrs={}
 
240
        if res:
 
241
            self.depends[res[0]['module']]=True
 
242
        fields = model_pool.fields_get(cr, uid)
 
243
        defaults={}
 
244
        defaults[model] = model_pool.default_get(cr, uid, data)
 
245
        for key,val in data.items():  
 
246
            if ((key in defaults[model]) and (val ==  defaults[model][key])) and not(fields[key].get('required',False)):
 
247
                continue
 
248
            if not (val or (fields[key]['type']=='boolean')):
 
249
                continue
 
250
            elif fields[key]['type'] in ('boolean',):
 
251
                if not val:
 
252
                    continue
 
253
                attrs[key] = val
 
254
            elif fields[key]['type'] in ('integer','float'):
 
255
                attrs[key] = val
 
256
            elif fields[key]['type'] in ('many2one',):
 
257
                if type(val) in (type(''), type(u'')):
 
258
                    id = val
 
259
                else:
 
260
                    id, update = self._get_id(cr, uid, fields[key]['relation'], val)
 
261
                attrs[key] = str(id)
 
262
            elif fields[key]['type'] in ('one2many',):
 
263
                items=[[]]
 
264
                for valitem in (val or []):
 
265
                    if valitem[0] in (0,1):
 
266
                        if key in model_pool._columns:
 
267
                            fname = model_pool._columns[key]._fields_id
 
268
                        else:
 
269
                            fname = model_pool._inherit_fields[key][2]._fields_id
 
270
                        valitem[2][fname] = record_id
 
271
                        newid,update = self._get_id(cr, uid, fields[key]['relation'], valitem[1])
 
272
                        if not newid:
 
273
                            newid = self._create_id(cr, uid, fields[key]['relation'], valitem[2])
 
274
                        self.ids[(fields[key]['relation'], valitem[1])] = newid
 
275
                        childrecord = self._create_yaml_record(cr, uid, fields[key]['relation'],valitem[2], newid)
 
276
                        items[0].append(childrecord['attrs'])
 
277
                attrs[key] = items
 
278
            elif fields[key]['type'] in ('many2many',):
 
279
                if (key in defaults[model]) and (val[0][2] ==  defaults[model][key]):
 
280
                    continue
 
281
                res = []
 
282
                for valitem in (val or []):
 
283
                    if valitem[0]==6:
 
284
                        for id2 in valitem[2]:
 
285
                            id,update = self._get_id(cr, uid, fields[key]['relation'], id2)
 
286
                            self.ids[(fields[key]['relation'],id2)] = id
 
287
                            res.append(str(id))
 
288
                        m2m=[res]
 
289
                if m2m[0]:
 
290
                    attrs[key] = m2m
 
291
            else:
 
292
                val=val.replace('"','\'')
 
293
                try:
 
294
                    attrs[key]=str(val)
 
295
                except:
 
296
                    attrs[key]=tools.ustr(val)
 
297
        record['attrs'] = attrs
 
298
        return record
 
299
 
191
300
    def get_copy_data(self, cr, uid, model, id, result):
192
301
        res = []
193
302
        obj=self.pool.get(model)
215
324
                    result[key]=data[key][0]
216
325
 
217
326
            elif mod_fields[key]['type'] in ('one2many',):
218
 
                continue # due to this start stop recording will not record one2many field
 
327
#                continue # due to this start stop recording will not record one2many field
219
328
                rel = mod_fields[key]['relation']
220
329
                if len(data[key]):
221
330
                    res1=[]
272
381
                noupdate = noupdate or update
273
382
                record_list += record
274
383
 
275
 
        elif rec[4]=='create':
276
 
            id = self._create_id(cr, uid, rec[3],rec[5])
277
 
            record,noupdate = self._create_record(cr, uid, doc, rec[3], rec[5], id)
 
384
        elif rec[3]=='create':
 
385
            id = self._create_id(cr, uid, rec[2],rec[4])
 
386
            record,noupdate = self._create_record(cr, uid, doc, rec[2], rec[4], id)
278
387
            self.ids[(rec[3], result)] = id
279
388
            record_list += record
280
389
 
281
 
        elif rec[4]=='copy':
282
 
            data=self.get_copy_data(cr,uid,rec[3],rec[5],rec[6])
283
 
            copy_rec=(rec[0],rec[1],rec[2],rec[3],rec[4],rec[5],data,rec[7])
 
390
        elif rec[3]=='copy':
 
391
            data=self.get_copy_data(cr,uid,rec[2],rec[4],rec[5])
 
392
            copy_rec=(rec[0],rec[1],rec[2],rec[3],rec[4],data,rec[5])
284
393
            rec=copy_rec
285
394
            rec_data=[(self.recording_data[0][0],rec,self.recording_data[0][2],self.recording_data[0][3])]
286
395
            self.recording_data=rec_data
287
 
            id = self._create_id(cr, uid, rec[3],rec[6])
288
 
            record,noupdate = self._create_record(cr, uid, doc, rec[3], rec[6], id)
289
 
            self.ids[(rec[3], result)] = id
 
396
            id = self._create_id(cr, uid, rec[2],rec[5])
 
397
            record,noupdate = self._create_record(cr, uid, doc, rec[2], rec[5], id)
 
398
            self.ids[(rec[2], result)] = id
290
399
            record_list += record
291
400
 
292
401
        return record_list,noupdate
293
402
 
 
403
    def _generate_object_yaml(self, cr, uid, rec, result=None):
 
404
        if self.mode=="create":
 
405
            id = self._create_id(cr, uid, rec[2],rec[4])
 
406
            self.ids[(rec[2], result)] = id
 
407
            record = self._create_yaml_record(cr, uid, rec[2], rec[4], id)
 
408
            return record
 
409
        if self.mode=="workflow":
 
410
            id,update = self._get_id(cr, uid, rec[2], rec[4])
 
411
            data = {}
 
412
            data['model'] = rec[2]
 
413
            data['action'] = rec[3]
 
414
            data['ref'] = id
 
415
            return data
 
416
        if self.mode=="write":
 
417
            id,update = self._get_id(cr, uid, rec[2],rec[4][0])
 
418
            record = self._create_yaml_record(cr, uid, rec[2], rec[5], id)
 
419
            return record
 
420
        data=self.get_copy_data(cr,uid,rec[2],rec[4],rec[5])
 
421
        copy_rec=(rec[0],rec[1],rec[2],rec[3],rec[4],data,rec[5])
 
422
        rec=copy_rec
 
423
        rec_data=[(self.recording_data[0][0],rec,self.recording_data[0][2],self.recording_data[0][3])]
 
424
        self.recording_data=rec_data
 
425
        id = self._create_id(cr, uid, rec[2],rec[5])
 
426
        record = self._create_yaml_record(cr, uid, str(rec[2]), rec[5], id)
 
427
        self.ids[(rec[2], result)] = id
 
428
        return record
 
429
 
294
430
    def _generate_assert_xml(self, rec, doc):
295
431
        pass
296
432
 
303
439
            doc.appendChild(terp)
304
440
            for rec in self.recording_data:
305
441
                if rec[0]=='workflow':
306
 
                    rec_id,noupdate = self._get_id(cr, uid, rec[1][3], rec[1][5])
 
442
                    rec_id,noupdate = self._get_id(cr, uid, rec[1][2], rec[1][4])
307
443
                    if not rec_id:
308
444
                        continue
309
445
                    data = doc.createElement("data")
327
463
                elif rec[0]=='assert':
328
464
                        pass
329
465
            return doc.toprettyxml(indent="\t").encode('utf-8')
 
466
 
 
467
    def generate_yaml(self, cr, uid):
 
468
        self.ids = {}
 
469
        if len(self.recording_data):
 
470
            yaml_file='''\n'''
 
471
    
 
472
            for rec in self.recording_data:
 
473
                if rec[1][3] == 'create':
 
474
                    self.mode="create"
 
475
                elif rec[1][3] == 'write':
 
476
                    self.mode="write"
 
477
                elif rec[1][3] == 'copy':
 
478
                    self.mode="copy"
 
479
                elif rec[0] == 'workflow':
 
480
                    self.mode="workflow"
 
481
                else:
 
482
                    continue
 
483
                if self.mode == "workflow":
 
484
                    record= self._generate_object_yaml(cr, uid, rec[1],rec[0])
 
485
                    object=yaml.load(unicode('''\n !workflow %s \n'''%record,'iso-8859-1'))
 
486
                    yaml_file += str(object) + '''\n'''
 
487
                else:
 
488
                    record= self._generate_object_yaml(cr, uid, rec[1],rec[3])
 
489
                    object= yaml.load(unicode('''\n !record %s \n'''%record,'iso-8859-1'))
 
490
                    yaml_file += str(object) + '''\n'''
 
491
                    attrs=yaml.dump(object.attrs, default_flow_style=False)
 
492
                    yaml_file += attrs + '''\n\n'''
 
493
                    
 
494
        yaml_result=''''''
 
495
        for line in yaml_file.split('\n'):
 
496
            line=line.replace("''","'")
 
497
            if line.find('!record') == 0:
 
498
                line = "- \n" + "  " + line
 
499
            elif line.find('!workflow') == 0:
 
500
                line = "- \n" + "  " + line                    
 
501
            elif line.find('- -') != -1:
 
502
                line=line.replace('- -','  -')
 
503
                line = "    " + line
 
504
            else:
 
505
                line = "    " + line
 
506
            yaml_result += line + '''\n'''
 
507
            
 
508
        return yaml_result
 
509
 
330
510
base_module_record()
331
511
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
332
512