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