addons/mail/mail_message.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2010-today OpenERP SA (<http://www.openerp.com>)
   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
  22 import logging
  23 from openerp import tools
  24
  25 from email.header import decode_header
  26 from openerp import SUPERUSER_ID
  27 from openerp.osv import osv, orm, fields
  28 from openerp.tools import html_email_clean
  29 from openerp.tools.translate import _
  30
  31 _logger = logging.getLogger(__name__)
  32
  33 try:
  34     from mako.template import Template as MakoTemplate
  35 except ImportError:
  36     _logger.warning("payment_acquirer: mako templates not available, payment acquirer will not work!")
  37
  38
  39 """ Some tools for parsing / creating email fields """
  40 def decode(text):
  41     """Returns unicode() string conversion of the the given encoded smtp header text"""
  42     if text:
  43         text = decode_header(text.replace('\r', ''))
  44         return ''.join([tools.ustr(x[0], x[1]) for x in text])
  45
  46
  47 class mail_message(osv.Model):
  48     """ Messages model: system notification (replacing res.log notifications),
  49         comments (OpenChatter discussion) and incoming emails. """
  50     _name = 'mail.message'
  51     _description = 'Message'
  52     _inherit = ['ir.needaction_mixin']
  53     _order = 'id desc'
  54     _rec_name = 'record_name'
  55
  56     _message_read_limit = 30
  57     _message_read_fields = ['id', 'parent_id', 'model', 'res_id', 'body', 'subject', 'date', 'to_read', 'email_from',
  58         'type', 'vote_user_ids', 'attachment_ids', 'author_id', 'partner_ids', 'record_name']
  59     _message_record_name_length = 18
  60     _message_read_more_limit = 1024
  61
  62     def default_get(self, cr, uid, fields, context=None):
  63         # protection for `default_type` values leaking from menu action context (e.g. for invoices)
  64         if context and context.get('default_type') and context.get('default_type') not in self._columns['type'].selection:
  65             context = dict(context, default_type=None)
  66         return super(mail_message, self).default_get(cr, uid, fields, context=context)
  67
  68     def _shorten_name(self, name):
  69         if len(name) <= (self._message_record_name_length + 3):
  70             return name
  71         return name[:self._message_record_name_length] + '...'
  72
  73     def _get_record_name(self, cr, uid, ids, name, arg, context=None):
  74         """ Return the related document name, using name_get. It is done using
  75             SUPERUSER_ID, to be sure to have the record name correctly stored. """
  76         # TDE note: regroup by model/ids, to have less queries to perform
  77         result = dict.fromkeys(ids, False)
  78         for message in self.read(cr, uid, ids, ['model', 'res_id'], context=context):
  79             if not message.get('model') or not message.get('res_id') or not self.pool.get(message['model']):
  80                 continue
  81             result[message['id']] = self.pool.get(message['model']).name_get(cr, SUPERUSER_ID, [message['res_id']], context=context)[0][1]
  82         return result
  83
  84     def _get_to_read(self, cr, uid, ids, name, arg, context=None):
  85         """ Compute if the message is unread by the current user. """
  86         res = dict((id, False) for id in ids)
  87         partner_id = self.pool.get('res.users').read(cr, uid, uid, ['partner_id'], context=context)['partner_id'][0]
  88         notif_obj = self.pool.get('mail.notification')
  89         notif_ids = notif_obj.search(cr, uid, [
  90             ('partner_id', 'in', [partner_id]),
  91             ('message_id', 'in', ids),
  92             ('read', '=', False),
  93         ], context=context)
  94         for notif in notif_obj.browse(cr, uid, notif_ids, context=context):
  95             res[notif.message_id.id] = True
  96         return res
  97
  98     def _search_to_read(self, cr, uid, obj, name, domain, context=None):
  99         """ Search for messages to read by the current user. Condition is
 100             inversed because we search unread message on a read column. """
 101         return ['&', ('notification_ids.partner_id.user_ids', 'in', [uid]), ('notification_ids.read', '=', not domain[0][2])]
 102
 103     def _get_starred(self, cr, uid, ids, name, arg, context=None):
 104         """ Compute if the message is unread by the current user. """
 105         res = dict((id, False) for id in ids)
 106         partner_id = self.pool.get('res.users').read(cr, uid, uid, ['partner_id'], context=context)['partner_id'][0]
 107         notif_obj = self.pool.get('mail.notification')
 108         notif_ids = notif_obj.search(cr, uid, [
 109             ('partner_id', 'in', [partner_id]),
 110             ('message_id', 'in', ids),
 111             ('starred', '=', True),
 112         ], context=context)
 113         for notif in notif_obj.browse(cr, uid, notif_ids, context=context):
 114             res[notif.message_id.id] = True
 115         return res
 116
 117     def _search_starred(self, cr, uid, obj, name, domain, context=None):
 118         """ Search for messages to read by the current user. Condition is
 119             inversed because we search unread message on a read column. """
 120         return ['&', ('notification_ids.partner_id.user_ids', 'in', [uid]), ('notification_ids.starred', '=', domain[0][2])]
 121
 122     def name_get(self, cr, uid, ids, context=None):
 123         # name_get may receive int id instead of an id list
 124         if isinstance(ids, (int, long)):
 125             ids = [ids]
 126         res = []
 127         for message in self.browse(cr, uid, ids, context=context):
 128             name = '%s: %s' % (message.subject or '', message.body or '')
 129             res.append((message.id, self._shorten_name(name.lstrip(' :'))))
 130         return res
 131
 132     _columns = {
 133         'type': fields.selection([
 134                         ('email', 'Email'),
 135                         ('comment', 'Comment'),
 136                         ('notification', 'System notification'),
 137                         ], 'Type',
 138             help="Message type: email for email message, notification for system "\
 139                  "message, comment for other messages such as user replies"),
 140         'email_from': fields.char('From',
 141             help="Email address of the sender. This field is set when no matching partner is found for incoming emails."),
 142         'author_id': fields.many2one('res.partner', 'Author', select=1,
 143             ondelete='set null',
 144             help="Author of the message. If not set, email_from may hold an email address that did not match any partner."),
 145         'partner_ids': fields.many2many('res.partner', string='Recipients'),
 146         'notified_partner_ids': fields.many2many('res.partner', 'mail_notification',
 147             'message_id', 'partner_id', 'Notified partners',
 148             help='Partners that have a notification pushing this message in their mailboxes'),
 149         'attachment_ids': fields.many2many('ir.attachment', 'message_attachment_rel',
 150             'message_id', 'attachment_id', 'Attachments'),
 151         'parent_id': fields.many2one('mail.message', 'Parent Message', select=True,
 152             ondelete='set null', help="Initial thread message."),
 153         'child_ids': fields.one2many('mail.message', 'parent_id', 'Child Messages'),
 154         'model': fields.char('Related Document Model', size=128, select=1),
 155         'res_id': fields.integer('Related Document ID', select=1),
 156         'record_name': fields.function(_get_record_name, type='char',
 157             store=True, string='Message Record Name',
 158             help="Name get of the related document."),
 159         'notification_ids': fields.one2many('mail.notification', 'message_id',
 160             string='Notifications', auto_join=True,
 161             help='Technical field holding the message notifications. Use notified_partner_ids to access notified partners.'),
 162         'subject': fields.char('Subject'),
 163         'date': fields.datetime('Date'),
 164         'message_id': fields.char('Message-Id', help='Message unique identifier', select=1, readonly=1),
 165         'body': fields.html('Contents', help='Automatically sanitized HTML contents'),
 166         'to_read': fields.function(_get_to_read, fnct_search=_search_to_read,
 167             type='boolean', string='To read',
 168             help='Current user has an unread notification linked to this message'),
 169         'starred': fields.function(_get_starred, fnct_search=_search_starred,
 170             type='boolean', string='Starred',
 171             help='Current user has a starred notification linked to this message'),
 172         'subtype_id': fields.many2one('mail.message.subtype', 'Subtype',
 173             ondelete='set null', select=1,),
 174         'vote_user_ids': fields.many2many('res.users', 'mail_vote',
 175             'message_id', 'user_id', string='Votes',
 176             help='Users that voted for this message'),
 177     }
 178
 179     def _needaction_domain_get(self, cr, uid, context=None):
 180         return [('to_read', '=', True)]
 181
 182     def _get_default_author(self, cr, uid, context=None):
 183         return self.pool.get('res.users').read(cr, uid, uid, ['partner_id'], context=context)['partner_id'][0]
 184
 185     _defaults = {
 186         'type': 'email',
 187         'date': lambda *a: fields.datetime.now(),
 188         'author_id': lambda self, cr, uid, ctx={}: self._get_default_author(cr, uid, ctx),
 189         'body': '',
 190     }
 191
 192     #------------------------------------------------------
 193     # Vote/Like
 194     #------------------------------------------------------
 195
 196     def vote_toggle(self, cr, uid, ids, context=None):
 197         ''' Toggles vote. Performed using read to avoid access rights issues.
 198             Done as SUPERUSER_ID because uid may vote for a message he cannot modify. '''
 199         for message in self.read(cr, uid, ids, ['vote_user_ids'], context=context):
 200             new_has_voted = not (uid in message.get('vote_user_ids'))
 201             if new_has_voted:
 202                 self.write(cr, SUPERUSER_ID, message.get('id'), {'vote_user_ids': [(4, uid)]}, context=context)
 203             else:
 204                 self.write(cr, SUPERUSER_ID, message.get('id'), {'vote_user_ids': [(3, uid)]}, context=context)
 205         return new_has_voted or False
 206
 207     #------------------------------------------------------
 208     # download an attachment
 209     #------------------------------------------------------
 210
 211     def download_attachment(self, cr, uid, id_message, attachment_id, context=None):
 212         """ Return the content of linked attachments. """
 213         message = self.browse(cr, uid, id_message, context=context)
 214         if attachment_id in [attachment.id for attachment in message.attachment_ids]:
 215             attachment = self.pool.get('ir.attachment').browse(cr, SUPERUSER_ID, attachment_id, context=context)
 216             if attachment.datas and attachment.datas_fname:
 217                 return {
 218                     'base64': attachment.datas,
 219                     'filename': attachment.datas_fname,
 220                 }
 221         return False
 222
 223     #------------------------------------------------------
 224     # Notification API
 225     #------------------------------------------------------
 226
 227     def set_message_read(self, cr, uid, msg_ids, read, create_missing=True, context=None):
 228         """ Set messages as (un)read. Technically, the notifications related
 229             to uid are set to (un)read. If for some msg_ids there are missing
 230             notifications (i.e. due to load more or thread parent fetching),
 231             they are created.
 232
 233             :param bool read: set notification as (un)read
 234             :param bool create_missing: create notifications for missing entries
 235                 (i.e. when acting on displayed messages not notified)
 236         """
 237         notification_obj = self.pool.get('mail.notification')
 238         user_pid = self.pool.get('res.users').read(cr, uid, uid, ['partner_id'], context=context)['partner_id'][0]
 239         domain = [('partner_id', '=', user_pid), ('message_id', 'in', msg_ids)]
 240         if not create_missing:
 241             domain += [('read', '=', not read)]
 242         notif_ids = notification_obj.search(cr, uid, domain, context=context)
 243
 244         # all message have notifications: already set them as (un)read
 245         if len(notif_ids) == len(msg_ids) or not create_missing:
 246             return notification_obj.write(cr, uid, notif_ids, {'read': read}, context=context)
 247
 248         # some messages do not have notifications: find which one, create notification, update read status
 249         notified_msg_ids = [notification.message_id.id for notification in notification_obj.browse(cr, uid, notif_ids, context=context)]
 250         to_create_msg_ids = list(set(msg_ids) - set(notified_msg_ids))
 251         for msg_id in to_create_msg_ids:
 252             notification_obj.create(cr, uid, {'partner_id': user_pid, 'read': read, 'message_id': msg_id}, context=context)
 253         return notification_obj.write(cr, uid, notif_ids, {'read': read}, context=context)
 254
 255     def set_message_starred(self, cr, uid, msg_ids, starred, create_missing=True, context=None):
 256         """ Set messages as (un)starred. Technically, the notifications related
 257             to uid are set to (un)starred.
 258
 259             :param bool starred: set notification as (un)starred
 260             :param bool create_missing: create notifications for missing entries
 261                 (i.e. when acting on displayed messages not notified)
 262         """
 263         notification_obj = self.pool.get('mail.notification')
 264         user_pid = self.pool.get('res.users').read(cr, uid, uid, ['partner_id'], context=context)['partner_id'][0]
 265         domain = [('partner_id', '=', user_pid), ('message_id', 'in', msg_ids)]
 266         if not create_missing:
 267             domain += [('starred', '=', not starred)]
 268         values = {
 269             'starred': starred
 270         }
 271         if starred:
 272             values['read'] = False
 273
 274         notif_ids = notification_obj.search(cr, uid, domain, context=context)
 275
 276         # all message have notifications: already set them as (un)starred
 277         if len(notif_ids) == len(msg_ids) or not create_missing:
 278             notification_obj.write(cr, uid, notif_ids, values, context=context)
 279             return starred
 280
 281         # some messages do not have notifications: find which one, create notification, update starred status
 282         notified_msg_ids = [notification.message_id.id for notification in notification_obj.browse(cr, uid, notif_ids, context=context)]
 283         to_create_msg_ids = list(set(msg_ids) - set(notified_msg_ids))
 284         for msg_id in to_create_msg_ids:
 285             notification_obj.create(cr, uid, dict(values, partner_id=user_pid, message_id=msg_id), context=context)
 286         notification_obj.write(cr, uid, notif_ids, values, context=context)
 287         return starred
 288
 289     #------------------------------------------------------
 290     # Message loading for web interface
 291     #------------------------------------------------------
 292
 293     def _message_read_dict_postprocess(self, cr, uid, messages, message_tree, context=None):
 294         """ Post-processing on values given by message_read. This method will
 295             handle partners in batch to avoid doing numerous queries.
 296
 297             :param list messages: list of message, as get_dict result
 298             :param dict message_tree: {[msg.id]: msg browse record}
 299         """
 300         res_partner_obj = self.pool.get('res.partner')
 301         ir_attachment_obj = self.pool.get('ir.attachment')
 302         pid = self.pool.get('res.users').read(cr, uid, uid, ['partner_id'], context=None)['partner_id'][0]
 303
 304         # 1. Aggregate partners (author_id and partner_ids) and attachments
 305         partner_ids = set()
 306         attachment_ids = set()
 307         for key, message in message_tree.iteritems():
 308             if message.author_id:
 309                 partner_ids |= set([message.author_id.id])
 310             if message.notified_partner_ids:
 311                 partner_ids |= set([partner.id for partner in message.notified_partner_ids])
 312             if message.attachment_ids:
 313                 attachment_ids |= set([attachment.id for attachment in message.attachment_ids])
 314         # Read partners as SUPERUSER -> display the names like classic m2o even if no access
 315         partners = res_partner_obj.name_get(cr, SUPERUSER_ID, list(partner_ids), context=context)
 316         partner_tree = dict((partner[0], partner) for partner in partners)
 317
 318         # 2. Attachments as SUPERUSER, because could receive msg and attachments for doc uid cannot see
 319         attachments = ir_attachment_obj.read(cr, SUPERUSER_ID, list(attachment_ids), ['id', 'datas_fname', 'name'], context=context)
 320         attachments_tree = dict((attachment['id'], {'id': attachment['id'], 'filename': attachment['datas_fname'], 'name': attachment['name']}) for attachment in attachments)
 321
 322         # 3. Update message dictionaries
 323         for message_dict in messages:
 324             message_id = message_dict.get('id')
 325             message = message_tree[message_id]
 326             if message.author_id:
 327                 author = partner_tree[message.author_id.id]
 328             else:
 329                 author = (0, message.email_from)
 330             partner_ids = []
 331             for partner in message.notified_partner_ids:
 332                 if partner.id in partner_tree:
 333                     partner_ids.append(partner_tree[partner.id])
 334             attachment_ids = []
 335             for attachment in message.attachment_ids:
 336                 if attachment.id in attachments_tree:
 337                     attachment_ids.append(attachments_tree[attachment.id])
 338             message_dict.update({
 339                 'is_author': pid == author[0],
 340                 'author_id': author,
 341                 'partner_ids': partner_ids,
 342                 'attachment_ids': attachment_ids,
 343                 })
 344         return True
 345
 346     def _message_read_dict(self, cr, uid, message, parent_id=False, context=None):
 347         """ Return a dict representation of the message. This representation is
 348             used in the JS client code, to display the messages. Partners and
 349             attachments related stuff will be done in post-processing in batch.
 350
 351             :param dict message: mail.message browse record
 352         """
 353         # private message: no model, no res_id
 354         is_private = False
 355         if not message.model or not message.res_id:
 356             is_private = True
 357         # votes and favorites: res.users ids, no prefetching should be done
 358         vote_nb = len(message.vote_user_ids)
 359         has_voted = uid in [user.id for user in message.vote_user_ids]
 360
 361         try:
 362             body_html = html_email_clean(message.body)
 363         except Exception:
 364             body_html = '<p><b>Encoding Error : </b><br/>Unable to convert this message (id: %s).</p>' % message.id
 365             _logger.exception(Exception)
 366
 367         return {'id': message.id,
 368                 'type': message.type,
 369                 'body': body_html,
 370                 'model': message.model,
 371                 'res_id': message.res_id,
 372                 'record_name': message.record_name,
 373                 'subject': message.subject,
 374                 'date': message.date,
 375                 'to_read': message.to_read,
 376                 'parent_id': parent_id,
 377                 'is_private': is_private,
 378                 'author_id': False,
 379                 'is_author': False,
 380                 'partner_ids': [],
 381                 'vote_nb': vote_nb,
 382                 'has_voted': has_voted,
 383                 'is_favorite': message.starred,
 384                 'attachment_ids': [],
 385             }
 386
 387     def _message_read_add_expandables(self, cr, uid, messages, message_tree, parent_tree,
 388             message_unload_ids=[], thread_level=0, domain=[], parent_id=False, context=None):
 389         """ Create expandables for message_read, to load new messages.
 390             1. get the expandable for new threads
 391                 if display is flat (thread_level == 0):
 392                     fetch message_ids < min(already displayed ids), because we
 393                     want a flat display, ordered by id
 394                 else:
 395                     fetch message_ids that are not childs of already displayed
 396                     messages
 397             2. get the expandables for new messages inside threads if display
 398                is not flat
 399                 for each thread header, search for its childs
 400                     for each hole in the child list based on message displayed,
 401                     create an expandable
 402
 403             :param list messages: list of message structure for the Chatter
 404                 widget to which expandables are added
 405             :param dict message_tree: dict [id]: browse record of this message
 406             :param dict parent_tree: dict [parent_id]: [child_ids]
 407             :param list message_unload_ids: list of message_ids we do not want
 408                 to load
 409             :return bool: True
 410         """
 411         def _get_expandable(domain, message_nb, parent_id, max_limit):
 412             return {
 413                 'domain': domain,
 414                 'nb_messages': message_nb,
 415                 'type': 'expandable',
 416                 'parent_id': parent_id,
 417                 'max_limit':  max_limit,
 418             }
 419
 420         if not messages:
 421             return True
 422         message_ids = sorted(message_tree.keys())
 423
 424         # 1. get the expandable for new threads
 425         if thread_level == 0:
 426             exp_domain = domain + [('id', '<', min(message_unload_ids + message_ids))]
 427         else:
 428             exp_domain = domain + ['!', ('id', 'child_of', message_unload_ids + parent_tree.keys())]
 429         ids = self.search(cr, uid, exp_domain, context=context, limit=1)
 430         if ids:
 431             # inside a thread: prepend
 432             if parent_id:
 433                 messages.insert(0, _get_expandable(exp_domain, -1, parent_id, True))
 434             # new threads: append
 435             else:
 436                 messages.append(_get_expandable(exp_domain, -1, parent_id, True))
 437
 438         # 2. get the expandables for new messages inside threads if display is not flat
 439         if thread_level == 0:
 440             return True
 441         for message_id in message_ids:
 442             message = message_tree[message_id]
 443
 444             # generate only for thread header messages (TDE note: parent_id may be False is uid cannot see parent_id, seems ok)
 445             if message.parent_id:
 446                 continue
 447
 448             # check there are message for expandable
 449             child_ids = set([child.id for child in message.child_ids]) - set(message_unload_ids)
 450             child_ids = sorted(list(child_ids), reverse=True)
 451             if not child_ids:
 452                 continue
 453
 454             # make groups of unread messages
 455             id_min, id_max, nb = max(child_ids), 0, 0
 456             for child_id in child_ids:
 457                 if not child_id in message_ids:
 458                     nb += 1
 459                     if id_min > child_id:
 460                         id_min = child_id
 461                     if id_max < child_id:
 462                         id_max = child_id
 463                 elif nb > 0:
 464                     exp_domain = [('id', '>=', id_min), ('id', '<=', id_max), ('id', 'child_of', message_id)]
 465                     idx = [msg.get('id') for msg in messages].index(child_id) + 1
 466                     # messages.append(_get_expandable(exp_domain, nb, message_id, False))
 467                     messages.insert(idx, _get_expandable(exp_domain, nb, message_id, False))
 468                     id_min, id_max, nb = max(child_ids), 0, 0
 469                 else:
 470                     id_min, id_max, nb = max(child_ids), 0, 0
 471             if nb > 0:
 472                 exp_domain = [('id', '>=', id_min), ('id', '<=', id_max), ('id', 'child_of', message_id)]
 473                 idx = [msg.get('id') for msg in messages].index(message_id) + 1
 474                 # messages.append(_get_expandable(exp_domain, nb, message_id, id_min))
 475                 messages.insert(idx, _get_expandable(exp_domain, nb, message_id, False))
 476
 477         return True
 478
 479     def message_read(self, cr, uid, ids=None, domain=None, message_unload_ids=None,
 480                         thread_level=0, context=None, parent_id=False, limit=None):
 481         """ Read messages from mail.message, and get back a list of structured
 482             messages to be displayed as discussion threads. If IDs is set,
 483             fetch these records. Otherwise use the domain to fetch messages.
 484             After having fetch messages, their ancestors will be added to obtain
 485             well formed threads, if uid has access to them.
 486
 487             After reading the messages, expandable messages are added in the
 488             message list (see ``_message_read_add_expandables``). It consists
 489             in messages holding the 'read more' data: number of messages to
 490             read, domain to apply.
 491
 492             :param list ids: optional IDs to fetch
 493             :param list domain: optional domain for searching ids if ids not set
 494             :param list message_unload_ids: optional ids we do not want to fetch,
 495                 because i.e. they are already displayed somewhere
 496             :param int parent_id: context of parent_id
 497                 - if parent_id reached when adding ancestors, stop going further
 498                   in the ancestor search
 499                 - if set in flat mode, ancestor_id is set to parent_id
 500             :param int limit: number of messages to fetch, before adding the
 501                 ancestors and expandables
 502             :return list: list of message structure for the Chatter widget
 503         """
 504         assert thread_level in [0, 1], 'message_read() thread_level should be 0 (flat) or 1 (1 level of thread); given %s.' % thread_level
 505         domain = domain if domain is not None else []
 506         message_unload_ids = message_unload_ids if message_unload_ids is not None else []
 507         if message_unload_ids:
 508             domain += [('id', 'not in', message_unload_ids)]
 509         notification_obj = self.pool.get('mail.notification')
 510         limit = limit or self._message_read_limit
 511         message_tree = {}
 512         message_list = []
 513         parent_tree = {}
 514
 515         # no specific IDS given: fetch messages according to the domain, add their parents if uid has access to
 516         if ids is None:
 517             ids = self.search(cr, uid, domain, context=context, limit=limit)
 518
 519         # fetch parent if threaded, sort messages
 520         for message in self.browse(cr, uid, ids, context=context):
 521             message_id = message.id
 522             if message_id in message_tree:
 523                 continue
 524             message_tree[message_id] = message
 525
 526             # find parent_id
 527             if thread_level == 0:
 528                 tree_parent_id = parent_id
 529             else:
 530                 tree_parent_id = message_id
 531                 parent = message
 532                 while parent.parent_id and parent.parent_id.id != parent_id:
 533                     parent = parent.parent_id
 534                     tree_parent_id = parent.id
 535                 if not parent.id in message_tree:
 536                     message_tree[parent.id] = parent
 537             # newest messages first
 538             parent_tree.setdefault(tree_parent_id, [])
 539             if tree_parent_id != message_id:
 540                 parent_tree[tree_parent_id].append(self._message_read_dict(cr, uid, message_tree[message_id], parent_id=tree_parent_id, context=context))
 541
 542         if thread_level:
 543             for key, message_id_list in parent_tree.iteritems():
 544                 message_id_list.sort(key=lambda item: item['id'])
 545                 message_id_list.insert(0, self._message_read_dict(cr, uid, message_tree[key], context=context))
 546
 547         # create final ordered message_list based on parent_tree
 548         parent_list = parent_tree.items()
 549         parent_list = sorted(parent_list, key=lambda item: max([msg.get('id') for msg in item[1]]) if item[1] else item[0], reverse=True)
 550         message_list = [message for (key, msg_list) in parent_list for message in msg_list]
 551
 552         # get the child expandable messages for the tree
 553         self._message_read_dict_postprocess(cr, uid, message_list, message_tree, context=context)
 554         self._message_read_add_expandables(cr, uid, message_list, message_tree, parent_tree,
 555             thread_level=thread_level, message_unload_ids=message_unload_ids, domain=domain, parent_id=parent_id, context=context)
 556         return message_list
 557
 558     #------------------------------------------------------
 559     # mail_message internals
 560     #------------------------------------------------------
 561
 562     def init(self, cr):
 563         cr.execute("""SELECT indexname FROM pg_indexes WHERE indexname = 'mail_message_model_res_id_idx'""")
 564         if not cr.fetchone():
 565             cr.execute("""CREATE INDEX mail_message_model_res_id_idx ON mail_message (model, res_id)""")
 566
 567     def _find_allowed_model_wise(self, cr, uid, doc_model, doc_dict, context=None):
 568         doc_ids = doc_dict.keys()
 569         allowed_doc_ids = self.pool.get(doc_model).search(cr, uid, [('id', 'in', doc_ids)], context=context)
 570         return set([message_id for allowed_doc_id in allowed_doc_ids for message_id in doc_dict[allowed_doc_id]])
 571
 572     def _find_allowed_doc_ids(self, cr, uid, model_ids, context=None):
 573         model_access_obj = self.pool.get('ir.model.access')
 574         allowed_ids = set()
 575         for doc_model, doc_dict in model_ids.iteritems():
 576             if not model_access_obj.check(cr, uid, doc_model, 'read', False):
 577                 continue
 578             allowed_ids |= self._find_allowed_model_wise(cr, uid, doc_model, doc_dict, context=context)
 579         return allowed_ids
 580
 581     def _search(self, cr, uid, args, offset=0, limit=None, order=None,
 582         context=None, count=False, access_rights_uid=None):
 583         """ Override that adds specific access rights of mail.message, to remove
 584             ids uid could not see according to our custom rules. Please refer
 585             to check_access_rule for more details about those rules.
 586
 587             After having received ids of a classic search, keep only:
 588             - if author_id == pid, uid is the author, OR
 589             - a notification (id, pid) exists, uid has been notified, OR
 590             - uid have read access to the related document is model, res_id
 591             - otherwise: remove the id
 592         """
 593         # Rules do not apply to administrator
 594         if uid == SUPERUSER_ID:
 595             return super(mail_message, self)._search(cr, uid, args, offset=offset, limit=limit, order=order,
 596                 context=context, count=count, access_rights_uid=access_rights_uid)
 597         # Perform a super with count as False, to have the ids, not a counter
 598         ids = super(mail_message, self)._search(cr, uid, args, offset=offset, limit=limit, order=order,
 599             context=context, count=False, access_rights_uid=access_rights_uid)
 600         if not ids and count:
 601             return 0
 602         elif not ids:
 603             return ids
 604
 605         pid = self.pool.get('res.users').read(cr, uid, uid, ['partner_id'])['partner_id'][0]
 606         author_ids, partner_ids, allowed_ids = set([]), set([]), set([])
 607         model_ids = {}
 608
 609         messages = super(mail_message, self).read(cr, uid, ids, ['author_id', 'model', 'res_id', 'notified_partner_ids'], context=context)
 610         for message in messages:
 611             if message.get('author_id') and message.get('author_id')[0] == pid:
 612                 author_ids.add(message.get('id'))
 613             elif pid in message.get('notified_partner_ids'):
 614                 partner_ids.add(message.get('id'))
 615             elif message.get('model') and message.get('res_id'):
 616                 model_ids.setdefault(message.get('model'), {}).setdefault(message.get('res_id'), set()).add(message.get('id'))
 617
 618         allowed_ids = self._find_allowed_doc_ids(cr, uid, model_ids, context=context)
 619         final_ids = author_ids | partner_ids | allowed_ids
 620
 621         if count:
 622             return len(final_ids)
 623         else:
 624             # re-construct a list based on ids, because set did not keep the original order
 625             id_list = [id for id in ids if id in final_ids]
 626             return id_list
 627
 628     def check_access_rule(self, cr, uid, ids, operation, context=None):
 629         """ Access rules of mail.message:
 630             - read: if
 631                 - author_id == pid, uid is the author, OR
 632                 - mail_notification (id, pid) exists, uid has been notified, OR
 633                 - uid have read access to the related document if model, res_id
 634                 - otherwise: raise
 635             - create: if
 636                 - no model, no res_id, I create a private message OR
 637                 - pid in message_follower_ids if model, res_id OR
 638                 - mail_notification (parent_id.id, pid) exists, uid has been notified of the parent, OR
 639                 - uid have write access on the related document if model, res_id, OR
 640                 - otherwise: raise
 641             - write: if
 642                 - author_id == pid, uid is the author, OR
 643                 - uid has write access on the related document if model, res_id
 644                 - otherwise: raise
 645             - unlink: if
 646                 - uid has write access on the related document if model, res_id
 647                 - otherwise: raise
 648         """
 649         def _generate_model_record_ids(msg_val, msg_ids=[]):
 650             """ :param model_record_ids: {'model': {'res_id': (msg_id, msg_id)}, ... }
 651                 :param message_values: {'msg_id': {'model': .., 'res_id': .., 'author_id': ..}}
 652             """
 653             model_record_ids = {}
 654             for id in msg_ids:
 655                 if msg_val[id]['model'] and msg_val[id]['res_id']:
 656                     model_record_ids.setdefault(msg_val[id]['model'], dict()).setdefault(msg_val[id]['res_id'], set()).add(msg_val[id]['res_id'])
 657             return model_record_ids
 658
 659         if uid == SUPERUSER_ID:
 660             return
 661         if isinstance(ids, (int, long)):
 662             ids = [ids]
 663         not_obj = self.pool.get('mail.notification')
 664         fol_obj = self.pool.get('mail.followers')
 665         partner_id = self.pool.get('res.users').read(cr, uid, uid, ['partner_id'], context=None)['partner_id'][0]
 666
 667         # Read mail_message.ids to have their values
 668         message_values = dict.fromkeys(ids)
 669         cr.execute('SELECT DISTINCT id, model, res_id, author_id, parent_id FROM "%s" WHERE id = ANY (%%s)' % self._table, (ids,))
 670         for id, rmod, rid, author_id, parent_id in cr.fetchall():
 671             message_values[id] = {'model': rmod, 'res_id': rid, 'author_id': author_id, 'parent_id': parent_id}
 672
 673         # Author condition (READ, WRITE, CREATE (private)) -> could become an ir.rule ?
 674         author_ids = []
 675         if operation == 'read' or operation == 'write':
 676             author_ids = [mid for mid, message in message_values.iteritems()
 677                 if message.get('author_id') and message.get('author_id') == partner_id]
 678         elif operation == 'create':
 679             author_ids = [mid for mid, message in message_values.iteritems()
 680                 if not message.get('model') and not message.get('res_id')]
 681
 682         # Parent condition, for create (check for received notifications for the created message parent)
 683         notified_ids = []
 684         if operation == 'create':
 685             parent_ids = [message.get('parent_id') for mid, message in message_values.iteritems()
 686                 if message.get('parent_id')]
 687             not_ids = not_obj.search(cr, SUPERUSER_ID, [('message_id.id', 'in', parent_ids), ('partner_id', '=', partner_id)], context=context)
 688             not_parent_ids = [notif.message_id.id for notif in not_obj.browse(cr, SUPERUSER_ID, not_ids, context=context)]
 689             notified_ids += [mid for mid, message in message_values.iteritems()
 690                 if message.get('parent_id') in not_parent_ids]
 691
 692         # Notification condition, for read (check for received notifications and create (in message_follower_ids)) -> could become an ir.rule, but not till we do not have a many2one variable field
 693         other_ids = set(ids).difference(set(author_ids), set(notified_ids))
 694         model_record_ids = _generate_model_record_ids(message_values, other_ids)
 695         if operation == 'read':
 696             not_ids = not_obj.search(cr, SUPERUSER_ID, [
 697                 ('partner_id', '=', partner_id),
 698                 ('message_id', 'in', ids),
 699             ], context=context)
 700             notified_ids = [notification.message_id.id for notification in not_obj.browse(cr, SUPERUSER_ID, not_ids, context=context)]
 701         elif operation == 'create':
 702             for doc_model, doc_dict in model_record_ids.items():
 703                 fol_ids = fol_obj.search(cr, SUPERUSER_ID, [
 704                     ('res_model', '=', doc_model),
 705                     ('res_id', 'in', list(doc_dict.keys())),
 706                     ('partner_id', '=', partner_id),
 707                     ], context=context)
 708                 fol_mids = [follower.res_id for follower in fol_obj.browse(cr, SUPERUSER_ID, fol_ids, context=context)]
 709                 notified_ids += [mid for mid, message in message_values.iteritems()
 710                     if message.get('model') == doc_model and message.get('res_id') in fol_mids]
 711
 712         # CRUD: Access rights related to the document
 713         other_ids = other_ids.difference(set(notified_ids))
 714         model_record_ids = _generate_model_record_ids(message_values, other_ids)
 715         document_related_ids = []
 716         for model, doc_dict in model_record_ids.items():
 717             model_obj = self.pool.get(model)
 718             mids = model_obj.exists(cr, uid, doc_dict.keys())
 719             if operation in ['create', 'write', 'unlink']:
 720                 model_obj.check_access_rights(cr, uid, 'write')
 721                 model_obj.check_access_rule(cr, uid, mids, 'write', context=context)
 722             else:
 723                 model_obj.check_access_rights(cr, uid, operation)
 724                 model_obj.check_access_rule(cr, uid, mids, operation, context=context)
 725             document_related_ids += [mid for mid, message in message_values.iteritems()
 726                 if message.get('model') == model and message.get('res_id') in mids]
 727
 728         # Calculate remaining ids: if not void, raise an error
 729         other_ids = other_ids.difference(set(document_related_ids))
 730         if not other_ids:
 731             return
 732         raise orm.except_orm(_('Access Denied'),
 733                             _('The requested operation cannot be completed due to security restrictions. Please contact your system administrator.\n\n(Document type: %s, Operation: %s)') % \
 734                             (self._description, operation))
 735
 736     def create(self, cr, uid, values, context=None):
 737         if context is None:
 738             context = {}
 739         default_starred = context.pop('default_starred', False)
 740         if not values.get('message_id') and values.get('res_id') and values.get('model'):
 741             values['message_id'] = tools.generate_tracking_message_id('%(res_id)s-%(model)s' % values)
 742         elif not values.get('message_id'):
 743             values['message_id'] = tools.generate_tracking_message_id('private')
 744         newid = super(mail_message, self).create(cr, uid, values, context)
 745         self._notify(cr, uid, newid, context=context)
 746         # TDE FIXME: handle default_starred. Why not setting an inv on starred ?
 747         # Because starred will call set_message_starred, that looks for notifications.
 748         # When creating a new mail_message, it will create a notification to a message
 749         # that does not exist, leading to an error (key not existing). Also this
 750         # this means unread notifications will be created, yet we can not assure
 751         # this is what we want.
 752         if default_starred:
 753             self.set_message_starred(cr, uid, [newid], True, context=context)
 754         return newid
 755
 756     def read(self, cr, uid, ids, fields=None, context=None, load='_classic_read'):
 757         """ Override to explicitely call check_access_rule, that is not called
 758             by the ORM. It instead directly fetches ir.rules and apply them. """
 759         self.check_access_rule(cr, uid, ids, 'read', context=context)
 760         res = super(mail_message, self).read(cr, uid, ids, fields=fields, context=context, load=load)
 761         return res
 762
 763     def unlink(self, cr, uid, ids, context=None):
 764         # cascade-delete attachments that are directly attached to the message (should only happen
 765         # for mail.messages that act as parent for a standalone mail.mail record).
 766         self.check_access_rule(cr, uid, ids, 'unlink', context=context)
 767         attachments_to_delete = []
 768         for message in self.browse(cr, uid, ids, context=context):
 769             for attach in message.attachment_ids:
 770                 if attach.res_model == self._name and attach.res_id == message.id:
 771                     attachments_to_delete.append(attach.id)
 772         if attachments_to_delete:
 773             self.pool.get('ir.attachment').unlink(cr, uid, attachments_to_delete, context=context)
 774         return super(mail_message, self).unlink(cr, uid, ids, context=context)
 775
 776     def copy(self, cr, uid, id, default=None, context=None):
 777         """ Overridden to avoid duplicating fields that are unique to each email """
 778         if default is None:
 779             default = {}
 780         default.update(message_id=False, headers=False)
 781         return super(mail_message, self).copy(cr, uid, id, default=default, context=context)
 782
 783     #------------------------------------------------------
 784     # Messaging API
 785     #------------------------------------------------------
 786
 787     # TDE note: this code is not used currently, will be improved in a future merge, when quoted context
 788     # will be added to email send for notifications. Currently only WIP.
 789     MAIL_TEMPLATE = """<div>
 790     % if message:
 791         ${display_message(message)}
 792     % endif
 793     % for ctx_msg in context_messages:
 794         ${display_message(ctx_msg)}
 795     % endfor
 796     % if add_expandable:
 797         ${display_expandable()}
 798     % endif
 799     ${display_message(header_message)}
 800     </div>
 801
 802     <%def name="display_message(message)">
 803         <div>
 804             Subject: ${message.subject}<br />
 805             Body: ${message.body}
 806         </div>
 807     </%def>
 808
 809     <%def name="display_expandable()">
 810         <div>This is an expandable.</div>
 811     </%def>
 812     """
 813
 814     def message_quote_context(self, cr, uid, id, context=None, limit=3, add_original=False):
 815         """
 816             1. message.parent_id = False: new thread, no quote_context
 817             2. get the lasts messages in the thread before message
 818             3. get the message header
 819             4. add an expandable between them
 820
 821             :param dict quote_context: options for quoting
 822             :return string: html quote
 823         """
 824         add_expandable = False
 825
 826         message = self.browse(cr, uid, id, context=context)
 827         if not message.parent_id:
 828             return ''
 829         context_ids = self.search(cr, uid, [
 830             ('parent_id', '=', message.parent_id.id),
 831             ('id', '<', message.id),
 832             ], limit=limit, context=context)
 833
 834         if len(context_ids) >= limit:
 835             add_expandable = True
 836             context_ids = context_ids[0:-1]
 837
 838         context_ids.append(message.parent_id.id)
 839         context_messages = self.browse(cr, uid, context_ids, context=context)
 840         header_message = context_messages.pop()
 841
 842         try:
 843             if not add_original:
 844                 message = False
 845             result = MakoTemplate(self.MAIL_TEMPLATE).render_unicode(message=message,
 846                                                         context_messages=context_messages,
 847                                                         header_message=header_message,
 848                                                         add_expandable=add_expandable,
 849                                                         # context kw would clash with mako internals
 850                                                         ctx=context,
 851                                                         format_exceptions=True)
 852             result = result.strip()
 853             return result
 854         except Exception:
 855             _logger.exception("failed to render mako template for quoting message")
 856             return ''
 857         return result
 858
 859     def _notify(self, cr, uid, newid, context=None):
 860         """ Add the related record followers to the destination partner_ids if is not a private message.
 861             Call mail_notification.notify to manage the email sending
 862         """
 863         notification_obj = self.pool.get('mail.notification')
 864         message = self.browse(cr, uid, newid, context=context)
 865
 866         partners_to_notify = set([])
 867         # message has no subtype_id: pure log message -> no partners, no one notified
 868         if not message.subtype_id:
 869             return True
 870
 871         # all followers of the mail.message document have to be added as partners and notified
 872         if message.model and message.res_id:
 873             fol_obj = self.pool.get("mail.followers")
 874             # browse as SUPERUSER because rules could restrict the search results
 875             fol_ids = fol_obj.search(cr, SUPERUSER_ID, [
 876                 ('res_model', '=', message.model),
 877                 ('res_id', '=', message.res_id),
 878                 ('subtype_ids', 'in', message.subtype_id.id)
 879                 ], context=context)
 880             partners_to_notify |= set(fo.partner_id for fo in fol_obj.browse(cr, SUPERUSER_ID, fol_ids, context=context))
 881         # remove me from notified partners, unless the message is written on my own wall
 882         if message.author_id and message.model == "res.partner" and message.res_id == message.author_id.id:
 883             partners_to_notify |= set([message.author_id])
 884         elif message.author_id:
 885             partners_to_notify -= set([message.author_id])
 886
 887         # all partner_ids of the mail.message have to be notified regardless of the above (even the author if explicitly added!)
 888         if message.partner_ids:
 889             partners_to_notify |= set(message.partner_ids)
 890
 891         # notify
 892         if partners_to_notify:
 893             notification_obj._notify(cr, uid, newid, partners_to_notify=[p.id for p in partners_to_notify], context=context)
 894         message.refresh()
 895
 896         # An error appear when a user receive a notification without notifying
 897         # the parent message -> add a read notification for the parent
 898         if message.parent_id:
 899             # all notified_partner_ids of the mail.message have to be notified for the parented messages
 900             partners_to_parent_notify = set(message.notified_partner_ids).difference(message.parent_id.notified_partner_ids)
 901             for partner in partners_to_parent_notify:
 902                 notification_obj.create(cr, uid, {
 903                         'message_id': message.parent_id.id,
 904                         'partner_id': partner.id,
 905                         'read': True,
 906                     }, context=context)
 907
 908     #------------------------------------------------------
 909     # Tools
 910     #------------------------------------------------------
 911
 912     def check_partners_email(self, cr, uid, partner_ids, context=None):
 913         """ Verify that selected partner_ids have an email_address defined.
 914             Otherwise throw a warning. """
 915         partner_wo_email_lst = []
 916         for partner in self.pool.get('res.partner').browse(cr, uid, partner_ids, context=context):
 917             if not partner.email:
 918                 partner_wo_email_lst.append(partner)
 919         if not partner_wo_email_lst:
 920             return {}
 921         warning_msg = _('The following partners chosen as recipients for the email have no email address linked :')
 922         for partner in partner_wo_email_lst:
 923             warning_msg += '\n- %s' % (partner.name)
 924         return {'warning': {
 925                     'title': _('Partners email addresses not found'),
 926                     'message': warning_msg,
 927                     }
 928                 }