~jfb-tempo-consulting/unifield-addons/ref_addons

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'):

if _old_args is not None:

if args[3] != 'write' and args[3] != 'create' and len(args) > 5 and isinstance(args[5], dict):

args=list(args)

args[5]=_old_args

args=tuple(args)

mod.recording_data.append(('osv_memory_action', args, argv ,None))

else:

if args[3] == 'create':

args[4].update(_old_args)

elif args[3] == 'write':

args[5].update(_old_args)

mod.recording_data.append(('query', args, argv,res))

return res

def exec_workflow(self, *args, **argv):

res = super(recording_objects_proxy, self).exec_workflow(*args, **argv)

pool = pooler.get_pool(args[0])

mod = pool.get('ir.module.record')

if mod and mod.recording:

mod.recording_data.append(('workflow', args, argv))

return res

recording_objects_proxy()

class xElement(minidom.Element):

"""dom.Element with compact print

The Element in minidom has a problem: if printed, adds whitespace

around the text nodes. The standard will not ignore that whitespace.

This class simply prints the contained nodes in their compact form, w/o

added spaces.

"""

def writexml(self, writer, indent="", addindent="", newl=""):

writer.write(indent)

minidom.Element.writexml(self, writer, indent='', addindent='', newl='')

writer.write(newl)

def doc_createXElement(xdoc, tagName):

e = xElement(tagName)

e.ownerDocument = xdoc

return e

import yaml

from tools import yaml_tag # This import is not unused! Do not remove!

# Please do not override yaml_tag here: modify it in server bin/tools/yaml_tag.py

class base_module_record(osv.osv):

_name = "ir.module.record"

_columns = {

}

def __init__(self, *args, **kwargs):

self.recording = 0

self.recording_data = []

100

self.depends = {}

101

super(base_module_record, self).__init__(*args, **kwargs)

102

103

# To Be Improved

104

def _create_id(self, cr, uid, model, data):

105

i = 0

106

while True:

107

try:

108

name = filter(lambda x: x in string.letters, (data.get('name','') or '').lower())

109

except:

110

name=''

111

# name=data.get('name','') or ''.lower()

112

val = model.replace('.','_')+'_'+ name + str(i)

113

i+=1

114

if val not in self.ids.values():

115

break

116

return val

117

118

def _get_id(self, cr, uid, model, id):

119

if type(id)==type(()):

120

id=id[0]

121

if (model,id) in self.ids:

122

res_id = self.ids[(model,id)]

123

return res_id, False

124

dt = self.pool.get('ir.model.data')

125

dtids = dt.search(cr, uid, [('model','=',model), ('res_id','=',id)])

126

if not dtids:

127

return False, None

128

obj = dt.browse(cr, uid, dtids[0])

129

self.depends[obj.module] = True

130

return obj.module+'.'+obj.name, obj.noupdate

131

132

def _create_record(self, cr, uid, doc, model, data, record_id, noupdate=False):

133

data_pool = self.pool.get('ir.model.data')

134

model_pool = self.pool.get(model)

135

136

record = doc.createElement('record')

137

record.setAttribute("id", record_id)

138

record.setAttribute("model", model)

139

record_list = [record]

140

141

lids = data_pool.search(cr, uid, [('model','=',model)])

142

res = data_pool.read(cr, uid, lids[:1], ['module'])

143

if res:

144

self.depends[res[0]['module']]=True

145

fields = model_pool.fields_get(cr, uid)

146

for key,val in data.items():

147

if not (val or (fields[key]['type']=='boolean')):

148

continue

149

if fields[key]['type'] in ('integer','float'):

150

field = doc.createElement('field')

151

field.setAttribute("name", key)

152

field.setAttribute("eval", val and str(val) or 'False' )

153

record.appendChild(field)

154

elif fields[key]['type'] in ('boolean',):

155

field = doc.createElement('field')

156

field.setAttribute("name", key)

157

field.setAttribute("eval", val and '1' or '0' )

158

record.appendChild(field)

159

elif fields[key]['type'] in ('many2one',):

160

field = doc.createElement('field')

161

field.setAttribute("name", key)

162

if type(val) in (type(''),type(u'')):

163

id = val

164

else:

165

id,update = self._get_id(cr, uid, fields[key]['relation'], val)

166

noupdate = noupdate or update

167

if not id:

168

relation_pool = self.pool.get(fields[key]['relation'])

169

170

field.setAttribute("model", fields[key]['relation'])

171

fld_nm = relation_pool._rec_name

172

name = relation_pool.read(cr, uid, val,[fld_nm])[fld_nm] or False

173

field.setAttribute("search", str([(str(fld_nm) ,'=', name)]))

174

else:

175

field.setAttribute("ref", id)

176

record.appendChild(field)

177

elif fields[key]['type'] in ('one2many',):

178

for valitem in (val or []):

179

if valitem[0] in (0,1):

180

if key in model_pool._columns:

181

model_pool._columns[key]._fields_id

182

else:

183

model_pool._inherit_fields[key][2]._fields_id

184

if valitem[0] == 0:

185

newid = self._create_id(cr, uid, fields[key]['relation'], valitem[2])

186

valitem[1]=newid

187

else:

188

newid,update = self._get_id(cr, uid, fields[key]['relation'], valitem[1])

189

if not newid:

190

newid = self._create_id(cr, uid, fields[key]['relation'], valitem[2])

191

valitem[1]=newid

192

self.ids[(fields[key]['relation'], valitem[1])] = newid

193

194

childrecord, update = self._create_record(cr, uid, doc, fields[key]['relation'],valitem[2], newid)

195

noupdate = noupdate or update

196

record_list += childrecord

197

else:

198

pass

199

elif fields[key]['type'] in ('many2many',):

200

res = []

201

for valitem in (val or []):

202

if valitem[0]==6:

203

for id2 in valitem[2]:

204

id,update = self._get_id(cr, uid, fields[key]['relation'], id2)

205

self.ids[(fields[key]['relation'],id2)] = id

206

noupdate = noupdate or update

207

res.append(id)

208

field = doc.createElement('field')

209

field.setAttribute("name", key)

210

field.setAttribute("eval", "[(6,0,["+','.join(map(lambda x: "ref('%s')" % (x,), res))+'])]')

211

record.appendChild(field)

212

else:

213

field = doc_createXElement(doc, 'field')

214

field.setAttribute("name", key)

215

field.appendChild(doc.createTextNode(val))

216

record.appendChild(field)

217

218

return record_list, noupdate

219

220

def _create_yaml_record(self, cr, uid, model, data, record_id):

221

record={'model': model, 'id': str(record_id)}

222

223

model_pool = self.pool.get(model)

224

data_pool = self.pool.get('ir.model.data')

225

lids = data_pool.search(cr, uid, [('model','=',model)])

226

227

res = data_pool.read(cr, uid, lids[:1], ['module'])

228

attrs={}

229

if res:

230

self.depends[res[0]['module']]=True

231

fields = model_pool.fields_get(cr, uid)

232

defaults={}

233

try:

234

defaults[model] = model_pool.default_get(cr, uid, data)

235

except:

236

defaults[model]={}

237

for key,val in data.items():

238

if ((key in defaults[model]) and (val == defaults[model][key])) and not(fields[key].get('required',False)):

239

continue

240

if fields[key]['type'] in ('integer','float'):

241

if not val:

242

val=0.0

243

attrs[key] = val

244

elif not (val or (fields[key]['type']=='function')):

245

continue

246

elif fields[key]['type'] in ('boolean',):

247

if not val:

248

continue

249

attrs[key] = val

250

elif fields[key]['type'] in ('many2one',):

251

if type(val) in (type(''), type(u'')):

252

id = val

253

else:

254

id, update = self._get_id(cr, uid, fields[key]['relation'], val)

255

attrs[key] = str(id)

256

elif fields[key]['type'] in ('one2many',):

257

items=[[]]

258

for valitem in (val or []):

259

if valitem[0] in (0,1):

260

if key in model_pool._columns:

261

fname = model_pool._columns[key]._fields_id

262

else:

263

fname = model_pool._inherit_fields[key][2]._fields_id

264

del valitem[2][fname] #delete parent_field from child's fields list

265

266

childrecord = self._create_yaml_record(cr, uid, fields[key]['relation'],valitem[2], None)

267

items[0].append(childrecord['attrs'])

268

attrs[key] = items

269

elif fields[key]['type'] in ('many2many',):

270

if (key in defaults[model]) and (val[0][2] == defaults[model][key]):

271

continue

272

res = []

273

for valitem in (val or []):

274

if valitem[0]==6:

275

for id2 in valitem[2]:

276

id,update = self._get_id(cr, uid, fields[key]['relation'], id2)

277

self.ids[(fields[key]['relation'],id2)] = id

278

res.append(str(id))

279

m2m=[res]

280

if m2m[0]:

281

attrs[key] = m2m

282

else:

283

try:

284

attrs[key]=str(val)

285

except:

286

attrs[key]=tools.ustr(val)

287

attrs[key]=attrs[key].replace('"','\'')

288

record['attrs'] = attrs

289

return record

290

291

def get_copy_data(self, cr, uid, model, id, result):

292

res = []

293

obj=self.pool.get(model)

294

data=obj.read(cr, uid,[id])

295

if type(data)==type([]):

296

del data[0]['id']

297

data=data[0]

298

else:

299

del data['id']

300

301

mod_fields = obj.fields_get(cr, uid)

302

for f in filter(lambda a: isinstance(obj._columns[a], fields.function)\

303

and (not obj._columns[a].store),obj._columns):

304

del data[f]

305

306

for key,val in data.items():

307

if result.has_key(key):

308

continue

309

if mod_fields[key]['type'] == 'many2one':

310

if type(data[key])==type(True) or type(data[key])==type(1):

311

result[key]=data[key]

312

elif not data[key]:

313

result[key] = False

314

else:

315

result[key]=data[key][0]

316

317

elif mod_fields[key]['type'] in ('one2many',):

318

# continue # due to this start stop recording will not record one2many field

319

rel = mod_fields[key]['relation']

320

if len(data[key]):

321

res1=[]

322

for rel_id in data[key]:

323

res=[0,0]

324

res.append(self.get_copy_data(cr, uid,rel,rel_id,{}))

325

res1.append(res)

326

result[key]=res1

327

else:

328

result[key]=data[key]

329

330

elif mod_fields[key]['type'] == 'many2many':

331

result[key]=[(6,0,data[key])]

332

333

else:

334

result[key]=data[key]

335

for k,v in obj._inherits.items():

336

del result[v]

337

return result

338

339

def _create_function(self, cr, uid, doc, model, name, record_id):

340

record = doc.createElement('function')

341

record.setAttribute("name", name)

342

record.setAttribute("model", model)

343

record_list = [record]

344

345

value = doc.createElement('value')

346

value.setAttribute('eval', '[ref(\'%s\')]' % (record_id, ))

347

value.setAttribute('model', model)

348

349

record.appendChild(value)

350

return record_list, False

351

352

def _generate_object_xml(self, cr, uid, rec, recv, doc, result=None):

353

record_list = []

354

noupdate = False

355

if rec[3]=='write':

356

for id in rec[4]:

357

id,update = self._get_id(cr, uid, rec[2], id)

358

noupdate = noupdate or update

359

if not id:

360

continue

361

record,update = self._create_record(cr, uid, doc, rec[2], rec[5], id)

362

noupdate = noupdate or update

363

record_list += record

364

365

elif rec[4] in ('menu_create',):

366

for id in rec[5]:

367

id,update = self._get_id(cr, uid, rec[3], id)

368

noupdate = noupdate or update

369

if not id:

370

continue

371

record,update = self._create_function(cr, uid, doc, rec[3], rec[4], id)

372

noupdate = noupdate or update

373

record_list += record

374

375

elif rec[3]=='create':

376

id = self._create_id(cr, uid, rec[2],rec[4])

377

record,noupdate = self._create_record(cr, uid, doc, rec[2], rec[4], id)

378

self.ids[(rec[2], result)] = id

379

record_list += record

380

381

elif rec[3]=='copy':

382

data=self.get_copy_data(cr,uid,rec[2],rec[4],rec[5])

383

copy_rec=(rec[0],rec[1],rec[2],rec[3],rec[4],data,rec[5])

384

rec=copy_rec

385

rec_data=[(self.recording_data[0][0],rec,self.recording_data[0][2],self.recording_data[0][3])]

386

self.recording_data=rec_data

387

id = self._create_id(cr, uid, rec[2],rec[5])

388

record,noupdate = self._create_record(cr, uid, doc, rec[2], rec[5], id)

389

self.ids[(rec[2], result)] = id

390

record_list += record

391

392

return record_list,noupdate

393

394

def _generate_object_yaml(self, cr, uid, rec, result=None):

395

if self.mode=="create":

396

yml_id = self._create_id(cr, uid, rec[2],rec[4])

397

self.ids[(rec[2], result)] = yml_id

398

record = self._create_yaml_record(cr, uid, rec[2], rec[4], yml_id)

399

return record

400

if self.mode=="workflow":

401

id,update = self._get_id(cr, uid, rec[2], rec[4])

402

data = {}

403

data['model'] = rec[2]

404

data['action'] = rec[3]

405

data['ref'] = id

406

return data

407

if self.mode=="write":

408

id,update = self._get_id(cr, uid, rec[2],rec[4][0])

409

record = self._create_yaml_record(cr, uid, rec[2], rec[5], id)

410

return record

411

data=self.get_copy_data(cr,uid,rec[2],rec[4],rec[5])

412

copy_rec=(rec[0],rec[1],rec[2],rec[3],rec[4],data,rec[5])

413

rec=copy_rec

414

rec_data=[(self.recording_data[0][0],rec,self.recording_data[0][2],self.recording_data[0][3])]

415

self.recording_data=rec_data

416

id = self._create_id(cr, uid, rec[2],rec[5])

417

record = self._create_yaml_record(cr, uid, str(rec[2]), rec[5], id)

418

self.ids[(rec[2], result)] = id

419

return record

420

421

def _generate_function_yaml(self, cr, uid, args):

422

db, uid, model, action, ids, context = args

423

temp_context = context.copy()

424

active_id = temp_context['active_id']

425

active_model = temp_context['active_model']

426

active_id, update = self._get_id(cr, uid, active_model, active_id)

427

if not active_id:

428

active_id = 1

429

rec_id, noupdate = self._get_id(cr, uid, model, ids[0])

430

temp_context['active_id'] = "ref('%s')"%unicode(active_id)

431

temp_context['active_ids'][0] = "ref('%s')"%str(active_id)

432

function={}

433

function['model'] = model

434

function['action'] = action

435

attrs = "self.%s(cr, uid, [ref('%s')], {" %(action, rec_id, )

436

for k, v in temp_context.iteritems():

437

if isinstance(v, str):

438

f= "'"+k+"': "+"'%s'"%v + ", "

439

else:

440

v=str(v).replace('"', '')

441

f= "'"+k+"': "+"%s"%v + ", "

442

attrs = attrs + f

443

attrs=str(attrs)+'})'

444

function['attrs'] = attrs

445

return function

446

447

def _generate_assert_xml(self, rec, doc):

448

pass

449

450

def generate_xml(self, cr, uid):

451

# Create the minidom document

452

if len(self.recording_data):

453

self.ids = {}

454

doc = minidom.Document()

455

terp = doc.createElement("openerp")

456

doc.appendChild(terp)

457

for rec in self.recording_data:

458

if rec[0]=='workflow':

459

rec_id,noupdate = self._get_id(cr, uid, rec[1][2], rec[1][4])

460

if not rec_id:

461

continue

462

data = doc.createElement("data")

463

terp.appendChild(data)

464

wkf = doc.createElement('workflow')

465

data.appendChild(wkf)

466

wkf.setAttribute("model", rec[1][2])

467

wkf.setAttribute("action", rec[1][3])

468

if noupdate:

469

data.setAttribute("noupdate", "1")

470

wkf.setAttribute("ref", rec_id)

471

if rec[0]=='query':

472

res_list,noupdate = self._generate_object_xml(cr, uid, rec[1], rec[2], doc, rec[3])

473

data = doc.createElement("data")

474

if noupdate:

475

data.setAttribute("noupdate", "1")

476

if res_list:

477

terp.appendChild(data)

478

for res in res_list:

479

data.appendChild(res)

480

elif rec[0]=='assert':

481

pass

482

return doc.toprettyxml(indent="\t").encode('utf-8')

483

484

def generate_yaml(self, cr, uid):

485

self.ids = {}

486

if len(self.recording_data):

487

yaml_file='''\n'''

488

489

for rec in self.recording_data:

490

if rec[1][3] == 'create':

491

self.mode="create"

492

elif rec[1][3] == 'write':

493

self.mode="write"

494

elif rec[1][3] == 'copy':

495

self.mode="copy"

496

elif rec[0] == 'workflow':

497

self.mode="workflow"

498

elif rec[0] == 'osv_memory_action':

499

self.mode='osv_memory_action'

500

else:

501

continue

502

if self.mode == "workflow":

503

record = self._generate_object_yaml(cr, uid, rec[1],rec[0])

504

yaml_file += "!comment Performing a workflow action %s on module %s"%(record['action'], record['model']) + '''\n'''

505

object = yaml.load(unicode('''\n !workflow %s \n'''%record,'iso-8859-1'))

506

yaml_file += str(object) + '''\n\n'''

507

elif self.mode == 'osv_memory_action':

508

osv_action = self._generate_function_yaml(cr, uid, rec[1])

509

yaml_file += "!comment Performing an osv_memory action %s on module %s"%(osv_action['action'], osv_action['model']) + '''\n'''

510

osv_action = yaml.load(unicode('''\n !python %s \n'''%osv_action,'iso-8859-1'))

511

yaml_file += str(osv_action) + '''\n'''

512

attrs = yaml.dump(osv_action.attrs, default_flow_style=False)

513

attrs = attrs.replace("''", '"')

514

attrs = attrs.replace("'", '')

515

yaml_file += attrs + '''\n\n'''

516

else:

517

record = self._generate_object_yaml(cr, uid, rec[1], rec[3])

518

if self.mode == "create" or self.mode == "copy":

519

yaml_file += "!comment Creating a %s record"%(record['model']) + '''\n'''

520

else:

521

yaml_file += "!comment Modifying a %s record"%(record['model']) + '''\n'''

522

object = yaml.load(unicode('''\n !record %s \n'''%record,'iso-8859-1'))

523

yaml_file += str(object) + '''\n'''

524

attrs = yaml.dump(object.attrs, default_flow_style=False)

525

yaml_file += attrs + '''\n\n'''

526

527

yaml_result=''''''

528

for line in yaml_file.split('\n'):

529

line=line.replace("''","'")

530

if (line.find('!record') == 0) or (line.find('!workflow') == 0) or (line.find('!python') == 0):

531

line = "- \n" + " " + line

532

elif line.find('!comment') == 0:

533

line=line.replace('!comment','- \n ')

534

elif line.find('- -') != -1:

535

line=line.replace('- -',' -')

536

line = " " + line

537

else:

538

line = " " + line

539

yaml_result += line + '''\n'''

540

541

return yaml_result

542

543

base_module_record()

544

# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

545

Older »