base_module_doc_rst/base_module_doc_rst.py
# -*- coding: utf-8 -*-
##############################################################################
#
# OpenERP, Open Source Management Solution
# Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>).
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
import os
import base64
import openerp.modules.registry
from openerp import models, fields
class Module(models.Model):
_inherit = 'ir.module.module'
_description = 'Module With Relationship Graph'
file_graph = fields.Binary('Relationship Graph')
def _get_graphical_representation(
self, cr, uid, model_ids, level=1, context=None
):
obj_model = self.pool.get('ir.model')
if level == 0:
return tuple()
relation = []
for id in model_ids:
model_data = obj_model.browse(cr, uid, id, context=context)
for field in (
f for f in model_data.field_id if f.ttype in (
'many2many', 'many2one', 'one2many'
)
):
relation.append(
(
model_data.model,
field.name,
field.ttype,
field.relation,
field.field_description
)
)
new_model_ids = obj_model.search(
cr,
uid,
[('model', '=', field.relation)],
context=context
)
if new_model_ids:
model = obj_model.read(
cr,
uid,
new_model_ids,
['id', 'name'],
context=context
)[0]
relation.extend(
self._get_graphical_representation(
cr, uid, model['id'], level - 1
)
)
return tuple(relation)
def _get_structure(self, relations, main_element):
res = {}
for rel in relations:
# if we have to display the string along with field name,
# then uncomment the first line n comment the second line
res.setdefault(rel[0], set()).add(rel[1])
res.setdefault(rel[3], set())
val = []
for obj, fieldsx in res.items():
val.append('"%s" [%s label="{<id>%s|%s}"];' % (
obj,
obj in
main_element and
'fillcolor=yellow, style="filled,rounded"' or
"",
obj,
"|".join(["<%s> %s" % (fn, fn) for fn in fieldsx])
))
return "\n".join(val)
def _get_arrow(self, field_type='many2one'):
return {
'many2one': (
'arrowtail="none" arrowhead="normal" color="red" label="m2o"'
),
'many2many': (
'arrowtail="crow" arrowhead="crow" color="green" label="m2m"'
),
'one2many': (
'arrowtail="none" arrowhead="crow" color="blue" label="o2m"'
),
}[field_type]
def get_graphical_representation(self, cr, uid, model_ids, context=None):
obj_model = self.pool.get('ir.model')
if context is None:
context = {}
res = {}
models = []
for obj in obj_model.browse(cr, uid, model_ids, context=context):
models.append(obj.model)
relations = set(
self._get_graphical_representation(
cr, uid, model_ids, context.get('level', 1)
)
)
res[obj.model] = (
"digraph G {\nnode [style=rounded, shape=record];\n%s\n%s }" % (
self._get_structure(relations, models),
''.join('"%s":%s -> "%s":id:n [%s]; // %s\n' % (
m, fn, fr, self._get_arrow(ft), ft
) for m, fn, ft, fr, fl in relations),
)
)
return res
def _get_module_objects(self, cr, uid, module, context=None):
obj_model = self.pool.get('ir.model')
obj_mod_data = self.pool.get('ir.model.data')
obj_ids = []
model_data_ids = obj_mod_data.search(
cr, uid,
[('module', '=', module), ('model', '=', 'ir.model')],
context=context
)
model_ids = []
for mod in obj_mod_data.browse(
cr, uid, model_data_ids, context=context
):
model_ids.append(mod.res_id)
models = obj_model.browse(cr, uid, model_ids, context=context)
map(lambda x: obj_ids.append(x.id), models)
return obj_ids
def get_relation_graph(self, cr, uid, module_name, context=None):
if context is None:
context = {}
object_ids = self._get_module_objects(
cr, uid, module_name, context=context
)
if not object_ids:
return {'module_file': False}
# context.update({'level': 1})
dots = self.get_graphical_representation(
cr, uid, object_ids, context=context
)
# todo: use os.realpath
file_path = openerp.modules.module.get_module_path(
'base_module_doc_rst'
)
path_png = file_path + "/module.png"
for key, val in dots.items():
path_dotfile = file_path + "/%s.dot" % (key,)
fp = file(path_dotfile, "w")
fp.write(val)
fp.close()
os.popen(
'dot -Tpng' + ' ' + path_dotfile + ' ' + '-o' + ' ' + path_png
)
fp = file(path_png, "r")
x = fp.read()
fp.close()
os.popen('rm ' + path_dotfile + ' ' + path_png)
return {'module_file': base64.encodestring(x)}