openerp/addons/base/ir/ir_ui_view.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 import collections
  22 import copy
  23 import datetime
  24 import dateutil
  25 from dateutil.relativedelta import relativedelta
  26 import fnmatch
  27 import logging
  28 import os
  29 import time
  30 from operator import itemgetter
  31
  32 import simplejson
  33 import werkzeug
  34 import HTMLParser
  35 from lxml import etree
  36
  37 import openerp
  38 from openerp import tools, api
  39 from openerp.http import request
  40 from openerp.modules.module import get_resource_path, get_resource_from_path
  41 from openerp.osv import fields, osv, orm
  42 from openerp.tools import config, graph, SKIPPED_ELEMENT_TYPES, SKIPPED_ELEMENTS
  43 from openerp.tools.convert import _fix_multiple_roots
  44 from openerp.tools.parse_version import parse_version
  45 from openerp.tools.safe_eval import safe_eval as eval
  46 from openerp.tools.view_validation import valid_view
  47 from openerp.tools import misc
  48 from openerp.tools.translate import _
  49
  50 _logger = logging.getLogger(__name__)
  51
  52 MOVABLE_BRANDING = ['data-oe-model', 'data-oe-id', 'data-oe-field', 'data-oe-xpath', 'data-oe-source-id']
  53
  54 def keep_query(*keep_params, **additional_params):
  55     """
  56     Generate a query string keeping the current request querystring's parameters specified
  57     in ``keep_params`` and also adds the parameters specified in ``additional_params``.
  58
  59     Multiple values query string params will be merged into a single one with comma seperated
  60     values.
  61
  62     The ``keep_params`` arguments can use wildcards too, eg:
  63
  64         keep_query('search', 'shop_*', page=4)
  65     """
  66     if not keep_params and not additional_params:
  67         keep_params = ('*',)
  68     params = additional_params.copy()
  69     qs_keys = request.httprequest.args.keys()
  70     for keep_param in keep_params:
  71         for param in fnmatch.filter(qs_keys, keep_param):
  72             if param not in additional_params and param in qs_keys:
  73                 params[param] = ','.join(request.httprequest.args.getlist(param))
  74     return werkzeug.urls.url_encode(params)
  75
  76 class view_custom(osv.osv):
  77     _name = 'ir.ui.view.custom'
  78     _order = 'create_date desc'  # search(limit=1) should return the last customization
  79     _columns = {
  80         'ref_id': fields.many2one('ir.ui.view', 'Original View', select=True, required=True, ondelete='cascade'),
  81         'user_id': fields.many2one('res.users', 'User', select=True, required=True, ondelete='cascade'),
  82         'arch': fields.text('View Architecture', required=True),
  83     }
  84
  85     def name_get(self, cr, uid, ids, context=None):
  86         return [(rec.id, rec.user_id.name) for rec in self.browse(cr, uid, ids, context=context)]
  87
  88     def name_search(self, cr, user, name, args=None, operator='ilike', context=None, limit=100):
  89         if args is None:
  90             args = []
  91         if name:
  92             ids = self.search(cr, user, [('user_id', operator, name)] + args, limit=limit)
  93             return self.name_get(cr, user, ids, context=context)
  94         return super(view_custom, self).name_search(cr, user, name, args=args, operator=operator, context=context, limit=limit)
  95
  96
  97     def _auto_init(self, cr, context=None):
  98         super(view_custom, self)._auto_init(cr, context)
  99         cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = \'ir_ui_view_custom_user_id_ref_id\'')
 100         if not cr.fetchone():
 101             cr.execute('CREATE INDEX ir_ui_view_custom_user_id_ref_id ON ir_ui_view_custom (user_id, ref_id)')
 102
 103 def _hasclass(context, *cls):
 104     """ Checks if the context node has all the classes passed as arguments
 105     """
 106     node_classes = set(context.context_node.attrib.get('class', '').split())
 107
 108     return node_classes.issuperset(cls)
 109
 110 def get_view_arch_from_file(filename, xmlid):
 111     doc = etree.parse(filename)
 112     node = None
 113     for n in doc.xpath('//*[@id="%s"] | //*[@id="%s"]' % (xmlid, xmlid.split('.')[1])):
 114         if n.tag in ('template', 'record'):
 115             node = n
 116             break
 117     if node is not None:
 118         if node.tag == 'record':
 119             field = node.find('field[@name="arch"]')
 120             _fix_multiple_roots(field)
 121             inner = ''.join([etree.tostring(child) for child in field.iterchildren()])
 122             return field.text + inner
 123         elif node.tag == 'template':
 124             # The following dom operations has been copied from convert.py's _tag_template()
 125             if not node.get('inherit_id'):
 126                 node.set('t-name', xmlid)
 127                 node.tag = 't'
 128             else:
 129                 node.tag = 'data'
 130             node.attrib.pop('id', None)
 131             return etree.tostring(node)
 132     _logger.warning("Could not find view arch definition in file '%s' for xmlid '%s'" % (filename, xmlid))
 133     return None
 134
 135 xpath_utils = etree.FunctionNamespace(None)
 136 xpath_utils['hasclass'] = _hasclass
 137
 138 class view(osv.osv):
 139     _name = 'ir.ui.view'
 140
 141     def _get_model_data(self, cr, uid, ids, fname, args, context=None):
 142         result = dict.fromkeys(ids, False)
 143         IMD = self.pool['ir.model.data']
 144         data_ids = IMD.search_read(cr, uid, [('res_id', 'in', ids), ('model', '=', 'ir.ui.view')], ['res_id'], context=context)
 145         result.update(map(itemgetter('res_id', 'id'), data_ids))
 146         return result
 147
 148     def _views_from_model_data(self, cr, uid, ids, context=None):
 149         IMD = self.pool['ir.model.data']
 150         data_ids = IMD.search_read(cr, uid, [('id', 'in', ids), ('model', '=', 'ir.ui.view')], ['res_id'], context=context)
 151         return map(itemgetter('res_id'), data_ids)
 152
 153     def _arch_get(self, cr, uid, ids, name, arg, context=None):
 154         result = {}
 155         for view in self.browse(cr, uid, ids, context=context):
 156             arch_fs = None
 157             if config['dev_mode'] and view.arch_fs and view.xml_id:
 158                 # It is safe to split on / herebelow because arch_fs is explicitely stored with '/'
 159                 fullpath = get_resource_path(*view.arch_fs.split('/'))
 160                 arch_fs = get_view_arch_from_file(fullpath, view.xml_id)
 161             result[view.id] = arch_fs or view.arch_db
 162         return result
 163
 164     def _arch_set(self, cr, uid, ids, field_name, field_value, args, context=None):
 165         if not isinstance(ids, list):
 166             ids = [ids]
 167         if field_value:
 168             for view in self.browse(cr, uid, ids, context=context):
 169                 data = dict(arch_db=field_value)
 170                 key = 'install_mode_data'
 171                 if context and key in context:
 172                     imd = context[key]
 173                     if self._model._name == imd['model'] and (not view.xml_id or view.xml_id == imd['xml_id']):
 174                         # we store the relative path to the resource instead of the absolute path
 175                         data['arch_fs'] = '/'.join(get_resource_from_path(imd['xml_file'])[0:2])
 176                 self.write(cr, uid, ids, data, context=context)
 177
 178         return True
 179
 180     _columns = {
 181         'name': fields.char('View Name', required=True),
 182         'model': fields.char('Object', select=True),
 183         'key': fields.char(string='Key'),
 184         'priority': fields.integer('Sequence', required=True),
 185         'type': fields.selection([
 186             ('tree','Tree'),
 187             ('form','Form'),
 188             ('graph', 'Graph'),
 189             ('pivot', 'Pivot'),
 190             ('calendar', 'Calendar'),
 191             ('diagram','Diagram'),
 192             ('gantt', 'Gantt'),
 193             ('kanban', 'Kanban'),
 194             ('search','Search'),
 195             ('qweb', 'QWeb')], string='View Type'),
 196         'arch': fields.function(_arch_get, fnct_inv=_arch_set, string='View Architecture', type="text", nodrop=True),
 197         'arch_db': fields.text('Arch Blob'),
 198         'arch_fs': fields.char('Arch Filename'),
 199         'inherit_id': fields.many2one('ir.ui.view', 'Inherited View', ondelete='restrict', select=True),
 200         'inherit_children_ids': fields.one2many('ir.ui.view','inherit_id', 'Inherit Views'),
 201         'field_parent': fields.char('Child Field'),
 202         'model_data_id': fields.function(_get_model_data, type='many2one', relation='ir.model.data', string="Model Data",
 203                                          store={
 204                                              _name: (lambda s, c, u, i, ctx=None: i, None, 10),
 205                                              'ir.model.data': (_views_from_model_data, ['model', 'res_id'], 10),
 206                                          }),
 207         'xml_id': fields.function(osv.osv.get_xml_id, type='char', size=128, string="External ID",
 208                                   help="ID of the view defined in xml file"),
 209         'groups_id': fields.many2many('res.groups', 'ir_ui_view_group_rel', 'view_id', 'group_id',
 210             string='Groups', help="If this field is empty, the view applies to all users. Otherwise, the view applies to the users of those groups only."),
 211         'model_ids': fields.one2many('ir.model.data', 'res_id', domain=[('model','=','ir.ui.view')], auto_join=True),
 212         'create_date': fields.datetime('Create Date', readonly=True),
 213         'write_date': fields.datetime('Last Modification Date', readonly=True),
 214
 215         'mode': fields.selection(
 216             [('primary', "Base view"), ('extension', "Extension View")],
 217             string="View inheritance mode", required=True,
 218             help="""Only applies if this view inherits from an other one (inherit_id is not False/Null).
 219
 220 * if extension (default), if this view is requested the closest primary view
 221   is looked up (via inherit_id), then all views inheriting from it with this
 222   view's model are applied
 223 * if primary, the closest primary view is fully resolved (even if it uses a
 224   different model than this one), then this view's inheritance specs
 225   (<xpath/>) are applied, and the result is used as if it were this view's
 226   actual arch.
 227 """),
 228         'active': fields.boolean("Active",
 229             help="""If this view is inherited,
 230 * if True, the view always extends its parent
 231 * if False, the view currently does not extend its parent but can be enabled
 232              """),
 233     }
 234     _defaults = {
 235         'mode': 'primary',
 236         'active': True,
 237         'priority': 16,
 238     }
 239     _order = "priority,name"
 240
 241     # Holds the RNG schema
 242     _relaxng_validator = None
 243
 244     def _relaxng(self):
 245         if not self._relaxng_validator:
 246             frng = tools.file_open(os.path.join('base','rng','view.rng'))
 247             try:
 248                 relaxng_doc = etree.parse(frng)
 249                 self._relaxng_validator = etree.RelaxNG(relaxng_doc)
 250             except Exception:
 251                 _logger.exception('Failed to load RelaxNG XML schema for views validation')
 252             finally:
 253                 frng.close()
 254         return self._relaxng_validator
 255
 256     def _check_xml(self, cr, uid, ids, context=None):
 257         if context is None:
 258             context = {}
 259         context = dict(context, check_view_ids=ids)
 260
 261         # Sanity checks: the view should not break anything upon rendering!
 262         # Any exception raised below will cause a transaction rollback.
 263         for view in self.browse(cr, uid, ids, context):
 264             view_def = self.read_combined(cr, uid, view.id, None, context=context)
 265             view_arch_utf8 = view_def['arch']
 266             if view.type != 'qweb':
 267                 view_doc = etree.fromstring(view_arch_utf8)
 268                 # verify that all fields used are valid, etc.
 269                 self.postprocess_and_fields(cr, uid, view.model, view_doc, view.id, context=context)
 270                 # RNG-based validation is not possible anymore with 7.0 forms
 271                 view_docs = [view_doc]
 272                 if view_docs[0].tag == 'data':
 273                     # A <data> element is a wrapper for multiple root nodes
 274                     view_docs = view_docs[0]
 275                 validator = self._relaxng()
 276                 for view_arch in view_docs:
 277                     version = view_arch.get('version', '7.0')
 278                     if parse_version(version) < parse_version('7.0') and validator and not validator.validate(view_arch):
 279                         for error in validator.error_log:
 280                             _logger.error(tools.ustr(error))
 281                         return False
 282                     if not valid_view(view_arch):
 283                         return False
 284         return True
 285
 286     _sql_constraints = [
 287         ('inheritance_mode',
 288          "CHECK (mode != 'extension' OR inherit_id IS NOT NULL)",
 289          "Invalid inheritance mode: if the mode is 'extension', the view must"
 290          " extend an other view"),
 291     ]
 292     _constraints = [
 293         (_check_xml, 'Invalid view definition', ['arch']),
 294     ]
 295
 296     def _auto_init(self, cr, context=None):
 297         super(view, self)._auto_init(cr, context)
 298         cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = \'ir_ui_view_model_type_inherit_id\'')
 299         if not cr.fetchone():
 300             cr.execute('CREATE INDEX ir_ui_view_model_type_inherit_id ON ir_ui_view (model, inherit_id)')
 301
 302     def _compute_defaults(self, cr, uid, values, context=None):
 303         if 'inherit_id' in values:
 304             values.setdefault(
 305                 'mode', 'extension' if values['inherit_id'] else 'primary')
 306         return values
 307
 308     def create(self, cr, uid, values, context=None):
 309         if not values.get('type'):
 310             if values.get('inherit_id'):
 311                 values['type'] = self.browse(cr, uid, values['inherit_id'], context).type
 312             else:
 313                 values['type'] = etree.fromstring(values['arch']).tag
 314
 315         if not values.get('name'):
 316             values['name'] = "%s %s" % (values.get('model'), values['type'])
 317
 318         self.clear_cache()
 319         return super(view, self).create(
 320             cr, uid,
 321             self._compute_defaults(cr, uid, values, context=context),
 322             context=context)
 323
 324     def write(self, cr, uid, ids, vals, context=None):
 325         if not isinstance(ids, (list, tuple)):
 326             ids = [ids]
 327         if context is None:
 328             context = {}
 329
 330         # If view is modified we remove the arch_fs information thus activating the arch_db
 331         # version. An `init` of the view will restore the arch_fs for the --dev mode
 332         if 'arch' in vals and 'install_mode_data' not in context:
 333             vals['arch_fs'] = False
 334
 335         # drop the corresponding view customizations (used for dashboards for example), otherwise
 336         # not all users would see the updated views
 337         custom_view_ids = self.pool.get('ir.ui.view.custom').search(cr, uid, [('ref_id', 'in', ids)])
 338         if custom_view_ids:
 339             self.pool.get('ir.ui.view.custom').unlink(cr, uid, custom_view_ids)
 340
 341         self.clear_cache()
 342         ret = super(view, self).write(
 343             cr, uid, ids,
 344             self._compute_defaults(cr, uid, vals, context=context),
 345             context)
 346         return ret
 347
 348     def toggle(self, cr, uid, ids, context=None):
 349         """ Switches between enabled and disabled statuses
 350         """
 351         for view in self.browse(cr, uid, ids, context=dict(context or {}, active_test=False)):
 352             view.write({'active': not view.active})
 353
 354     # default view selection
 355     def default_view(self, cr, uid, model, view_type, context=None):
 356         """ Fetches the default view for the provided (model, view_type) pair:
 357          primary view with the lowest priority.
 358
 359         :param str model:
 360         :param int view_type:
 361         :return: id of the default view of False if none found
 362         :rtype: int
 363         """
 364         domain = [
 365             ['model', '=', model],
 366             ['type', '=', view_type],
 367             ['mode', '=', 'primary'],
 368         ]
 369         ids = self.search(cr, uid, domain, limit=1, context=context)
 370         if not ids:
 371             return False
 372         return ids[0]
 373
 374     #------------------------------------------------------
 375     # Inheritance mecanism
 376     #------------------------------------------------------
 377     def get_inheriting_views_arch(self, cr, uid, view_id, model, context=None):
 378         """Retrieves the architecture of views that inherit from the given view, from the sets of
 379            views that should currently be used in the system. During the module upgrade phase it
 380            may happen that a view is present in the database but the fields it relies on are not
 381            fully loaded yet. This method only considers views that belong to modules whose code
 382            is already loaded. Custom views defined directly in the database are loaded only
 383            after the module initialization phase is completely finished.
 384
 385            :param int view_id: id of the view whose inheriting views should be retrieved
 386            :param str model: model identifier of the inheriting views.
 387            :rtype: list of tuples
 388            :return: [(view_arch,view_id), ...]
 389         """
 390
 391         user = self.pool['res.users'].browse(cr, 1, uid, context=context)
 392         user_groups = frozenset(user.groups_id or ())
 393
 394         conditions = [
 395             ['inherit_id', '=', view_id],
 396             ['model', '=', model],
 397             ['mode', '=', 'extension'],
 398             ['active', '=', True],
 399         ]
 400         if self.pool._init:
 401             # Module init currently in progress, only consider views from
 402             # modules whose code is already loaded
 403             conditions.extend([
 404                 '|',
 405                 ['model_ids.module', 'in', tuple(self.pool._init_modules)],
 406                 ['id', 'in', context and context.get('check_view_ids') or (0,)],
 407             ])
 408         view_ids = self.search(cr, uid, conditions, context=context)
 409
 410         return [(view.arch, view.id)
 411                 for view in self.browse(cr, 1, view_ids, context)
 412                 if not (view.groups_id and user_groups.isdisjoint(view.groups_id))]
 413
 414     def raise_view_error(self, cr, uid, message, view_id, context=None):
 415         view = self.browse(cr, uid, view_id, context)
 416         not_avail = _('n/a')
 417         message = ("%(msg)s\n\n" +
 418                    _("Error context:\nView `%(view_name)s`") +
 419                    "\n[view_id: %(viewid)s, xml_id: %(xmlid)s, "
 420                    "model: %(model)s, parent_id: %(parent)s]") % \
 421                         {
 422                           'view_name': view.name or not_avail,
 423                           'viewid': view_id or not_avail,
 424                           'xmlid': view.xml_id or not_avail,
 425                           'model': view.model or not_avail,
 426                           'parent': view.inherit_id.id or not_avail,
 427                           'msg': message,
 428                         }
 429         _logger.error(message)
 430         raise AttributeError(message)
 431
 432     def locate_node(self, arch, spec):
 433         """ Locate a node in a source (parent) architecture.
 434
 435         Given a complete source (parent) architecture (i.e. the field
 436         `arch` in a view), and a 'spec' node (a node in an inheriting
 437         view that specifies the location in the source view of what
 438         should be changed), return (if it exists) the node in the
 439         source view matching the specification.
 440
 441         :param arch: a parent architecture to modify
 442         :param spec: a modifying node in an inheriting view
 443         :return: a node in the source matching the spec
 444         """
 445         if spec.tag == 'xpath':
 446             nodes = arch.xpath(spec.get('expr'))
 447             return nodes[0] if nodes else None
 448         elif spec.tag == 'field':
 449             # Only compare the field name: a field can be only once in a given view
 450             # at a given level (and for multilevel expressions, we should use xpath
 451             # inheritance spec anyway).
 452             for node in arch.iter('field'):
 453                 if node.get('name') == spec.get('name'):
 454                     return node
 455             return None
 456
 457         for node in arch.iter(spec.tag):
 458             if isinstance(node, SKIPPED_ELEMENT_TYPES):
 459                 continue
 460             if all(node.get(attr) == spec.get(attr) for attr in spec.attrib
 461                    if attr not in ('position','version')):
 462                 # Version spec should match parent's root element's version
 463                 if spec.get('version') and spec.get('version') != arch.get('version'):
 464                     return None
 465                 return node
 466         return None
 467
 468     def inherit_branding(self, specs_tree, view_id, root_id):
 469         for node in specs_tree.iterchildren(tag=etree.Element):
 470             xpath = node.getroottree().getpath(node)
 471             if node.tag == 'data' or node.tag == 'xpath':
 472                 self.inherit_branding(node, view_id, root_id)
 473             else:
 474                 node.set('data-oe-id', str(view_id))
 475                 node.set('data-oe-source-id', str(root_id))
 476                 node.set('data-oe-xpath', xpath)
 477                 node.set('data-oe-model', 'ir.ui.view')
 478                 node.set('data-oe-field', 'arch')
 479
 480         return specs_tree
 481
 482     def apply_inheritance_specs(self, cr, uid, source, specs_tree, inherit_id, context=None):
 483         """ Apply an inheriting view (a descendant of the base view)
 484
 485         Apply to a source architecture all the spec nodes (i.e. nodes
 486         describing where and what changes to apply to some parent
 487         architecture) given by an inheriting view.
 488
 489         :param Element source: a parent architecture to modify
 490         :param Elepect specs_tree: a modifying architecture in an inheriting view
 491         :param inherit_id: the database id of specs_arch
 492         :return: a modified source where the specs are applied
 493         :rtype: Element
 494         """
 495         # Queue of specification nodes (i.e. nodes describing where and
 496         # changes to apply to some parent architecture).
 497         specs = [specs_tree]
 498
 499         while len(specs):
 500             spec = specs.pop(0)
 501             if isinstance(spec, SKIPPED_ELEMENT_TYPES):
 502                 continue
 503             if spec.tag == 'data':
 504                 specs += [c for c in spec]
 505                 continue
 506             node = self.locate_node(source, spec)
 507             if node is not None:
 508                 pos = spec.get('position', 'inside')
 509                 if pos == 'replace':
 510                     if node.getparent() is None:
 511                         source = copy.deepcopy(spec[0])
 512                     else:
 513                         for child in spec:
 514                             node.addprevious(child)
 515                         node.getparent().remove(node)
 516                 elif pos == 'attributes':
 517                     for child in spec.getiterator('attribute'):
 518                         attribute = (child.get('name'), child.text or None)
 519                         if attribute[1]:
 520                             node.set(attribute[0], attribute[1])
 521                         elif attribute[0] in node.attrib:
 522                             del node.attrib[attribute[0]]
 523                 else:
 524                     sib = node.getnext()
 525                     for child in spec:
 526                         if pos == 'inside':
 527                             node.append(child)
 528                         elif pos == 'after':
 529                             if sib is None:
 530                                 node.addnext(child)
 531                                 node = child
 532                             else:
 533                                 sib.addprevious(child)
 534                         elif pos == 'before':
 535                             node.addprevious(child)
 536                         else:
 537                             self.raise_view_error(cr, uid, _("Invalid position attribute: '%s'") % pos, inherit_id, context=context)
 538             else:
 539                 attrs = ''.join([
 540                     ' %s="%s"' % (attr, spec.get(attr))
 541                     for attr in spec.attrib
 542                     if attr != 'position'
 543                 ])
 544                 tag = "<%s%s>" % (spec.tag, attrs)
 545                 self.raise_view_error(cr, uid, _("Element '%s' cannot be located in parent view") % tag, inherit_id, context=context)
 546
 547         return source
 548
 549     def apply_view_inheritance(self, cr, uid, source, source_id, model, root_id=None, context=None):
 550         """ Apply all the (directly and indirectly) inheriting views.
 551
 552         :param source: a parent architecture to modify (with parent modifications already applied)
 553         :param source_id: the database view_id of the parent view
 554         :param model: the original model for which we create a view (not
 555             necessarily the same as the source's model); only the inheriting
 556             views with that specific model will be applied.
 557         :return: a modified source where all the modifying architecture are applied
 558         """
 559         if context is None: context = {}
 560         if root_id is None:
 561             root_id = source_id
 562         sql_inherit = self.get_inheriting_views_arch(cr, uid, source_id, model, context=context)
 563         for (specs, view_id) in sql_inherit:
 564             specs_tree = etree.fromstring(specs.encode('utf-8'))
 565             if context.get('inherit_branding'):
 566                 self.inherit_branding(specs_tree, view_id, root_id)
 567             source = self.apply_inheritance_specs(cr, uid, source, specs_tree, view_id, context=context)
 568             source = self.apply_view_inheritance(cr, uid, source, view_id, model, root_id=root_id, context=context)
 569         return source
 570
 571     def read_combined(self, cr, uid, view_id, fields=None, context=None):
 572         """
 573         Utility function to get a view combined with its inherited views.
 574
 575         * Gets the top of the view tree if a sub-view is requested
 576         * Applies all inherited archs on the root view
 577         * Returns the view with all requested fields
 578           .. note:: ``arch`` is always added to the fields list even if not
 579                     requested (similar to ``id``)
 580         """
 581         if context is None: context = {}
 582
 583         # if view_id is not a root view, climb back to the top.
 584         base = v = self.browse(cr, uid, view_id, context=context)
 585         while v.mode != 'primary':
 586             v = v.inherit_id
 587         root_id = v.id
 588
 589         # arch and model fields are always returned
 590         if fields:
 591             fields = list(set(fields) | set(['arch', 'model']))
 592
 593         # read the view arch
 594         [view] = self.read(cr, uid, [root_id], fields=fields, context=context)
 595         view_arch = etree.fromstring(view['arch'].encode('utf-8'))
 596         if not v.inherit_id:
 597             arch_tree = view_arch
 598         else:
 599             parent_view = self.read_combined(
 600                 cr, uid, v.inherit_id.id, fields=fields, context=context)
 601             arch_tree = etree.fromstring(parent_view['arch'])
 602             self.apply_inheritance_specs(
 603                 cr, uid, arch_tree, view_arch, parent_view['id'], context=context)
 604
 605
 606         if context.get('inherit_branding'):
 607             arch_tree.attrib.update({
 608                 'data-oe-model': 'ir.ui.view',
 609                 'data-oe-id': str(root_id),
 610                 'data-oe-field': 'arch',
 611             })
 612
 613         # and apply inheritance
 614         arch = self.apply_view_inheritance(
 615             cr, uid, arch_tree, root_id, base.model, context=context)
 616
 617         return dict(view, arch=etree.tostring(arch, encoding='utf-8'))
 618
 619     #------------------------------------------------------
 620     # Postprocessing: translation, groups and modifiers
 621     #------------------------------------------------------
 622     # TODO:
 623     # - split postprocess so that it can be used instead of translate_qweb
 624     # - remove group processing from ir_qweb
 625     #------------------------------------------------------
 626     def postprocess(self, cr, user, model, node, view_id, in_tree_view, model_fields, context=None):
 627         """Return the description of the fields in the node.
 628
 629         In a normal call to this method, node is a complete view architecture
 630         but it is actually possible to give some sub-node (this is used so
 631         that the method can call itself recursively).
 632
 633         Originally, the field descriptions are drawn from the node itself.
 634         But there is now some code calling fields_get() in order to merge some
 635         of those information in the architecture.
 636
 637         """
 638         if context is None:
 639             context = {}
 640         result = False
 641         fields = {}
 642         children = True
 643
 644         modifiers = {}
 645         Model = self.pool.get(model)
 646         if Model is None:
 647             self.raise_view_error(cr, user, _('Model not found: %(model)s') % dict(model=model),
 648                                   view_id, context)
 649
 650         def encode(s):
 651             if isinstance(s, unicode):
 652                 return s.encode('utf8')
 653             return s
 654
 655         def check_group(node):
 656             """Apply group restrictions,  may be set at view level or model level::
 657                * at view level this means the element should be made invisible to
 658                  people who are not members
 659                * at model level (exclusively for fields, obviously), this means
 660                  the field should be completely removed from the view, as it is
 661                  completely unavailable for non-members
 662
 663                :return: True if field should be included in the result of fields_view_get
 664             """
 665             if node.tag == 'field' and node.get('name') in Model._fields:
 666                 field = Model._fields[node.get('name')]
 667                 if field.groups and not self.user_has_groups(
 668                         cr, user, groups=field.groups, context=context):
 669                     node.getparent().remove(node)
 670                     fields.pop(node.get('name'), None)
 671                     # no point processing view-level ``groups`` anymore, return
 672                     return False
 673             if node.get('groups'):
 674                 can_see = self.user_has_groups(
 675                     cr, user, groups=node.get('groups'), context=context)
 676                 if not can_see:
 677                     node.set('invisible', '1')
 678                     modifiers['invisible'] = True
 679                     if 'attrs' in node.attrib:
 680                         del(node.attrib['attrs']) #avoid making field visible later
 681                 del(node.attrib['groups'])
 682             return True
 683
 684         if node.tag in ('field', 'node', 'arrow'):
 685             if node.get('object'):
 686                 attrs = {}
 687                 views = {}
 688                 xml = "<form>"
 689                 for f in node:
 690                     if f.tag == 'field':
 691                         xml += etree.tostring(f, encoding="utf-8")
 692                 xml += "</form>"
 693                 new_xml = etree.fromstring(encode(xml))
 694                 ctx = context.copy()
 695                 ctx['base_model_name'] = model
 696                 xarch, xfields = self.postprocess_and_fields(cr, user, node.get('object'), new_xml, view_id, ctx)
 697                 views['form'] = {
 698                     'arch': xarch,
 699                     'fields': xfields
 700                 }
 701                 attrs = {'views': views}
 702                 fields = xfields
 703             if node.get('name'):
 704                 attrs = {}
 705                 field = Model._fields.get(node.get('name'))
 706                 if field:
 707                     children = False
 708                     views = {}
 709                     for f in node:
 710                         if f.tag in ('form', 'tree', 'graph', 'kanban', 'calendar'):
 711                             node.remove(f)
 712                             ctx = context.copy()
 713                             ctx['base_model_name'] = model
 714                             xarch, xfields = self.postprocess_and_fields(cr, user, field.comodel_name, f, view_id, ctx)
 715                             views[str(f.tag)] = {
 716                                 'arch': xarch,
 717                                 'fields': xfields
 718                             }
 719                     attrs = {'views': views}
 720                 fields[node.get('name')] = attrs
 721
 722                 field = model_fields.get(node.get('name'))
 723                 if field:
 724                     orm.transfer_field_to_modifiers(field, modifiers)
 725
 726         elif node.tag in ('form', 'tree'):
 727             result = Model.view_header_get(cr, user, False, node.tag, context)
 728             if result:
 729                 node.set('string', result)
 730             in_tree_view = node.tag == 'tree'
 731
 732         elif node.tag == 'calendar':
 733             for additional_field in ('date_start', 'date_delay', 'date_stop', 'color', 'all_day', 'attendee'):
 734                 if node.get(additional_field):
 735                     fields[node.get(additional_field)] = {}
 736
 737         if not check_group(node):
 738             # node must be removed, no need to proceed further with its children
 739             return fields
 740
 741         # The view architeture overrides the python model.
 742         # Get the attrs before they are (possibly) deleted by check_group below
 743         orm.transfer_node_to_modifiers(node, modifiers, context, in_tree_view)
 744
 745         # TODO remove attrs counterpart in modifiers when invisible is true ?
 746
 747         # translate view
 748         if 'lang' in context:
 749             Translations = self.pool['ir.translation']
 750             if node.text and node.text.strip():
 751                 term = node.text.strip()
 752                 trans = Translations._get_source(cr, user, model, 'view', context['lang'], term)
 753                 if trans:
 754                     node.text = node.text.replace(term, trans)
 755             if node.tail and node.tail.strip():
 756                 term = node.tail.strip()
 757                 trans = Translations._get_source(cr, user, model, 'view', context['lang'], term)
 758                 if trans:
 759                     node.tail =  node.tail.replace(term, trans)
 760
 761             if node.get('string') and node.get('string').strip() and not result:
 762                 term = node.get('string').strip()
 763                 trans = Translations._get_source(cr, user, model, 'view', context['lang'], term)
 764                 if trans == term and ('base_model_name' in context):
 765                     # If translation is same as source, perhaps we'd have more luck with the alternative model name
 766                     # (in case we are in a mixed situation, such as an inherited view where parent_view.model != model
 767                     trans = Translations._get_source(cr, user, context['base_model_name'], 'view', context['lang'], term)
 768                 if trans:
 769                     node.set('string', trans)
 770
 771             for attr_name in ('confirm', 'sum', 'avg', 'help', 'placeholder'):
 772                 attr_value = node.get(attr_name)
 773                 if attr_value and attr_value.strip():
 774                     trans = Translations._get_source(cr, user, model, 'view', context['lang'], attr_value.strip())
 775                     if trans:
 776                         node.set(attr_name, trans)
 777
 778         for f in node:
 779             if children or (node.tag == 'field' and f.tag in ('filter','separator')):
 780                 fields.update(self.postprocess(cr, user, model, f, view_id, in_tree_view, model_fields, context))
 781
 782         orm.transfer_modifiers_to_node(modifiers, node)
 783         return fields
 784
 785     def add_on_change(self, cr, user, model_name, arch):
 786         """ Add attribute on_change="1" on fields that are dependencies of
 787             computed fields on the same view.
 788         """
 789         # map each field object to its corresponding nodes in arch
 790         field_nodes = collections.defaultdict(list)
 791
 792         def collect(node, model):
 793             if node.tag == 'field':
 794                 field = model._fields.get(node.get('name'))
 795                 if field:
 796                     field_nodes[field].append(node)
 797                     if field.relational:
 798                         model = self.pool.get(field.comodel_name)
 799             for child in node:
 800                 collect(child, model)
 801
 802         collect(arch, self.pool[model_name])
 803
 804         for field, nodes in field_nodes.iteritems():
 805             # if field should trigger an onchange, add on_change="1" on the
 806             # nodes referring to field
 807             model = self.pool[field.model_name]
 808             if model._has_onchange(field, field_nodes):
 809                 for node in nodes:
 810                     if not node.get('on_change'):
 811                         node.set('on_change', '1')
 812
 813         return arch
 814
 815     def _disable_workflow_buttons(self, cr, user, model, node):
 816         """ Set the buttons in node to readonly if the user can't activate them. """
 817         if model is None or user == 1:
 818             # admin user can always activate workflow buttons
 819             return node
 820
 821         # TODO handle the case of more than one workflow for a model or multiple
 822         # transitions with different groups and same signal
 823         usersobj = self.pool.get('res.users')
 824         buttons = (n for n in node.getiterator('button') if n.get('type') != 'object')
 825         for button in buttons:
 826             user_groups = usersobj.read(cr, user, [user], ['groups_id'])[0]['groups_id']
 827             cr.execute("""SELECT DISTINCT t.group_id
 828                         FROM wkf
 829                   INNER JOIN wkf_activity a ON a.wkf_id = wkf.id
 830                   INNER JOIN wkf_transition t ON (t.act_to = a.id)
 831                        WHERE wkf.osv = %s
 832                          AND t.signal = %s
 833                          AND t.group_id is NOT NULL
 834                    """, (model, button.get('name')))
 835             group_ids = [x[0] for x in cr.fetchall() if x[0]]
 836             can_click = not group_ids or bool(set(user_groups).intersection(group_ids))
 837             button.set('readonly', str(int(not can_click)))
 838         return node
 839
 840     def postprocess_and_fields(self, cr, user, model, node, view_id, context=None):
 841         """ Return an architecture and a description of all the fields.
 842
 843         The field description combines the result of fields_get() and
 844         postprocess().
 845
 846         :param node: the architecture as as an etree
 847         :return: a tuple (arch, fields) where arch is the given node as a
 848             string and fields is the description of all the fields.
 849
 850         """
 851         fields = {}
 852         Model = self.pool.get(model)
 853         if Model is None:
 854             self.raise_view_error(cr, user, _('Model not found: %(model)s') % dict(model=model), view_id, context)
 855
 856         if node.tag == 'diagram':
 857             if node.getchildren()[0].tag == 'node':
 858                 node_model = self.pool[node.getchildren()[0].get('object')]
 859                 node_fields = node_model.fields_get(cr, user, None, context)
 860                 fields.update(node_fields)
 861                 if not node.get("create") and not node_model.check_access_rights(cr, user, 'create', raise_exception=False):
 862                     node.set("create", 'false')
 863             if node.getchildren()[1].tag == 'arrow':
 864                 arrow_fields = self.pool[node.getchildren()[1].get('object')].fields_get(cr, user, None, context)
 865                 fields.update(arrow_fields)
 866         else:
 867             fields = Model.fields_get(cr, user, None, context)
 868
 869         node = self.add_on_change(cr, user, model, node)
 870         fields_def = self.postprocess(cr, user, model, node, view_id, False, fields, context=context)
 871         node = self._disable_workflow_buttons(cr, user, model, node)
 872         if node.tag in ('kanban', 'tree', 'form', 'gantt'):
 873             for action, operation in (('create', 'create'), ('delete', 'unlink'), ('edit', 'write')):
 874                 if not node.get(action) and not Model.check_access_rights(cr, user, operation, raise_exception=False):
 875                     node.set(action, 'false')
 876         if node.tag in ('kanban'):
 877             group_by_name = node.get('default_group_by')
 878             if group_by_name in Model._fields:
 879                 group_by_field = Model._fields[group_by_name]
 880                 if group_by_field.type == 'many2one':
 881                     group_by_model = Model.pool[group_by_field.comodel_name]
 882                     for action, operation in (('group_create', 'create'), ('group_delete', 'unlink'), ('group_edit', 'write')):
 883                         if not node.get(action) and not group_by_model.check_access_rights(cr, user, operation, raise_exception=False):
 884                             node.set(action, 'false')
 885
 886         arch = etree.tostring(node, encoding="utf-8").replace('\t', '')
 887         for k in fields.keys():
 888             if k not in fields_def:
 889                 del fields[k]
 890         for field in fields_def:
 891             if field == 'id':
 892                 # sometime, the view may contain the (invisible) field 'id' needed for a domain (when 2 objects have cross references)
 893                 fields['id'] = {'readonly': True, 'type': 'integer', 'string': 'ID'}
 894             elif field in fields:
 895                 fields[field].update(fields_def[field])
 896             else:
 897                 message = _("Field `%(field_name)s` does not exist") % \
 898                                 dict(field_name=field)
 899                 self.raise_view_error(cr, user, message, view_id, context)
 900         return arch, fields
 901
 902     #------------------------------------------------------
 903     # QWeb template views
 904     #------------------------------------------------------
 905     _read_template_cache = dict(accepted_keys=('lang','inherit_branding', 'editable', 'translatable'))
 906     if config['dev_mode']:
 907         _read_template_cache['size'] = 0
 908     @tools.ormcache_context(**_read_template_cache)
 909     def _read_template(self, cr, uid, view_id, context=None):
 910         arch = self.read_combined(cr, uid, view_id, fields=['arch'], context=context)['arch']
 911         arch_tree = etree.fromstring(arch)
 912
 913         if 'lang' in context:
 914             arch_tree = self.translate_qweb(cr, uid, view_id, arch_tree, context['lang'], context)
 915
 916         self.distribute_branding(arch_tree)
 917         root = etree.Element('templates')
 918         root.append(arch_tree)
 919         arch = etree.tostring(root, encoding='utf-8', xml_declaration=True)
 920         return arch
 921
 922     def read_template(self, cr, uid, xml_id, context=None):
 923         if isinstance(xml_id, (int, long)):
 924             view_id = xml_id
 925         else:
 926             if '.' not in xml_id:
 927                 raise ValueError('Invalid template id: %r' % (xml_id,))
 928             view_id = self.get_view_id(cr, uid, xml_id, context=context)
 929         return self._read_template(cr, uid, view_id, context=context)
 930
 931     @tools.ormcache(skiparg=3)
 932     def get_view_id(self, cr, uid, xml_id, context=None):
 933         return self.pool['ir.model.data'].xmlid_to_res_id(cr, uid, xml_id, raise_if_not_found=True)
 934
 935     def clear_cache(self):
 936         self._read_template.clear_cache(self)
 937
 938     def _contains_branded(self, node):
 939         return node.tag == 't'\
 940             or 't-raw' in node.attrib\
 941             or any(self.is_node_branded(child) for child in node.iterdescendants())
 942
 943     def _pop_view_branding(self, element):
 944         distributed_branding = dict(
 945             (attribute, element.attrib.pop(attribute))
 946             for attribute in MOVABLE_BRANDING
 947             if element.get(attribute))
 948         return distributed_branding
 949
 950     def distribute_branding(self, e, branding=None, parent_xpath='',
 951                             index_map=misc.ConstantMapping(1)):
 952         if e.get('t-ignore') or e.tag == 'head':
 953             # remove any view branding possibly injected by inheritance
 954             attrs = set(MOVABLE_BRANDING)
 955             for descendant in e.iterdescendants(tag=etree.Element):
 956                 if not attrs.intersection(descendant.attrib): continue
 957                 self._pop_view_branding(descendant)
 958             # TODO: find a better name and check if we have a string to boolean helper
 959             return
 960
 961         node_path = e.get('data-oe-xpath')
 962         if node_path is None:
 963             node_path = "%s/%s[%d]" % (parent_xpath, e.tag, index_map[e.tag])
 964         if branding and not (e.get('data-oe-model') or e.get('t-field')):
 965             e.attrib.update(branding)
 966             e.set('data-oe-xpath', node_path)
 967         if not e.get('data-oe-model'): return
 968
 969         if {'t-esc', 't-raw'}.intersection(e.attrib):
 970             # nodes which fully generate their content and have no reason to
 971             # be branded because they can not sensibly be edited
 972             self._pop_view_branding(e)
 973         elif self._contains_branded(e):
 974             # if a branded element contains branded elements distribute own
 975             # branding to children unless it's t-raw, then just remove branding
 976             # on current element
 977             distributed_branding = self._pop_view_branding(e)
 978
 979             if 't-raw' not in e.attrib:
 980                 # TODO: collections.Counter if remove p2.6 compat
 981                 # running index by tag type, for XPath query generation
 982                 indexes = collections.defaultdict(lambda: 0)
 983                 for child in e.iterchildren(tag=etree.Element):
 984                     if child.get('data-oe-xpath'):
 985                         # injected by view inheritance, skip otherwise
 986                         # generated xpath is incorrect
 987                         self.distribute_branding(child)
 988                     else:
 989                         indexes[child.tag] += 1
 990                         self.distribute_branding(
 991                             child, distributed_branding,
 992                             parent_xpath=node_path, index_map=indexes)
 993
 994     def is_node_branded(self, node):
 995         """ Finds out whether a node is branded or qweb-active (bears a
 996         @data-oe-model or a @t-* *which is not t-field* as t-field does not
 997         section out views)
 998
 999         :param node: an etree-compatible element to test
1000         :type node: etree._Element
1001         :rtype: boolean
1002         """
1003         return any(
1004             (attr in ('data-oe-model', 'group') or (attr != 't-field' and attr.startswith('t-')))
1005             for attr in node.attrib
1006         )
1007
1008     def translate_qweb(self, cr, uid, id_, arch, lang, context=None):
1009         # TODO: this should be moved in a place before inheritance is applied
1010         #       but process() is only called on fields_view_get()
1011         Translations = self.pool['ir.translation']
1012         h = HTMLParser.HTMLParser()
1013         def get_trans(text):
1014             if not text or not text.strip():
1015                 return None
1016             text = h.unescape(text.strip())
1017             if len(text) < 2 or (text.startswith('<!') and text.endswith('>')):
1018                 return None
1019             return Translations._get_source(cr, uid, 'website', 'view', lang, text, id_)
1020
1021         if type(arch) not in SKIPPED_ELEMENT_TYPES and arch.tag not in SKIPPED_ELEMENTS:
1022             text = get_trans(arch.text)
1023             if text:
1024                 arch.text = arch.text.replace(arch.text.strip(), text)
1025             tail = get_trans(arch.tail)
1026             if tail:
1027                 arch.tail = arch.tail.replace(arch.tail.strip(), tail)
1028
1029             for attr_name in ('title', 'alt', 'label', 'placeholder'):
1030                 attr = get_trans(arch.get(attr_name))
1031                 if attr:
1032                     arch.set(attr_name, attr)
1033             for node in arch.iterchildren("*"):
1034                 self.translate_qweb(cr, uid, id_, node, lang, context)
1035         return arch
1036
1037     @openerp.tools.ormcache()
1038     def get_view_xmlid(self, cr, uid, id):
1039         imd = self.pool['ir.model.data']
1040         domain = [('model', '=', 'ir.ui.view'), ('res_id', '=', id)]
1041         xmlid = imd.search_read(cr, uid, domain, ['module', 'name'])[0]
1042         return '%s.%s' % (xmlid['module'], xmlid['name'])
1043
1044     @api.cr_uid_ids_context
1045     def render(self, cr, uid, id_or_xml_id, values=None, engine='ir.qweb', context=None):
1046         if isinstance(id_or_xml_id, list):
1047             id_or_xml_id = id_or_xml_id[0]
1048
1049         if not context:
1050             context = {}
1051
1052         if values is None:
1053             values = dict()
1054         qcontext = dict(
1055             keep_query=keep_query,
1056             request=request, # might be unbound if we're not in an httprequest context
1057             debug=request.debug if request else False,
1058             json=simplejson,
1059             quote_plus=werkzeug.url_quote_plus,
1060             time=time,
1061             datetime=datetime,
1062             relativedelta=relativedelta,
1063         )
1064         qcontext.update(values)
1065
1066         # TODO: This helper can be used by any template that wants to embedd the backend.
1067         #       It is currently necessary because the ir.ui.view bundle inheritance does not
1068         #       match the module dependency graph.
1069         def get_modules_order():
1070             if request:
1071                 from openerp.addons.web.controllers.main import module_boot
1072                 return simplejson.dumps(module_boot())
1073             return '[]'
1074         qcontext['get_modules_order'] = get_modules_order
1075
1076         def loader(name):
1077             return self.read_template(cr, uid, name, context=context)
1078
1079         return self.pool[engine].render(cr, uid, id_or_xml_id, qcontext, loader=loader, context=context)
1080
1081     #------------------------------------------------------
1082     # Misc
1083     #------------------------------------------------------
1084
1085     def graph_get(self, cr, uid, id, model, node_obj, conn_obj, src_node, des_node, label, scale, context=None):
1086         nodes=[]
1087         nodes_name=[]
1088         transitions=[]
1089         start=[]
1090         tres={}
1091         labels={}
1092         no_ancester=[]
1093         blank_nodes = []
1094
1095         _Model_Obj = self.pool[model]
1096         _Node_Obj = self.pool[node_obj]
1097         _Arrow_Obj = self.pool[conn_obj]
1098
1099         for model_key,model_value in _Model_Obj._columns.items():
1100                 if model_value._type=='one2many':
1101                     if model_value._obj==node_obj:
1102                         _Node_Field=model_key
1103                         _Model_Field=model_value._fields_id
1104                     flag=False
1105                     for node_key,node_value in _Node_Obj._columns.items():
1106                         if node_value._type=='one2many':
1107                              if node_value._obj==conn_obj:
1108                                  if src_node in _Arrow_Obj._columns and flag:
1109                                     _Source_Field=node_key
1110                                  if des_node in _Arrow_Obj._columns and not flag:
1111                                     _Destination_Field=node_key
1112                                     flag = True
1113
1114         datas = _Model_Obj.read(cr, uid, id, [],context)
1115         for a in _Node_Obj.read(cr,uid,datas[_Node_Field],[]):
1116             if a[_Source_Field] or a[_Destination_Field]:
1117                 nodes_name.append((a['id'],a['name']))
1118                 nodes.append(a['id'])
1119             else:
1120                 blank_nodes.append({'id': a['id'],'name':a['name']})
1121
1122             if a.has_key('flow_start') and a['flow_start']:
1123                 start.append(a['id'])
1124             else:
1125                 if not a[_Source_Field]:
1126                     no_ancester.append(a['id'])
1127             for t in _Arrow_Obj.read(cr,uid, a[_Destination_Field],[]):
1128                 transitions.append((a['id'], t[des_node][0]))
1129                 tres[str(t['id'])] = (a['id'],t[des_node][0])
1130                 label_string = ""
1131                 if label:
1132                     for lbl in eval(label):
1133                         if t.has_key(tools.ustr(lbl)) and tools.ustr(t[lbl])=='False':
1134                             label_string += ' '
1135                         else:
1136                             label_string = label_string + " " + tools.ustr(t[lbl])
1137                 labels[str(t['id'])] = (a['id'],label_string)
1138         g  = graph(nodes, transitions, no_ancester)
1139         g.process(start)
1140         g.scale(*scale)
1141         result = g.result_get()
1142         results = {}
1143         for node in nodes_name:
1144             results[str(node[0])] = result[node[0]]
1145             results[str(node[0])]['name'] = node[1]
1146         return {'nodes': results,
1147                 'transitions': tres,
1148                 'label' : labels,
1149                 'blank_nodes': blank_nodes,
1150                 'node_parent_field': _Model_Field,}
1151
1152     def _validate_custom_views(self, cr, uid, model):
1153         """Validate architecture of custom views (= without xml id) for a given model.
1154             This method is called at the end of registry update.
1155         """
1156         cr.execute("""SELECT max(v.id)
1157                         FROM ir_ui_view v
1158                    LEFT JOIN ir_model_data md ON (md.model = 'ir.ui.view' AND md.res_id = v.id)
1159                        WHERE md.module IS NULL
1160                          AND v.model = %s
1161                     GROUP BY coalesce(v.inherit_id, v.id)
1162                    """, (model,))
1163
1164         ids = map(itemgetter(0), cr.fetchall())
1165         return self._check_xml(cr, uid, ids)
1166
1167     def _validate_module_views(self, cr, uid, module):
1168         """Validate architecture of all the views of a given module"""
1169         assert not self.pool._init or module in self.pool._init_modules
1170         xmlid_filter = ''
1171         params = (module,)
1172         if self.pool._init:
1173             # only validate the views that are still existing...
1174             xmlid_filter = "AND md.name IN %s"
1175             names = tuple(name for (xmod, name), (model, res_id) in self.pool.model_data_reference_ids.items() if xmod == module and model == self._name)
1176             if not names:
1177                 # no views for this module, nothing to validate
1178                 return
1179             params += (names,)
1180         cr.execute("""SELECT max(v.id)
1181                         FROM ir_ui_view v
1182                    LEFT JOIN ir_model_data md ON (md.model = 'ir.ui.view' AND md.res_id = v.id)
1183                        WHERE md.module = %s
1184                          {0}
1185                     GROUP BY coalesce(v.inherit_id, v.id)
1186                    """.format(xmlid_filter), params)
1187
1188         for vid, in cr.fetchall():
1189             if not self._check_xml(cr, uid, [vid]):
1190                 self.raise_view_error(cr, uid, "Can't validate view", vid)
1191
1192 # vim:et: