addons/mail/mail_thread.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2009-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 base64
  23 import datetime
  24 import dateutil
  25 import email
  26 import logging
  27 import pytz
  28 import time
  29 import xmlrpclib
  30 from email.message import Message
  31
  32 from openerp import tools
  33 from openerp import SUPERUSER_ID
  34 from openerp.addons.mail.mail_message import decode
  35 from openerp.osv import fields, osv
  36 from openerp.tools.safe_eval import safe_eval as eval
  37
  38 _logger = logging.getLogger(__name__)
  39
  40
  41 def decode_header(message, header, separator=' '):
  42     return separator.join(map(decode, message.get_all(header, [])))
  43
  44
  45 class mail_thread(osv.AbstractModel):
  46     ''' mail_thread model is meant to be inherited by any model that needs to
  47         act as a discussion topic on which messages can be attached. Public
  48         methods are prefixed with ``message_`` in order to avoid name
  49         collisions with methods of the models that will inherit from this class.
  50
  51         ``mail.thread`` defines fields used to handle and display the
  52         communication history. ``mail.thread`` also manages followers of
  53         inheriting classes. All features and expected behavior are managed
  54         by mail.thread. Widgets has been designed for the 7.0 and following
  55         versions of OpenERP.
  56
  57         Inheriting classes are not required to implement any method, as the
  58         default implementation will work for any model. However it is common
  59         to override at least the ``message_new`` and ``message_update``
  60         methods (calling ``super``) to add model-specific behavior at
  61         creation and update of a thread when processing incoming emails.
  62
  63         Options:
  64             - _mail_flat_thread: if set to True, all messages without parent_id
  65                 are automatically attached to the first message posted on the
  66                 ressource. If set to False, the display of Chatter is done using
  67                 threads, and no parent_id is automatically set.
  68     '''
  69     _name = 'mail.thread'
  70     _description = 'Email Thread'
  71     _mail_flat_thread = True
  72
  73     # Automatic logging system if mail installed
  74     # _track = {
  75     #   'field': {
  76     #       'module.subtype_xml': lambda self, cr, uid, obj, context=None: obj[state] == done,
  77     #       'module.subtype_xml2': lambda self, cr, uid, obj, context=None: obj[state] != done,
  78     #   },
  79     #   'field2': {
  80     #       ...
  81     #   },
  82     # }
  83     # where
  84     #   :param string field: field name
  85     #   :param module.subtype_xml: xml_id of a mail.message.subtype (i.e. mail.mt_comment)
  86     #   :param obj: is a browse_record
  87     #   :param function lambda: returns whether the tracking should record using this subtype
  88     _track = {}
  89
  90     def _get_message_data(self, cr, uid, ids, name, args, context=None):
  91         """ Computes:
  92             - message_unread: has uid unread message for the document
  93             - message_summary: html snippet summarizing the Chatter for kanban views """
  94         res = dict((id, dict(message_unread=False, message_summary='')) for id in ids)
  95         user_pid = self.pool.get('res.users').read(cr, uid, uid, ['partner_id'], context=context)['partner_id'][0]
  96
  97         # search for unread messages, directly in SQL to improve performances
  98         cr.execute("""  SELECT m.res_id FROM mail_message m
  99                         RIGHT JOIN mail_notification n
 100                         ON (n.message_id = m.id AND n.partner_id = %s AND (n.read = False or n.read IS NULL))
 101                         WHERE m.model = %s AND m.res_id in %s""",
 102                     (user_pid, self._name, tuple(ids),))
 103         msg_ids = [result[0] for result in cr.fetchall()]
 104         for msg_id in msg_ids:
 105             res[msg_id]['message_unread'] = True
 106
 107         for thread in self.browse(cr, uid, ids, context=context):
 108             cls = res[thread.id]['message_unread'] and ' class="oe_kanban_mail_new"' or ''
 109             res[thread.id]['message_summary'] = "<span%s><span class='oe_e'>9</span> %d</span> <span><span class='oe_e'>+</span> %d</span>" % (cls, len(thread.message_ids), len(thread.message_follower_ids))
 110
 111         return res
 112
 113     def _get_subscription_data(self, cr, uid, ids, name, args, context=None):
 114         """ Computes:
 115             - message_subtype_data: data about document subtypes: which are
 116                 available, which are followed if any """
 117         res = dict((id, dict(message_subtype_data='')) for id in ids)
 118         user_pid = self.pool.get('res.users').read(cr, uid, uid, ['partner_id'], context=context)['partner_id'][0]
 119
 120         # find current model subtypes, add them to a dictionary
 121         subtype_obj = self.pool.get('mail.message.subtype')
 122         subtype_ids = subtype_obj.search(cr, uid, ['|', ('res_model', '=', self._name), ('res_model', '=', False)], context=context)
 123         subtype_dict = dict((subtype.name, dict(default=subtype.default, followed=False, id=subtype.id)) for subtype in subtype_obj.browse(cr, uid, subtype_ids, context=context))
 124         for id in ids:
 125             res[id]['message_subtype_data'] = subtype_dict.copy()
 126
 127         # find the document followers, update the data
 128         fol_obj = self.pool.get('mail.followers')
 129         fol_ids = fol_obj.search(cr, uid, [
 130             ('partner_id', '=', user_pid),
 131             ('res_id', 'in', ids),
 132             ('res_model', '=', self._name),
 133         ], context=context)
 134         for fol in fol_obj.browse(cr, uid, fol_ids, context=context):
 135             thread_subtype_dict = res[fol.res_id]['message_subtype_data']
 136             for subtype in fol.subtype_ids:
 137                 thread_subtype_dict[subtype.name]['followed'] = True
 138             res[fol.res_id]['message_subtype_data'] = thread_subtype_dict
 139
 140         return res
 141
 142     def _search_message_unread(self, cr, uid, obj=None, name=None, domain=None, context=None):
 143         return [('message_ids.to_read', '=', True)]
 144
 145     def _get_followers(self, cr, uid, ids, name, arg, context=None):
 146         fol_obj = self.pool.get('mail.followers')
 147         fol_ids = fol_obj.search(cr, SUPERUSER_ID, [('res_model', '=', self._name), ('res_id', 'in', ids)])
 148         res = dict((id, dict(message_follower_ids=[], message_is_follower=False)) for id in ids)
 149         user_pid = self.pool.get('res.users').read(cr, uid, uid, ['partner_id'], context=context)['partner_id'][0]
 150         for fol in fol_obj.browse(cr, SUPERUSER_ID, fol_ids):
 151             res[fol.res_id]['message_follower_ids'].append(fol.partner_id.id)
 152             if fol.partner_id.id == user_pid:
 153                 res[fol.res_id]['message_is_follower'] = True
 154         return res
 155
 156     def _set_followers(self, cr, uid, id, name, value, arg, context=None):
 157         if not value:
 158             return
 159         partner_obj = self.pool.get('res.partner')
 160         fol_obj = self.pool.get('mail.followers')
 161
 162         # read the old set of followers, and determine the new set of followers
 163         fol_ids = fol_obj.search(cr, SUPERUSER_ID, [('res_model', '=', self._name), ('res_id', '=', id)])
 164         old = set(fol.partner_id.id for fol in fol_obj.browse(cr, SUPERUSER_ID, fol_ids))
 165         new = set(old)
 166
 167         for command in value or []:
 168             if isinstance(command, (int, long)):
 169                 new.add(command)
 170             elif command[0] == 0:
 171                 new.add(partner_obj.create(cr, uid, command[2], context=context))
 172             elif command[0] == 1:
 173                 partner_obj.write(cr, uid, [command[1]], command[2], context=context)
 174                 new.add(command[1])
 175             elif command[0] == 2:
 176                 partner_obj.unlink(cr, uid, [command[1]], context=context)
 177                 new.discard(command[1])
 178             elif command[0] == 3:
 179                 new.discard(command[1])
 180             elif command[0] == 4:
 181                 new.add(command[1])
 182             elif command[0] == 5:
 183                 new.clear()
 184             elif command[0] == 6:
 185                 new = set(command[2])
 186
 187         # remove partners that are no longer followers
 188         fol_ids = fol_obj.search(cr, SUPERUSER_ID,
 189             [('res_model', '=', self._name), ('res_id', '=', id), ('partner_id', 'not in', list(new))])
 190         fol_obj.unlink(cr, SUPERUSER_ID, fol_ids)
 191
 192         # add new followers
 193         for partner_id in new - old:
 194             fol_obj.create(cr, SUPERUSER_ID, {'res_model': self._name, 'res_id': id, 'partner_id': partner_id})
 195
 196     def _search_followers(self, cr, uid, obj, name, args, context):
 197         fol_obj = self.pool.get('mail.followers')
 198         res = []
 199         for field, operator, value in args:
 200             assert field == name
 201             fol_ids = fol_obj.search(cr, SUPERUSER_ID, [('res_model', '=', self._name), ('partner_id', operator, value)])
 202             res_ids = [fol.res_id for fol in fol_obj.browse(cr, SUPERUSER_ID, fol_ids)]
 203             res.append(('id', 'in', res_ids))
 204         return res
 205
 206     _columns = {
 207         'message_is_follower': fields.function(_get_followers,
 208             type='boolean', string='Is a Follower', multi='_get_followers,'),
 209         'message_follower_ids': fields.function(_get_followers, fnct_inv=_set_followers,
 210                 fnct_search=_search_followers, type='many2many',
 211                 obj='res.partner', string='Followers', multi='_get_followers'),
 212         'message_ids': fields.one2many('mail.message', 'res_id',
 213             domain=lambda self: [('model', '=', self._name)],
 214             auto_join=True,
 215             string='Messages',
 216             help="Messages and communication history"),
 217         'message_unread': fields.function(_get_message_data,
 218             fnct_search=_search_message_unread, multi="_get_message_data",
 219             type='boolean', string='Unread Messages',
 220             help="If checked new messages require your attention."),
 221         'message_summary': fields.function(_get_message_data, method=True,
 222             type='text', string='Summary', multi="_get_message_data",
 223             help="Holds the Chatter summary (number of messages, ...). "\
 224                  "This summary is directly in html format in order to "\
 225                  "be inserted in kanban views."),
 226     }
 227
 228     #------------------------------------------------------
 229     # CRUD overrides for automatic subscription and logging
 230     #------------------------------------------------------
 231
 232     def create(self, cr, uid, values, context=None):
 233         """ Chatter override :
 234             - subscribe uid
 235             - subscribe followers of parent
 236             - log a creation message
 237         """
 238         if context is None:
 239             context = {}
 240         thread_id = super(mail_thread, self).create(cr, uid, values, context=context)
 241
 242         # subscribe uid unless asked not to
 243         if not context.get('mail_create_nosubscribe'):
 244             self.message_subscribe_users(cr, uid, [thread_id], [uid], context=context)
 245             self.message_subscribe_from_parent(cr, uid, [thread_id], values.keys(), context=context)
 246
 247         # automatic logging unless asked not to (mainly for various testing purpose)
 248         if not context.get('mail_create_nolog'):
 249             self.message_post(cr, uid, thread_id, body='Document created', context=context)
 250         return thread_id
 251
 252     def write(self, cr, uid, ids, values, context=None):
 253         if isinstance(ids, (int, long)):
 254             ids = [ids]
 255         # Track initial values of tracked fields
 256         tracked_fields = self._get_tracked_fields(cr, uid, values.keys(), context=context)
 257         if tracked_fields:
 258             initial = self.read(cr, uid, ids, tracked_fields.keys(), context=context)
 259             initial_values = dict((item['id'], item) for item in initial)
 260
 261         # Perform write, update followers
 262         result = super(mail_thread, self).write(cr, uid, ids, values, context=context)
 263         self.message_subscribe_from_parent(cr, uid, ids, values.keys(), context=context)
 264
 265         # Perform the tracking
 266         if tracked_fields:
 267             self.message_track(cr, uid, ids, tracked_fields, initial_values, context=context)
 268         return result
 269
 270     def unlink(self, cr, uid, ids, context=None):
 271         """ Override unlink to delete messages and followers. This cannot be
 272             cascaded, because link is done through (res_model, res_id). """
 273         msg_obj = self.pool.get('mail.message')
 274         fol_obj = self.pool.get('mail.followers')
 275         # delete messages and notifications
 276         msg_ids = msg_obj.search(cr, uid, [('model', '=', self._name), ('res_id', 'in', ids)], context=context)
 277         msg_obj.unlink(cr, uid, msg_ids, context=context)
 278         # delete
 279         res = super(mail_thread, self).unlink(cr, uid, ids, context=context)
 280         # delete followers
 281         fol_ids = fol_obj.search(cr, SUPERUSER_ID, [('res_model', '=', self._name), ('res_id', 'in', ids)], context=context)
 282         fol_obj.unlink(cr, SUPERUSER_ID, fol_ids, context=context)
 283         return res
 284
 285     def copy(self, cr, uid, id, default=None, context=None):
 286         default = default or {}
 287         default['message_ids'] = []
 288         default['message_follower_ids'] = []
 289         return super(mail_thread, self).copy(cr, uid, id, default=default, context=context)
 290
 291     #------------------------------------------------------
 292     # Automatically log tracked fields
 293     #------------------------------------------------------
 294
 295     def _get_tracked_fields(self, cr, uid, updated_fields, context=None):
 296         """ Return a structure of tracked fields for the current model.
 297             :param list updated_fields: modified field names
 298             :return list: a list of (field_name, column_info obj), containing
 299                 always tracked fields and modified on_change fields
 300         """
 301         lst = []
 302         for name, column_info in self._all_columns.items():
 303             visibility = getattr(column_info.column, 'track_visibility', False)
 304             if visibility == 'always' or (visibility == 'onchange' and name in updated_fields) or name in self._track:
 305                 lst.append(name)
 306         if not lst:
 307             return lst
 308         return self.fields_get(cr, uid, lst, context=context)
 309
 310     def message_track(self, cr, uid, ids, tracked_fields, initial_values, context=None):
 311
 312         def convert_for_display(value, col_info):
 313             if not value and col_info['type'] == 'boolean':
 314                 return 'False'
 315             if not value:
 316                 return ''
 317             if col_info['type'] == 'many2one':
 318                 return value[1]
 319             if col_info['type'] == 'selection':
 320                 return dict(col_info['selection'])[value]
 321             return value
 322
 323         def format_message(message_description, tracked_values):
 324             message = ''
 325             if message_description:
 326                 message = '<span>%s</span>' % message_description
 327             for name, change in tracked_values.items():
 328                 message += '<div> &nbsp; &nbsp; &bull; <b>%s</b>: ' % change.get('col_info')
 329                 if change.get('old_value'):
 330                     message += '%s &rarr; ' % change.get('old_value')
 331                 message += '%s</div>' % change.get('new_value')
 332             return message
 333
 334         if not tracked_fields:
 335             return True
 336
 337         for record in self.read(cr, uid, ids, tracked_fields.keys(), context=context):
 338             initial = initial_values[record['id']]
 339             changes = []
 340             tracked_values = {}
 341
 342             # generate tracked_values data structure: {'col_name': {col_info, new_value, old_value}}
 343             for col_name, col_info in tracked_fields.items():
 344                 if record[col_name] == initial[col_name] and getattr(self._all_columns[col_name].column, 'track_visibility', None) == 'always':
 345                     tracked_values[col_name] = dict(col_info=col_info['string'],
 346                                                         new_value=convert_for_display(record[col_name], col_info))
 347                 elif record[col_name] != initial[col_name]:
 348                     if getattr(self._all_columns[col_name].column, 'track_visibility', None) in ['always', 'onchange']:
 349                         tracked_values[col_name] = dict(col_info=col_info['string'],
 350                                                             old_value=convert_for_display(initial[col_name], col_info),
 351                                                             new_value=convert_for_display(record[col_name], col_info))
 352                     if col_name in tracked_fields:
 353                         changes.append(col_name)
 354             if not changes:
 355                 continue
 356
 357             # find subtypes and post messages or log if no subtype found
 358             subtypes = []
 359             for field, track_info in self._track.items():
 360                 if field not in changes:
 361                     continue
 362                 for subtype, method in track_info.items():
 363                     if method(self, cr, uid, record, context):
 364                         subtypes.append(subtype)
 365
 366             posted = False
 367             for subtype in subtypes:
 368                 try:
 369                     subtype_rec = self.pool.get('ir.model.data').get_object(cr, uid, subtype.split('.')[0], subtype.split('.')[1])
 370                 except ValueError, e:
 371                     _logger.debug('subtype %s not found, giving error "%s"' % (subtype, e))
 372                     continue
 373                 message = format_message(subtype_rec.description if subtype_rec.description else subtype_rec.name, tracked_values)
 374                 self.message_post(cr, uid, record['id'], body=message, subtype=subtype, context=context)
 375                 posted = True
 376             if not posted:
 377                 message = format_message('', tracked_values)
 378                 self.message_post(cr, uid, record['id'], body=message, context=context)
 379         return True
 380
 381     #------------------------------------------------------
 382     # mail.message wrappers and tools
 383     #------------------------------------------------------
 384
 385     def _needaction_domain_get(self, cr, uid, context=None):
 386         if self._needaction:
 387             return [('message_unread', '=', True)]
 388         return []
 389
 390     #------------------------------------------------------
 391     # Mail gateway
 392     #------------------------------------------------------
 393
 394     def message_capable_models(self, cr, uid, context=None):
 395         """ Used by the plugin addon, based for plugin_outlook and others. """
 396         ret_dict = {}
 397         for model_name in self.pool.obj_list():
 398             model = self.pool.get(model_name)
 399             if 'mail.thread' in getattr(model, '_inherit', []):
 400                 ret_dict[model_name] = model._description
 401         return ret_dict
 402
 403     def _message_find_partners(self, cr, uid, message, header_fields=['From'], context=None):
 404         """ Find partners related to some header fields of the message. """
 405         s = ', '.join([decode(message.get(h)) for h in header_fields if message.get(h)])
 406         return [partner_id for email in tools.email_split(s)
 407                 for partner_id in self.pool.get('res.partner').search(cr, uid, [('email', 'ilike', email)], limit=1, context=context)]
 408
 409     def _message_find_user_id(self, cr, uid, message, context=None):
 410         from_local_part = tools.email_split(decode(message.get('From')))[0]
 411         # FP Note: canonification required, the minimu: .lower()
 412         user_ids = self.pool.get('res.users').search(cr, uid, ['|',
 413             ('login', '=', from_local_part),
 414             ('email', '=', from_local_part)], context=context)
 415         return user_ids[0] if user_ids else uid
 416
 417     def message_route(self, cr, uid, message, model=None, thread_id=None,
 418                       custom_values=None, context=None):
 419         """Attempt to figure out the correct target model, thread_id,
 420         custom_values and user_id to use for an incoming message.
 421         Multiple values may be returned, if a message had multiple
 422         recipients matching existing mail.aliases, for example.
 423
 424         The following heuristics are used, in this order:
 425              1. If the message replies to an existing thread_id, and
 426                 properly contains the thread model in the 'In-Reply-To'
 427                 header, use this model/thread_id pair, and ignore
 428                 custom_value (not needed as no creation will take place)
 429              2. Look for a mail.alias entry matching the message
 430                 recipient, and use the corresponding model, thread_id,
 431                 custom_values and user_id.
 432              3. Fallback to the ``model``, ``thread_id`` and ``custom_values``
 433                 provided.
 434              4. If all the above fails, raise an exception.
 435
 436            :param string message: an email.message instance
 437            :param string model: the fallback model to use if the message
 438                does not match any of the currently configured mail aliases
 439                (may be None if a matching alias is supposed to be present)
 440            :type dict custom_values: optional dictionary of default field values
 441                 to pass to ``message_new`` if a new record needs to be created.
 442                 Ignored if the thread record already exists, and also if a
 443                 matching mail.alias was found (aliases define their own defaults)
 444            :param int thread_id: optional ID of the record/thread from ``model``
 445                to which this mail should be attached. Only used if the message
 446                does not reply to an existing thread and does not match any mail alias.
 447            :return: list of [model, thread_id, custom_values, user_id]
 448         """
 449         assert isinstance(message, Message), 'message must be an email.message.Message at this point'
 450         message_id = message.get('Message-Id')
 451         references = decode_header(message, 'References')
 452         in_reply_to = decode_header(message, 'In-Reply-To')
 453
 454         # 1. Verify if this is a reply to an existing thread
 455         thread_references = references or in_reply_to
 456         ref_match = thread_references and tools.reference_re.search(thread_references)
 457         if ref_match:
 458             thread_id = int(ref_match.group(1))
 459             model = ref_match.group(2) or model
 460             model_pool = self.pool.get(model)
 461             if thread_id and model and model_pool and model_pool.exists(cr, uid, thread_id) \
 462                 and hasattr(model_pool, 'message_update'):
 463                 _logger.debug('Routing mail with Message-Id %s: direct reply to model: %s, thread_id: %s, custom_values: %s, uid: %s',
 464                               message_id, model, thread_id, custom_values, uid)
 465                 return [(model, thread_id, custom_values, uid)]
 466
 467         # Verify whether this is a reply to a private message
 468         if in_reply_to:
 469             message_ids = self.pool.get('mail.message').search(cr, uid, [('message_id', '=', in_reply_to)], limit=1, context=context)
 470             if message_ids:
 471                 message = self.pool.get('mail.message').browse(cr, uid, message_ids[0], context=context)
 472                 _logger.debug('Routing mail with Message-Id %s: direct reply to a private message: %s, custom_values: %s, uid: %s',
 473                                 message_id, message.id, custom_values, uid)
 474                 return [(message.model, message.res_id, custom_values, uid)]
 475
 476         # 2. Look for a matching mail.alias entry
 477         # Delivered-To is a safe bet in most modern MTAs, but we have to fallback on To + Cc values
 478         # for all the odd MTAs out there, as there is no standard header for the envelope's `rcpt_to` value.
 479         rcpt_tos = \
 480              ','.join([decode_header(message, 'Delivered-To'),
 481                        decode_header(message, 'To'),
 482                        decode_header(message, 'Cc'),
 483                        decode_header(message, 'Resent-To'),
 484                        decode_header(message, 'Resent-Cc')])
 485         local_parts = [e.split('@')[0] for e in tools.email_split(rcpt_tos)]
 486         if local_parts:
 487             mail_alias = self.pool.get('mail.alias')
 488             alias_ids = mail_alias.search(cr, uid, [('alias_name', 'in', local_parts)])
 489             if alias_ids:
 490                 routes = []
 491                 for alias in mail_alias.browse(cr, uid, alias_ids, context=context):
 492                     user_id = alias.alias_user_id.id
 493                     if not user_id:
 494                         # TDE note: this could cause crashes, because no clue that the user
 495                         # that send the email has the right to create or modify a new document
 496                         # Fallback on user_id = uid
 497                         # Note: recognized partners will be added as followers anyway
 498                         # user_id = self._message_find_user_id(cr, uid, message, context=context)
 499                         user_id = uid
 500                         _logger.debug('Routing mail with Message-Id %s: direct alias match: %r', message_id, routes)
 501                     routes.append((alias.alias_model_id.model, alias.alias_force_thread_id, \
 502                                    eval(alias.alias_defaults), user_id))
 503                 _logger.debug('Routing mail with Message-Id %s: direct alias match: %r', message_id, routes)
 504                 return routes
 505
 506         # 3. Fallback to the provided parameters, if they work
 507         model_pool = self.pool.get(model)
 508         if not thread_id:
 509             # Legacy: fallback to matching [ID] in the Subject
 510             match = tools.res_re.search(decode_header(message, 'Subject'))
 511             thread_id = match and match.group(1)
 512         assert thread_id and hasattr(model_pool, 'message_update') or hasattr(model_pool, 'message_new'), \
 513             "No possible route found for incoming message with Message-Id %s. " \
 514             "Create an appropriate mail.alias or force the destination model." % message_id
 515         if thread_id and not model_pool.exists(cr, uid, thread_id):
 516             _logger.warning('Received mail reply to missing document %s! Ignoring and creating new document instead for Message-Id %s',
 517                             thread_id, message_id)
 518             thread_id = None
 519         _logger.debug('Routing mail with Message-Id %s: fallback to model:%s, thread_id:%s, custom_values:%s, uid:%s',
 520                       message_id, model, thread_id, custom_values, uid)
 521         return [(model, thread_id, custom_values, uid)]
 522
 523     def message_process(self, cr, uid, model, message, custom_values=None,
 524                         save_original=False, strip_attachments=False,
 525                         thread_id=None, context=None):
 526         """ Process an incoming RFC2822 email message, relying on
 527             ``mail.message.parse()`` for the parsing operation,
 528             and ``message_route()`` to figure out the target model.
 529
 530             Once the target model is known, its ``message_new`` method
 531             is called with the new message (if the thread record did not exist)
 532             or its ``message_update`` method (if it did).
 533
 534             There is a special case where the target model is False: a reply
 535             to a private message. In this case, we skip the message_new /
 536             message_update step, to just post a new message using mail_thread
 537             message_post.
 538
 539            :param string model: the fallback model to use if the message
 540                does not match any of the currently configured mail aliases
 541                (may be None if a matching alias is supposed to be present)
 542            :param message: source of the RFC2822 message
 543            :type message: string or xmlrpclib.Binary
 544            :type dict custom_values: optional dictionary of field values
 545                 to pass to ``message_new`` if a new record needs to be created.
 546                 Ignored if the thread record already exists, and also if a
 547                 matching mail.alias was found (aliases define their own defaults)
 548            :param bool save_original: whether to keep a copy of the original
 549                 email source attached to the message after it is imported.
 550            :param bool strip_attachments: whether to strip all attachments
 551                 before processing the message, in order to save some space.
 552            :param int thread_id: optional ID of the record/thread from ``model``
 553                to which this mail should be attached. When provided, this
 554                overrides the automatic detection based on the message
 555                headers.
 556         """
 557         if context is None:
 558             context = {}
 559
 560         # extract message bytes - we are forced to pass the message as binary because
 561         # we don't know its encoding until we parse its headers and hence can't
 562         # convert it to utf-8 for transport between the mailgate script and here.
 563         if isinstance(message, xmlrpclib.Binary):
 564             message = str(message.data)
 565         # Warning: message_from_string doesn't always work correctly on unicode,
 566         # we must use utf-8 strings here :-(
 567         if isinstance(message, unicode):
 568             message = message.encode('utf-8')
 569         msg_txt = email.message_from_string(message)
 570         routes = self.message_route(cr, uid, msg_txt, model,
 571                                     thread_id, custom_values,
 572                                     context=context)
 573         msg = self.message_parse(cr, uid, msg_txt, save_original=save_original, context=context)
 574         if strip_attachments:
 575             msg.pop('attachments', None)
 576
 577         # postpone setting msg.partner_ids after message_post, to avoid double notifications
 578         partner_ids = msg.pop('partner_ids', [])
 579
 580         thread_id = False
 581         for model, thread_id, custom_values, user_id in routes:
 582             if self._name != model:
 583                 context.update({'thread_model': model})
 584             if model:
 585                 model_pool = self.pool.get(model)
 586                 assert thread_id and hasattr(model_pool, 'message_update') or hasattr(model_pool, 'message_new'), \
 587                     "Undeliverable mail with Message-Id %s, model %s does not accept incoming emails" % \
 588                         (msg['message_id'], model)
 589
 590                 # disabled subscriptions during message_new/update to avoid having the system user running the
 591                 # email gateway become a follower of all inbound messages
 592                 nosub_ctx = dict(context, mail_create_nosubscribe=True)
 593                 if thread_id and hasattr(model_pool, 'message_update'):
 594                     model_pool.message_update(cr, user_id, [thread_id], msg, context=nosub_ctx)
 595                 else:
 596                     thread_id = model_pool.message_new(cr, user_id, msg, custom_values, context=nosub_ctx)
 597             else:
 598                 assert thread_id == 0, "Posting a message without model should be with a null res_id, to create a private message."
 599                 model_pool = self.pool.get('mail.thread')
 600             new_msg_id = model_pool.message_post_user_api(cr, uid, [thread_id], context=context, content_subtype='html', **msg)
 601
 602             # when posting an incoming email to a document: subscribe the author, if a partner, as follower
 603             if model and thread_id and msg.get('author_id'):
 604                 model_pool.message_subscribe(cr, uid, [thread_id], [msg.get('author_id')], context=context)
 605
 606             if partner_ids:
 607                 # postponed after message_post, because this is an external message and we don't want to create
 608                 # duplicate emails due to notifications
 609                 self.pool.get('mail.message').write(cr, uid, [new_msg_id], {'partner_ids': partner_ids}, context=context)
 610
 611         return thread_id
 612
 613     def message_new(self, cr, uid, msg_dict, custom_values=None, context=None):
 614         """Called by ``message_process`` when a new message is received
 615            for a given thread model, if the message did not belong to
 616            an existing thread.
 617            The default behavior is to create a new record of the corresponding
 618            model (based on some very basic info extracted from the message).
 619            Additional behavior may be implemented by overriding this method.
 620
 621            :param dict msg_dict: a map containing the email details and
 622                                  attachments. See ``message_process`` and
 623                                 ``mail.message.parse`` for details.
 624            :param dict custom_values: optional dictionary of additional
 625                                       field values to pass to create()
 626                                       when creating the new thread record.
 627                                       Be careful, these values may override
 628                                       any other values coming from the message.
 629            :param dict context: if a ``thread_model`` value is present
 630                                 in the context, its value will be used
 631                                 to determine the model of the record
 632                                 to create (instead of the current model).
 633            :rtype: int
 634            :return: the id of the newly created thread object
 635         """
 636         if context is None:
 637             context = {}
 638         model = context.get('thread_model') or self._name
 639         model_pool = self.pool.get(model)
 640         fields = model_pool.fields_get(cr, uid, context=context)
 641         data = model_pool.default_get(cr, uid, fields, context=context)
 642         if 'name' in fields and not data.get('name'):
 643             data['name'] = msg_dict.get('subject', '')
 644         if custom_values and isinstance(custom_values, dict):
 645             data.update(custom_values)
 646         res_id = model_pool.create(cr, uid, data, context=context)
 647         return res_id
 648
 649     def message_update(self, cr, uid, ids, msg_dict, update_vals=None, context=None):
 650         """Called by ``message_process`` when a new message is received
 651            for an existing thread. The default behavior is to update the record
 652            with update_vals taken from the incoming email.
 653            Additional behavior may be implemented by overriding this
 654            method.
 655            :param dict msg_dict: a map containing the email details and
 656                                attachments. See ``message_process`` and
 657                                ``mail.message.parse()`` for details.
 658            :param dict update_vals: a dict containing values to update records
 659                               given their ids; if the dict is None or is
 660                               void, no write operation is performed.
 661         """
 662         if update_vals:
 663             self.write(cr, uid, ids, update_vals, context=context)
 664         return True
 665
 666     def _message_extract_payload(self, message, save_original=False):
 667         """Extract body as HTML and attachments from the mail message"""
 668         attachments = []
 669         body = u''
 670         if save_original:
 671             attachments.append(('original_email.eml', message.as_string()))
 672         if not message.is_multipart() or 'text/' in message.get('content-type', ''):
 673             encoding = message.get_content_charset()
 674             body = message.get_payload(decode=True)
 675             body = tools.ustr(body, encoding, errors='replace')
 676             if message.get_content_type() == 'text/plain':
 677                 # text/plain -> <pre/>
 678                 body = tools.append_content_to_html(u'', body, preserve=True)
 679         else:
 680             alternative = (message.get_content_type() == 'multipart/alternative')
 681             for part in message.walk():
 682                 if part.get_content_maintype() == 'multipart':
 683                     continue  # skip container
 684                 filename = part.get_filename()  # None if normal part
 685                 encoding = part.get_content_charset()  # None if attachment
 686                 # 1) Explicit Attachments -> attachments
 687                 if filename or part.get('content-disposition', '').strip().startswith('attachment'):
 688                     attachments.append((filename or 'attachment', part.get_payload(decode=True)))
 689                     continue
 690                 # 2) text/plain -> <pre/>
 691                 if part.get_content_type() == 'text/plain' and (not alternative or not body):
 692                     body = tools.append_content_to_html(body, tools.ustr(part.get_payload(decode=True),
 693                                                                          encoding, errors='replace'), preserve=True)
 694                 # 3) text/html -> raw
 695                 elif part.get_content_type() == 'text/html':
 696                     html = tools.ustr(part.get_payload(decode=True), encoding, errors='replace')
 697                     if alternative:
 698                         body = html
 699                     else:
 700                         body = tools.append_content_to_html(body, html, plaintext=False)
 701                 # 4) Anything else -> attachment
 702                 else:
 703                     attachments.append((filename or 'attachment', part.get_payload(decode=True)))
 704         return body, attachments
 705
 706     def message_parse(self, cr, uid, message, save_original=False, context=None):
 707         """Parses a string or email.message.Message representing an
 708            RFC-2822 email, and returns a generic dict holding the
 709            message details.
 710
 711            :param message: the message to parse
 712            :type message: email.message.Message | string | unicode
 713            :param bool save_original: whether the returned dict
 714                should include an ``original`` attachment containing
 715                the source of the message
 716            :rtype: dict
 717            :return: A dict with the following structure, where each
 718                     field may not be present if missing in original
 719                     message::
 720
 721                     { 'message_id': msg_id,
 722                       'subject': subject,
 723                       'from': from,
 724                       'to': to,
 725                       'cc': cc,
 726                       'body': unified_body,
 727                       'attachments': [('file1', 'bytes'),
 728                                       ('file2', 'bytes')}
 729                     }
 730         """
 731         msg_dict = {
 732             'type': 'email',
 733             'author_id': False,
 734         }
 735         if not isinstance(message, Message):
 736             if isinstance(message, unicode):
 737                 # Warning: message_from_string doesn't always work correctly on unicode,
 738                 # we must use utf-8 strings here :-(
 739                 message = message.encode('utf-8')
 740             message = email.message_from_string(message)
 741
 742         message_id = message['message-id']
 743         if not message_id:
 744             # Very unusual situation, be we should be fault-tolerant here
 745             message_id = "<%s@localhost>" % time.time()
 746             _logger.debug('Parsing Message without message-id, generating a random one: %s', message_id)
 747         msg_dict['message_id'] = message_id
 748
 749         if 'Subject' in message:
 750             msg_dict['subject'] = decode(message.get('Subject'))
 751
 752         # Envelope fields not stored in mail.message but made available for message_new()
 753         msg_dict['from'] = decode(message.get('from'))
 754         msg_dict['to'] = decode(message.get('to'))
 755         msg_dict['cc'] = decode(message.get('cc'))
 756
 757         if 'From' in message:
 758             author_ids = self._message_find_partners(cr, uid, message, ['From'], context=context)
 759             if author_ids:
 760                 msg_dict['author_id'] = author_ids[0]
 761             else:
 762                 msg_dict['email_from'] = message.get('from')
 763         partner_ids = self._message_find_partners(cr, uid, message, ['From', 'To', 'Cc'], context=context)
 764         msg_dict['partner_ids'] = [(4, partner_id) for partner_id in partner_ids]
 765
 766         if 'Date' in message:
 767             try:
 768                 date_hdr = decode(message.get('Date'))
 769                 parsed_date = dateutil.parser.parse(date_hdr, fuzzy=True)
 770                 if parsed_date.utcoffset() is None:
 771                     # naive datetime, so we arbitrarily decide to make it
 772                     # UTC, there's no better choice. Should not happen,
 773                     # as RFC2822 requires timezone offset in Date headers.
 774                     stored_date = parsed_date.replace(tzinfo=pytz.utc)
 775                 else:
 776                     stored_date = parsed_date.astimezone(pytz.utc)
 777             except Exception:
 778                 _logger.warning('Failed to parse Date header %r in incoming mail '
 779                                 'with message-id %r, assuming current date/time.',
 780                                 message.get('Date'), message_id)
 781                 stored_date = datetime.datetime.now()
 782             msg_dict['date'] = stored_date.strftime(tools.DEFAULT_SERVER_DATETIME_FORMAT)
 783
 784         if 'In-Reply-To' in message:
 785             parent_ids = self.pool.get('mail.message').search(cr, uid, [('message_id', '=', decode(message['In-Reply-To']))])
 786             if parent_ids:
 787                 msg_dict['parent_id'] = parent_ids[0]
 788
 789         if 'References' in message and 'parent_id' not in msg_dict:
 790             parent_ids = self.pool.get('mail.message').search(cr, uid, [('message_id', 'in',
 791                                                                          [x.strip() for x in decode(message['References']).split()])])
 792             if parent_ids:
 793                 msg_dict['parent_id'] = parent_ids[0]
 794
 795         msg_dict['body'], msg_dict['attachments'] = self._message_extract_payload(message)
 796         return msg_dict
 797
 798     #------------------------------------------------------
 799     # Note specific
 800     #------------------------------------------------------
 801
 802     def log(self, cr, uid, id, message, secondary=False, context=None):
 803         _logger.warning("log() is deprecated. As this module inherit from "\
 804                         "mail.thread, the message will be managed by this "\
 805                         "module instead of by the res.log mechanism. Please "\
 806                         "use mail_thread.message_post() instead of the "\
 807                         "now deprecated res.log.")
 808         self.message_post(cr, uid, [id], message, context=context)
 809
 810     def message_post(self, cr, uid, thread_id, body='', subject=None, type='notification',
 811                         subtype=None, parent_id=False, attachments=None, context=None, **kwargs):
 812         """ Post a new message in an existing thread, returning the new
 813             mail.message ID. Extra keyword arguments will be used as default
 814             column values for the new mail.message record.
 815             Auto link messages for same id and object
 816             :param int thread_id: thread ID to post into, or list with one ID;
 817                 if False/0, mail.message model will also be set as False
 818             :param str body: body of the message, usually raw HTML that will
 819                 be sanitized
 820             :param str subject: optional subject
 821             :param str type: mail_message.type
 822             :param int parent_id: optional ID of parent message in this thread
 823             :param tuple(str,str) attachments or list id: list of attachment tuples in the form
 824                 ``(name,content)``, where content is NOT base64 encoded
 825             :return: ID of newly created mail.message
 826         """
 827         if context is None:
 828             context = {}
 829         if attachments is None:
 830             attachments = {}
 831
 832         assert (not thread_id) or isinstance(thread_id, (int, long)) or \
 833             (isinstance(thread_id, (list, tuple)) and len(thread_id) == 1), "Invalid thread_id; should be 0, False, an ID or a list with one ID"
 834         if isinstance(thread_id, (list, tuple)):
 835             thread_id = thread_id and thread_id[0]
 836         mail_message = self.pool.get('mail.message')
 837         model = context.get('thread_model', self._name) if thread_id else False
 838
 839         attachment_ids = kwargs.pop('attachment_ids', [])
 840         for name, content in attachments:
 841             if isinstance(content, unicode):
 842                 content = content.encode('utf-8')
 843             data_attach = {
 844                 'name': name,
 845                 'datas': base64.b64encode(str(content)),
 846                 'datas_fname': name,
 847                 'description': name,
 848                 'res_model': context.get('thread_model') or self._name,
 849                 'res_id': thread_id,
 850             }
 851             attachment_ids.append((0, 0, data_attach))
 852
 853         # fetch subtype
 854         if subtype:
 855             s_data = subtype.split('.')
 856             if len(s_data) == 1:
 857                 s_data = ('mail', s_data[0])
 858             ref = self.pool.get('ir.model.data').get_object_reference(cr, uid, s_data[0], s_data[1])
 859             subtype_id = ref and ref[1] or False
 860         else:
 861             subtype_id = False
 862
 863         # _mail_flat_thread: automatically set free messages to the first posted message
 864         if self._mail_flat_thread and not parent_id and thread_id:
 865             message_ids = mail_message.search(cr, uid, ['&', ('res_id', '=', thread_id), ('model', '=', model)], context=context, order="id ASC", limit=1)
 866             parent_id = message_ids and message_ids[0] or False
 867         # we want to set a parent: force to set the parent_id to the oldest ancestor, to avoid having more than 1 level of thread
 868         elif parent_id:
 869             message_ids = mail_message.search(cr, SUPERUSER_ID, [('id', '=', parent_id), ('parent_id', '!=', False)], context=context)
 870             # avoid loops when finding ancestors
 871             processed_list = []
 872             if message_ids:
 873                 message = mail_message.browse(cr, SUPERUSER_ID, message_ids[0], context=context)
 874                 while (message.parent_id and message.parent_id.id not in processed_list):
 875                     processed_list.append(message.parent_id.id)
 876                     message = message.parent_id
 877                 parent_id = message.id
 878
 879         values = kwargs
 880         values.update({
 881             'model': model,
 882             'res_id': thread_id or False,
 883             'body': body,
 884             'subject': subject or False,
 885             'type': type,
 886             'parent_id': parent_id,
 887             'attachment_ids': attachment_ids,
 888             'subtype_id': subtype_id,
 889         })
 890
 891         # Avoid warnings about non-existing fields
 892         for x in ('from', 'to', 'cc'):
 893             values.pop(x, None)
 894
 895         return mail_message.create(cr, uid, values, context=context)
 896
 897     def message_post_user_api(self, cr, uid, thread_id, body='', parent_id=False,
 898                                 attachment_ids=None, extra_emails=None, content_subtype='plaintext',
 899                                 context=None, **kwargs):
 900         """ Wrapper on message_post, used for user input :
 901             - mail gateway
 902             - quick reply in Chatter (refer to mail.js), not
 903                 the mail.compose.message wizard
 904             The purpose is to perform some pre- and post-processing:
 905             - if body is plaintext: convert it into html
 906             - if parent_id: handle reply to a previous message by adding the
 907                 parent partners to the message
 908             - type and subtype: comment and mail.mt_comment by default
 909             - attachment_ids: supposed not attached to any document; attach them
 910                 to the related document. Should only be set by Chatter.
 911             - extra_email: [ 'Fabien <fpi@openerp.com>', 'al@openerp.com' ]
 912         """
 913         partner_obj = self.pool.get('res.partner')
 914         mail_message_obj = self.pool.get('mail.message')
 915         ir_attachment = self.pool.get('ir.attachment')
 916         extra_emails = extra_emails or []
 917
 918         # 1.A.1: pre-process partners and incoming extra_emails
 919         partner_ids = set([])
 920         for email in extra_emails:
 921             partner_id = partner_obj.find_or_create(cr, uid, email, context=context)
 922             # link mail with this from mail to the new partner id
 923             partner_msg_ids = mail_message_obj.search(cr, SUPERUSER_ID, [('email_from', '=', email), ('author_id', '=', False)], context=context)
 924             if partner_id and partner_msg_ids:
 925                 mail_message_obj.write(cr, SUPERUSER_ID, partner_msg_ids, {'email_from': None, 'author_id': partner_id}, context=context)
 926             partner_ids.add((4, partner_id))
 927         if partner_ids:
 928             self.message_subscribe(cr, uid, [thread_id], [item[1] for item in partner_ids], context=context)
 929
 930         # 1.A.2: add recipients of parent message
 931         if parent_id:
 932             parent_message = mail_message_obj.browse(cr, uid, parent_id, context=context)
 933             partner_ids |= set([(4, partner.id) for partner in parent_message.partner_ids])
 934             # TDE FIXME HACK: mail.thread -> private message
 935             if self._name == 'mail.thread' and parent_message.author_id.id:
 936                 partner_ids.add((4, parent_message.author_id.id))
 937
 938         # 1.A.3: add specified recipients
 939         partner_ids |= set(kwargs.pop('partner_ids', []))
 940
 941         # 1.B: handle body, message_type and message_subtype
 942         if content_subtype == 'plaintext':
 943             body = tools.plaintext2html(body)
 944         msg_type = kwargs.pop('type', 'comment')
 945         msg_subtype = kwargs.pop('subtype', 'mail.mt_comment')
 946
 947         # 2. Pre-processing: attachments
 948         # HACK TDE FIXME: Chatter: attachments linked to the document (not done JS-side), load the message
 949         if attachment_ids:
 950             # TDE FIXME (?): when posting a private message, we use mail.thread as a model
 951             # However, attaching doc to mail.thread is not possible, mail.thread does not have any table
 952             model = self._name
 953             if model == 'mail.thread':
 954                 model = False
 955             filtered_attachment_ids = ir_attachment.search(cr, SUPERUSER_ID, [
 956                 ('res_model', '=', 'mail.compose.message'),
 957                 ('res_id', '=', 0),
 958                 ('create_uid', '=', uid),
 959                 ('id', 'in', attachment_ids)], context=context)
 960             if filtered_attachment_ids:
 961                 if thread_id and model:
 962                     ir_attachment.write(cr, SUPERUSER_ID, attachment_ids, {'res_model': model, 'res_id': thread_id}, context=context)
 963         else:
 964             attachment_ids = []
 965         attachment_ids = [(4, id) for id in attachment_ids]
 966
 967         # 3. Post message
 968         return self.message_post(cr, uid, thread_id=thread_id, body=body,
 969                             type=msg_type, subtype=msg_subtype, parent_id=parent_id,
 970                             attachment_ids=attachment_ids, partner_ids=list(partner_ids), context=context, **kwargs)
 971
 972     #------------------------------------------------------
 973     # Followers API
 974     #------------------------------------------------------
 975
 976     def message_get_subscription_data(self, cr, uid, ids, context=None):
 977         """ Wrapper to get subtypes data. """
 978         return self._get_subscription_data(cr, uid, ids, None, None, context=context)
 979
 980     def message_subscribe_users(self, cr, uid, ids, user_ids=None, subtype_ids=None, context=None):
 981         """ Wrapper on message_subscribe, using users. If user_ids is not
 982             provided, subscribe uid instead. """
 983         if user_ids is None:
 984             user_ids = [uid]
 985         partner_ids = [user.partner_id.id for user in self.pool.get('res.users').browse(cr, uid, user_ids, context=context)]
 986         return self.message_subscribe(cr, uid, ids, partner_ids, subtype_ids=subtype_ids, context=context)
 987
 988     def message_subscribe(self, cr, uid, ids, partner_ids, subtype_ids=None, context=None):
 989         """ Add partners to the records followers. """
 990         user_pid = self.pool.get('res.users').read(cr, uid, uid, ['partner_id'], context=context)['partner_id'][0]
 991         if set(partner_ids) == set([user_pid]):
 992             self.check_access_rights(cr, uid, 'read')
 993         else:
 994             self.check_access_rights(cr, uid, 'write')
 995
 996         self.write(cr, SUPERUSER_ID, ids, {'message_follower_ids': [(4, pid) for pid in partner_ids]}, context=context)
 997         # if subtypes are not specified (and not set to a void list), fetch default ones
 998         if subtype_ids is None:
 999             subtype_obj = self.pool.get('mail.message.subtype')
1000             subtype_ids = subtype_obj.search(cr, uid, [('default', '=', True), '|', ('res_model', '=', self._name), ('res_model', '=', False)], context=context)
1001         # update the subscriptions
1002         fol_obj = self.pool.get('mail.followers')
1003         fol_ids = fol_obj.search(cr, SUPERUSER_ID, [('res_model', '=', self._name), ('res_id', 'in', ids), ('partner_id', 'in', partner_ids)], context=context)
1004         fol_obj.write(cr, SUPERUSER_ID, fol_ids, {'subtype_ids': [(6, 0, subtype_ids)]}, context=context)
1005         return True
1006
1007     def message_unsubscribe_users(self, cr, uid, ids, user_ids=None, context=None):
1008         """ Wrapper on message_subscribe, using users. If user_ids is not
1009             provided, unsubscribe uid instead. """
1010         if user_ids is None:
1011             user_ids = [uid]
1012         partner_ids = [user.partner_id.id for user in self.pool.get('res.users').browse(cr, uid, user_ids, context=context)]
1013         return self.message_unsubscribe(cr, uid, ids, partner_ids, context=context)
1014
1015     def message_unsubscribe(self, cr, uid, ids, partner_ids, context=None):
1016         """ Remove partners from the records followers. """
1017         user_pid = self.pool.get('res.users').read(cr, uid, uid, ['partner_id'], context=context)['partner_id'][0]
1018         if set(partner_ids) == set([user_pid]):
1019             self.check_access_rights(cr, uid, 'read')
1020         else:
1021             self.check_access_rights(cr, uid, 'write')
1022         return self.write(cr, SUPERUSER_ID, ids, {'message_follower_ids': [(3, pid) for pid in partner_ids]}, context=context)
1023
1024     def message_subscribe_from_parent(self, cr, uid, ids, updated_fields, context=None):
1025         """
1026             1. fetch project subtype related to task (parent_id.res_model = 'project.task')
1027             2. for each project subtype: subscribe the follower to the task
1028         """
1029         subtype_obj = self.pool.get('mail.message.subtype')
1030         follower_obj = self.pool.get('mail.followers')
1031
1032         # fetch related record subtypes
1033         related_subtype_ids = subtype_obj.search(cr, uid, ['|', ('res_model', '=', False), ('parent_id.res_model', '=', self._name)], context=context)
1034         subtypes = subtype_obj.browse(cr, uid, related_subtype_ids, context=context)
1035         default_subtypes = [subtype for subtype in subtypes if subtype.res_model == False]
1036         related_subtypes = [subtype for subtype in subtypes if subtype.res_model != False]
1037         relation_fields = set([subtype.relation_field for subtype in subtypes if subtype.relation_field != False])
1038         if not related_subtypes or not any(relation in updated_fields for relation in relation_fields):
1039             return True
1040
1041         for record in self.browse(cr, uid, ids, context=context):
1042             new_followers = dict()
1043             parent_res_id = False
1044             parent_model = False
1045             for subtype in related_subtypes:
1046                 if not subtype.relation_field or not subtype.parent_id:
1047                     continue
1048                 if not subtype.relation_field in self._columns or not getattr(record, subtype.relation_field, False):
1049                     continue
1050                 parent_res_id = getattr(record, subtype.relation_field).id
1051                 parent_model = subtype.res_model
1052                 follower_ids = follower_obj.search(cr, SUPERUSER_ID, [
1053                     ('res_model', '=', parent_model),
1054                     ('res_id', '=', parent_res_id),
1055                     ('subtype_ids', 'in', [subtype.id])
1056                     ], context=context)
1057                 for follower in follower_obj.browse(cr, SUPERUSER_ID, follower_ids, context=context):
1058                     new_followers.setdefault(follower.partner_id.id, set()).add(subtype.parent_id.id)
1059
1060             if not parent_res_id or not parent_model:
1061                 continue
1062
1063             for subtype in default_subtypes:
1064                 follower_ids = follower_obj.search(cr, SUPERUSER_ID, [
1065                     ('res_model', '=', parent_model),
1066                     ('res_id', '=', parent_res_id),
1067                     ('subtype_ids', 'in', [subtype.id])
1068                     ], context=context)
1069                 for follower in follower_obj.browse(cr, SUPERUSER_ID, follower_ids, context=context):
1070                     new_followers.setdefault(follower.partner_id.id, set()).add(subtype.id)
1071
1072             for pid, subtypes in new_followers.items():
1073                 self.message_subscribe(cr, uid, [record.id], [pid], list(subtypes), context=context)
1074         return True
1075
1076     #------------------------------------------------------
1077     # Thread state
1078     #------------------------------------------------------
1079
1080     def message_mark_as_unread(self, cr, uid, ids, context=None):
1081         """ Set as unread. """
1082         partner_id = self.pool.get('res.users').browse(cr, uid, uid, context=context).partner_id.id
1083         cr.execute('''
1084             UPDATE mail_notification SET
1085                 read=false
1086             WHERE
1087                 message_id IN (SELECT id from mail_message where res_id=any(%s) and model=%s limit 1) and
1088                 partner_id = %s
1089         ''', (ids, self._name, partner_id))
1090         return True
1091
1092     def message_mark_as_read(self, cr, uid, ids, context=None):
1093         """ Set as read. """
1094         partner_id = self.pool.get('res.users').browse(cr, uid, uid, context=context).partner_id.id
1095         cr.execute('''
1096             UPDATE mail_notification SET
1097                 read=true
1098             WHERE
1099                 message_id IN (SELECT id FROM mail_message WHERE res_id=ANY(%s) AND model=%s) AND
1100                 partner_id = %s
1101         ''', (ids, self._name, partner_id))
1102         return True
1103
1104 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: