odoo/addons/mail/mail_message.py

# -*- coding: utf-8 -*-
##############################################################################
#
#    OpenERP, Open Source Management Solution
#    Copyright (C) 2010-today OpenERP SA (<http://www.openerp.com>)
#
#    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 <http://www.gnu.org/licenses/>
#
##############################################################################

import logging
from email.header import decode_header
from osv import osv, fields
import tools

_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):
    """Model holding messages: system notification (replacing res.log
    notifications), comments (for OpenChatter feature). This model also
    provides facilities to parse new email messages. Type of messages are
    differentiated using the 'type' column. """

    _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
        else:
            return name[:18] + '...'

    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, uid, [message.res_id], context=context)[0][1])
        return result

    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 = {
        # should we keep a distinction between email and comment ?
        '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('Content'),
    }

    def _needaction_domain_get(self, cr, uid, context={}):
        if self._needaction:
            partner_id = self.pool.get('res.users').browse(cr, uid, uid, context=context).partner_id.id
            return [('notification_ids.partner_id','=',partner_id),('notification_ids.read','=',False)]
        return []

    def _get_default_author(self, cr, uid, context={}):
        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': _get_default_author
    }


    #------------------------------------------------------
    # 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_get(self, cr, uid, messages, domain, limit, flat=True, context=None):
        """ Get a tree representation of the browse records.
            :param messages: mail.message browse record list
        """
        roots = []
        tree = {} # key: ID, value: record
        for msg in messages:
            record = self._message_dict_get(cr, uid, msg, context=context)
            if not flat 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
                    record_parent['child_ids'].append(record)
                    record = record_parent
                    msg = msg.parent_id
            if msg.id not in tree:
                roots.append(record)
                tree[msg.id] = record
            if len(roots) >= limit:
                roots.append({
                    'type': 'expandable',
                    'domain': [('id','<=', msg.id)]+domain,
                    'context': context,
                    'thread_level': thread_level  # should be improve accodting to level of records
                })
        return roots

    def message_read(self, cr, uid, ids=False, domain=[], thread_level=0, limit=None, context=None):
        """ Fetch and read messages. 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 children
            according to thread_level.

            :return result: A tree structure: list of msg_dict, with child_ids
                being also msg_dict.
        """
        limit = limit or self._message_read_limit
        if ids is False:
            ids = self.search(cr, uid, domain, context=context, limit=limit)
        messages = self.browse(cr, uid, ids, context=context)
        # FP note - TDE note: TODO: flatten - order
        # TDE NOTE: add expandable: TO FIX WHEN SPECIFIED
        trees = self.message_read_tree_get(cr, uid, messages, domain, limit, thread_level==0, context=context)
        return trees


    #------------------------------------------------------
    # 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(self, cr, uid, ids, mode, context=None):
        """
        You can read/write a message if:
          - you received it (a notification exists) or
          - you can read the related document (res_model, res_id)
        If a message is not attached to a document, normal access rights on
        the mail.message object apply.
        """
        if not ids:
            return
        if isinstance(ids, (int, long)):
            ids = [ids]

        partner_id = self.pool.get('res.users').browse(cr, uid, uid, context=context).partner_id.id

        # check messages for which you have a notification
        not_obj = self.pool.get('mail.notification')
        not_ids = not_obj.search(cr, uid, [
            ('partner_id', '=', partner_id),
            ('message_id', 'in', ids),
        ], context=context)
        for notification in not_obj.browse(cr, uid, not_ids, context=context):
            if notification.message_id.id in ids:
                pass
                # FP Note: we should put this again !!!
                #ids.remove(notification.message_id.id)

        # check messages according to related documents
        res_ids = {}
        cr.execute('SELECT DISTINCT model, res_id FROM mail_message WHERE id = ANY (%s)', (ids,))
        for rmod, rid in cr.fetchall():
            if not (rmod and rid):
                continue
            res_ids.setdefault(rmod,set()).add(rid)

        ima_obj = self.pool.get('ir.model.access')
        for model, mids in res_ids.items():
            mids = self.pool.get(model).exists(cr, uid, mids)
            ima_obj.check(cr, uid, model, mode)
            self.pool.get(model).check_access_rule(cr, uid, mids, mode, context=context)

    def create(self, cr, uid, values, context=None):
        newid = super(mail_message, self).create(cr, uid, values, context)
        self.check(cr, uid, [newid], mode='create', context=context)
        self.notify(cr, uid, newid, context=context)
        return newid

    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 = []
        # add all partner_ids of the message
        if message.partner_ids:
            for partner in message.partner_ids:
                if partner.id not in partners_to_notify:
                    partners_to_notify.append(partner.id)
        # add all followers and set them as partner_ids
        if message.model and message.res_id:
            modobj = self.pool.get(message.model)
            for follower in modobj.browse(cr, uid, message.res_id, context=context).message_follower_ids:
                partners_to_notify.append(follower.id)
                self.write(cr, uid, [newid], {'partner_ids': [(4, follower.id)]}, context=context)
        self.pool.get('mail.notification').notify(cr, uid, partners_to_notify, newid, context=context)

    def read(self, cr, uid, ids, fields_to_read=None, context=None, load='_classic_read'):
        self.check(cr, uid, ids, 'read', context=context)
        return super(mail_message, self).read(cr, uid, ids, fields_to_read, context, load)

    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 = {}
        self.check(cr, uid, [id], 'read', context=context)
        default.update(message_id=False, headers=False)
        return super(mail_message,self).copy(cr, uid, id, default=default, context=context)

    def write(self, cr, uid, ids, vals, context=None):
        result = super(mail_message, self).write(cr, uid, ids, vals, context)
        self.check(cr, uid, ids, 'write', context=context)
        return result

    def unlink(self, cr, uid, ids, context=None):
        self.check(cr, uid, ids, 'unlink', context=context)
        return super(mail_message, self).unlink(cr, uid, ids, context)


class mail_notification(osv.Model):
    """ mail_notification is a relational table modeling messages pushed to partners.
    """
    _inherit = 'mail.notification'
    _columns = {
        'message_id': fields.many2one('mail.message', string='Message',
                        ondelete='cascade', required=True, select=1),
    }

    def set_message_read(self, cr, uid, msg_id, context=None):
        partner_id = self.pool.get('res.users').browse(cr, uid, uid, context=context).partner_id.id
        notif_ids = self.search(cr, uid, [('partner_id', '=', partner_id), ('message_id', '=', msg_id)], context=context)
        return self.write(cr, uid, notif_ids, {'read': True})