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