# -*- coding: utf-8 -*- ############################################################################## # # OpenERP, Open Source Management Solution # Copyright (C) 2010-today OpenERP SA () # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see # ############################################################################## import logging import tools from email.header import decode_header from operator import itemgetter from osv import osv, fields _logger = logging.getLogger(__name__) """ Some tools for parsing / creating email fields """ def decode(text): """Returns unicode() string conversion of the the given encoded smtp header text""" if text: text = decode_header(text.replace('\r', '')) return ''.join([tools.ustr(x[0], x[1]) for x in text]) class mail_message(osv.Model): """ Messages model: system notification (replacing res.log notifications), comments (OpenChatter discussion) and incoming emails. """ _name = 'mail.message' _description = 'Message' _inherit = ['ir.needaction_mixin'] _order = 'id desc' _message_read_limit = 10 _message_record_name_length = 18 def _shorten_name(self, name): if len(name) <= (self._message_record_name_length + 3): return name return name[:self._message_record_name_length] + '...' def _get_record_name(self, cr, uid, ids, name, arg, context=None): """ Return the related document name, using get_name. """ result = dict.fromkeys(ids, '') for message in self.browse(cr, uid, ids, context=context): if not message.model or not message.res_id: continue result[message.id] = self._shorten_name(self.pool.get(message.model).name_get(cr, 1, [message.res_id], context=context)[0][1]) return result def _get_unread(self, cr, uid, ids, name, arg, context=None): """ Compute if the message is unread by the current user. """ res = dict((id, {'unread': False}) for id in ids) partner_id = self.pool.get('res.users').browse(cr, uid, uid, context=context).partner_id.id notif_obj = self.pool.get('mail.notification') notif_ids = notif_obj.search(cr, uid, [ ('partner_id', 'in', [partner_id]), ('message_id', 'in', ids), ('read', '=', False) ], context=context) for notif in notif_obj.browse(cr, uid, notif_ids, context=context): res[notif.message_id.id]['unread'] = True return res def _search_unread(self, cr, uid, obj, name, domain, context=None): """ Search for messages unread by the current user. Condition is inversed because we search unread message on a read column. """ if domain[0][2]: read_cond = '(read = false or read is null)' else: read_cond = 'read = true' partner_id = self.pool.get('res.users').browse(cr, uid, uid, context=context).partner_id.id cr.execute("SELECT message_id FROM mail_notification "\ "WHERE partner_id = %%s AND %s" % read_cond, (partner_id,)) return [('id', 'in', [r[0] for r in cr.fetchall()])] def name_get(self, cr, uid, ids, context=None): # name_get may receive int id instead of an id list if isinstance(ids, (int, long)): ids = [ids] res = [] for message in self.browse(cr, uid, ids, context=context): name = '%s: %s' % (message.subject or '', message.body or '') res.append((message.id, self._shorten_name(name.lstrip(' :')))) return res _columns = { 'type': fields.selection([ ('email', 'Email'), ('comment', 'Comment'), ('notification', 'System notification'), ], 'Type', help="Message type: email for email message, notification for system "\ "message, comment for other messages such as user replies"), 'author_id': fields.many2one('res.partner', 'Author', required=True), 'partner_ids': fields.many2many('res.partner', 'mail_notification', 'message_id', 'partner_id', 'Recipients'), 'attachment_ids': fields.many2many('ir.attachment', 'message_attachment_rel', 'message_id', 'attachment_id', 'Attachments'), 'parent_id': fields.many2one('mail.message', 'Parent Message', select=True, ondelete='set null', help="Initial thread message."), 'child_ids': fields.one2many('mail.message', 'parent_id', 'Child Messages'), 'model': fields.char('Related Document Model', size=128, select=1), 'res_id': fields.integer('Related Document ID', select=1), 'record_name': fields.function(_get_record_name, type='string', string='Message Record Name', help="Name get of the related document."), 'notification_ids': fields.one2many('mail.notification', 'message_id', 'Notifications'), 'subject': fields.char('Subject'), 'date': fields.datetime('Date'), 'message_id': fields.char('Message-Id', help='Message unique identifier', select=1, readonly=1), 'body': fields.html('Contents', help='Automatically sanitized HTML contents'), 'unread': fields.function(_get_unread, fnct_search=_search_unread, type='boolean', string='Unread', help='Functional field to search for unread messages linked to uid'), } def _needaction_domain_get(self, cr, uid, context=None): if self._needaction: return [('unread', '=', True)] return [] def _get_default_author(self, cr, uid, context=None): return self.pool.get('res.users').browse(cr, uid, uid, context=context).partner_id.id _defaults = { 'type': 'email', 'date': lambda *a: fields.datetime.now(), 'author_id': lambda self, cr, uid, ctx={}: self._get_default_author(cr, uid, ctx), 'body': '', } #------------------------------------------------------ # Message loading for web interface #------------------------------------------------------ def _message_dict_get(self, cr, uid, msg, context=None): """ Return a dict representation of the message browse record. """ attachment_ids = self.pool.get('ir.attachment').name_get(cr, uid, [x.id for x in msg.attachment_ids], context=context) author_id = self.pool.get('res.partner').name_get(cr, uid, [msg.author_id.id], context=context)[0] author_user_id = self.pool.get('res.users').name_get(cr, uid, [msg.author_id.user_ids[0].id], context=context)[0] partner_ids = self.pool.get('res.partner').name_get(cr, uid, [x.id for x in msg.partner_ids], context=context) return { 'id': msg.id, 'type': msg.type, 'attachment_ids': attachment_ids, 'body': msg.body, 'model': msg.model, 'res_id': msg.res_id, 'record_name': msg.record_name, 'subject': msg.subject, 'date': msg.date, 'author_id': author_id, 'author_user_id': author_user_id, 'partner_ids': partner_ids, 'child_ids': [], } def message_read_tree_flatten(self, cr, uid, messages, current_level, level, context=None): """ Given a tree with several roots of following structure : [ {'id': 1, 'child_ids': [ {'id': 11, 'child_ids': [...] },], {...} ] Flatten it to have a maximum number of levels, 0 being flat and sort messages in a level according to a key of the messages. Perform the flattening at leafs if above the maximum depth, then get back in the tree. :param context: ``sort_key``: key for sorting (id by default) :param context: ``sort_reverse``: reverser order for sorting (True by default) """ def _flatten(msg_dict): """ from {'id': x, 'child_ids': [{child1}, {child2}]} get [{'id': x, 'child_ids': []}, {child1}, {child2}] """ child_ids = msg_dict.pop('child_ids', []) msg_dict['child_ids'] = [] return [msg_dict] + child_ids # return sorted([msg_dict] + child_ids, key=itemgetter('id'), reverse=True) context = context or {} # Depth-first flattening for message in messages: if message.get('type') == 'expandable': continue message['child_ids'] = self.message_read_tree_flatten(cr, uid, message['child_ids'], current_level + 1, level, context=context) # Flatten if above maximum depth if current_level < level: return_list = messages else: return_list = [] for message in messages: for flat_message in _flatten(message): return_list.append(flat_message) return sorted(return_list, key=itemgetter(context.get('sort_key', 'id')), reverse=context.get('sort_reverse', True)) def message_read(self, cr, uid, ids=False, domain=[], thread_level=0, limit=None, context=None): """ If IDs are provided, fetch these records. Otherwise use the domain to fetch the matching records. After having fetched the records provided by IDs, it will fetch the parents to have well-formed threads. :return list: list of trees of messages """ limit = limit or self._message_read_limit context = context or {} if not ids: ids = self.search(cr, uid, domain, context=context, limit=limit) messages = self.browse(cr, uid, ids, context=context) result = [] tree = {} # key: ID, value: record for msg in messages: if len(result) < (limit - 1): record = self._message_dict_get(cr, uid, msg, context=context) if thread_level and msg.parent_id: while msg.parent_id: if msg.parent_id.id in tree: record_parent = tree[msg.parent_id.id] else: record_parent = self._message_dict_get(cr, uid, msg.parent_id, context=context) if msg.parent_id.parent_id: tree[msg.parent_id.id] = record_parent if record['id'] not in [x['id'] for x in record_parent['child_ids']]: record_parent['child_ids'].append(record) record = record_parent msg = msg.parent_id if msg.id not in tree: result.append(record) tree[msg.id] = record else: result.append({ 'type': 'expandable', 'domain': [('id', '<=', msg.id)] + domain, 'context': context, 'thread_level': thread_level, # should be improve accodting to level of records 'id': -1, }) break # Flatten the result if thread_level > 0: result = self.message_read_tree_flatten(cr, uid, result, 0, thread_level, context=context) return result #------------------------------------------------------ # Email api #------------------------------------------------------ def init(self, cr): cr.execute("""SELECT indexname FROM pg_indexes WHERE indexname = 'mail_message_model_res_id_idx'""") if not cr.fetchone(): cr.execute("""CREATE INDEX mail_message_model_res_id_idx ON mail_message (model, res_id)""") def check_access_rule(self, cr, uid, ids, operation, context=None): """ mail.message access rule check - message received (a notification exists) -> ok - check rules of related document if exists - fallback on normal mail.message check """ if isinstance(ids, (int, long)): ids = [ids] # check messages for which you have a notification partner_id = self.pool.get('res.users').browse(cr, uid, uid, context=context).partner_id.id not_obj = self.pool.get('mail.notification') not_ids = not_obj.search(cr, uid, [ ('partner_id', '=', partner_id), ('message_id', 'in', ids), ], context=context) notified_ids = [notification.message_id.id for notification in not_obj.browse(cr, uid, not_ids, context=context) if notification.message_id.id in ids] # check messages linked to an existing document model_record_ids = {} document_ids = [] cr.execute('SELECT DISTINCT id, model, res_id FROM mail_message WHERE id = ANY (%s)', (ids,)) for id, rmod, rid in cr.fetchall(): if not (rmod and rid): continue document_ids.append(id) model_record_ids.setdefault(rmod, set()).add(rid) for model, mids in model_record_ids.items(): model_obj = self.pool.get(model) mids = model_obj.exists(cr, uid, mids) model_obj.check_access_rights(cr, uid, operation) model_obj.check_access_rule(cr, uid, mids, operation, context=context) # fall back on classic operation for other ids other_ids = set(ids).difference(set(notified_ids), set(document_ids)) super(mail_message, self).check_access_rule(cr, uid, other_ids, operation, context=None) def create(self, cr, uid, values, context=None): if not values.get('message_id') and values.get('res_id') and values.get('model'): values['message_id'] = tools.generate_tracking_message_id('%(model)s-%(res_id)s' % values) newid = super(mail_message, self).create(cr, uid, values, context) self.notify(cr, uid, newid, context=context) return newid def unlink(self, cr, uid, ids, context=None): # cascade-delete attachments that are directly attached to the message (should only happen # for mail.messages that act as parent for a standalone mail.mail record. attachments_to_delete = [] for mail in self.browse(cr, uid, ids, context=context): for attach in mail.attachment_ids: if attach.res_model == 'mail.message' and attach.res_id == mail.id: attachments_to_delete.append(attach.id) if attachments_to_delete: self.pool.get('ir.attachment').unlink(cr, uid, attachments_to_delete, context=context) return super(mail_message,self).unlink(cr, uid, ids, context=context) def notify(self, cr, uid, newid, context=None): """ Add the related record followers to the destination partner_ids. Call mail_notification.notify to manage the email sending """ message = self.browse(cr, uid, newid, context=context) partners_to_notify = set([]) # add all partner_ids of the message if message.partner_ids: partners_to_notify |= set(partner.id for partner in message.partner_ids) # add all followers and set add them in partner_ids if message.model and message.res_id: record = self.pool.get(message.model).browse(cr, uid, message.res_id, context=context) extra_notified = set(partner.id for partner in record.message_follower_ids) missing_notified = extra_notified - partners_to_notify if missing_notified: message.write({'partner_ids': [(4, p_id) for p_id in missing_notified]}) partners_to_notify |= extra_notified self.pool.get('mail.notification').notify(cr, uid, list(partners_to_notify), newid, context=context) def copy(self, cr, uid, id, default=None, context=None): """Overridden to avoid duplicating fields that are unique to each email""" if default is None: default = {} default.update(message_id=False, headers=False) return super(mail_message, self).copy(cr, uid, id, default=default, context=context)