addons/mail/mail_followers.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 from openerp.osv import osv, fields
  22 from openerp import tools, SUPERUSER_ID
  23 from openerp.tools.translate import _
  24 from openerp.tools.mail import plaintext2html
  25
  26 class mail_followers(osv.Model):
  27     """ mail_followers holds the data related to the follow mechanism inside
  28         OpenERP. Partners can choose to follow documents (records) of any kind
  29         that inherits from mail.thread. Following documents allow to receive
  30         notifications for new messages.
  31         A subscription is characterized by:
  32             :param: res_model: model of the followed objects
  33             :param: res_id: ID of resource (may be 0 for every objects)
  34     """
  35     _name = 'mail.followers'
  36     _rec_name = 'partner_id'
  37     _log_access = False
  38     _description = 'Document Followers'
  39     _columns = {
  40         'res_model': fields.char('Related Document Model',
  41                         required=True, select=1,
  42                         help='Model of the followed resource'),
  43         'res_id': fields.integer('Related Document ID', select=1,
  44                         help='Id of the followed resource'),
  45         'partner_id': fields.many2one('res.partner', string='Related Partner',
  46                         ondelete='cascade', required=True, select=1),
  47         'subtype_ids': fields.many2many('mail.message.subtype', string='Subtype',
  48             help="Message subtypes followed, meaning subtypes that will be pushed onto the user's Wall."),
  49     }
  50
  51     #
  52     # Modifying followers change access rights to individual documents. As the
  53     # cache may contain accessible/inaccessible data, one has to refresh it.
  54     #
  55     def create(self, cr, uid, vals, context=None):
  56         res = super(mail_followers, self).create(cr, uid, vals, context=context)
  57         self.invalidate_cache(cr, uid, context=context)
  58         return res
  59
  60     def write(self, cr, uid, ids, vals, context=None):
  61         res = super(mail_followers, self).write(cr, uid, ids, vals, context=context)
  62         self.invalidate_cache(cr, uid, context=context)
  63         return res
  64
  65     def unlink(self, cr, uid, ids, context=None):
  66         res = super(mail_followers, self).unlink(cr, uid, ids, context=context)
  67         self.invalidate_cache(cr, uid, context=context)
  68         return res
  69
  70
  71 class mail_notification(osv.Model):
  72     """ Class holding notifications pushed to partners. Followers and partners
  73         added in 'contacts to notify' receive notifications. """
  74     _name = 'mail.notification'
  75     _rec_name = 'partner_id'
  76     _log_access = False
  77     _description = 'Notifications'
  78
  79     _columns = {
  80         'partner_id': fields.many2one('res.partner', string='Contact',
  81                         ondelete='cascade', required=True, select=1),
  82         'is_read': fields.boolean('Read', select=1),
  83         'starred': fields.boolean('Starred', select=1,
  84             help='Starred message that goes into the todo mailbox'),
  85         'message_id': fields.many2one('mail.message', string='Message',
  86                         ondelete='cascade', required=True, select=1),
  87     }
  88
  89     _defaults = {
  90         'is_read': False,
  91         'starred': False,
  92     }
  93
  94     def init(self, cr):
  95         cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = %s', ('mail_notification_partner_id_read_starred_message_id',))
  96         if not cr.fetchone():
  97             cr.execute('CREATE INDEX mail_notification_partner_id_read_starred_message_id ON mail_notification (partner_id, is_read, starred, message_id)')
  98
  99     def get_partners_to_email(self, cr, uid, ids, message, context=None):
 100         """ Return the list of partners to notify, based on their preferences.
 101
 102             :param browse_record message: mail.message to notify
 103             :param list partners_to_notify: optional list of partner ids restricting
 104                 the notifications to process
 105         """
 106         notify_pids = []
 107         for notification in self.browse(cr, uid, ids, context=context):
 108             if notification.is_read:
 109                 continue
 110             partner = notification.partner_id
 111             # Do not send to partners without email address defined
 112             if not partner.email:
 113                 continue
 114             # Do not send to partners having same email address than the author (can cause loops or bounce effect due to messy database)
 115             if message.author_id and message.author_id.email == partner.email:
 116                 continue
 117             # Partner does not want to receive any emails or is opt-out
 118             if partner.notify_email == 'none':
 119                 continue
 120             notify_pids.append(partner.id)
 121         return notify_pids
 122
 123     def get_signature_footer(self, cr, uid, user_id, res_model=None, res_id=None, context=None):
 124         """ Format a standard footer for notification emails (such as pushed messages
 125             notification or invite emails).
 126             Format:
 127                 <p>--<br />
 128                     Administrator
 129                 </p>
 130                 <div>
 131                     <small>Sent from <a ...>Your Company</a> using <a ...>OpenERP</a>.</small>
 132                 </div>
 133         """
 134         footer = ""
 135         if not user_id:
 136             return footer
 137
 138         # add user signature
 139         user = self.pool.get("res.users").browse(cr, SUPERUSER_ID, [user_id], context=context)[0]
 140         if user.signature:
 141             signature = user.signature
 142         else:
 143             signature = "--<br />%s" % user.name
 144         footer = tools.append_content_to_html(footer, signature, plaintext=False)
 145         # add company signature
 146         if user.company_id.website:
 147             website_url = ('http://%s' % user.company_id.website) if not user.company_id.website.lower().startswith(('http:', 'https:')) \
 148                 else user.company_id.website
 149             company = "<a style='color:inherit' href='%s'>%s</a>" % (website_url, user.company_id.name)
 150         else:
 151             company = user.company_id.name
 152         sent_by = _('Sent by %(company)s using %(odoo)s.')
 153
 154         signature_company = '<small>%s</small>' % (sent_by % {
 155             'company': company,
 156             'odoo': "<a style='color:inherit' href='https://www.odoo.com/'>Odoo</a>"
 157         })
 158         footer = tools.append_content_to_html(footer, signature_company, plaintext=False, container_tag='div')
 159
 160         return footer
 161
 162     def update_message_notification(self, cr, uid, ids, message_id, partner_ids, context=None):
 163         existing_pids = set()
 164         new_pids = set()
 165         new_notif_ids = []
 166
 167         for notification in self.browse(cr, uid, ids, context=context):
 168             existing_pids.add(notification.partner_id.id)
 169
 170         # update existing notifications
 171         self.write(cr, uid, ids, {'is_read': False}, context=context)
 172
 173         # create new notifications
 174         new_pids = set(partner_ids) - existing_pids
 175         for new_pid in new_pids:
 176             new_notif_ids.append(self.create(cr, uid, {'message_id': message_id, 'partner_id': new_pid, 'is_read': False}, context=context))
 177         return new_notif_ids
 178
 179     def _notify_email(self, cr, uid, ids, message_id, force_send=False, user_signature=True, context=None):
 180         message = self.pool['mail.message'].browse(cr, SUPERUSER_ID, message_id, context=context)
 181
 182         # compute partners
 183         email_pids = self.get_partners_to_email(cr, uid, ids, message, context=None)
 184         if not email_pids:
 185             return True
 186
 187         # compute email body (signature, company data)
 188         body_html = message.body
 189         # add user signature except for mail groups, where users are usually adding their own signatures already
 190         if user_signature and message.model != 'mail.group':
 191             user_id = message.author_id and message.author_id.user_ids and message.author_id.user_ids[0] and message.author_id.user_ids[0].id or None
 192             signature_company = self.get_signature_footer(cr, uid, user_id, res_model=message.model, res_id=message.res_id, context=context)
 193             body_html = tools.append_content_to_html(body_html, signature_company, plaintext=False, container_tag='div')
 194
 195         # compute email references
 196         references = message.parent_id.message_id if message.parent_id else False
 197
 198         # custom values
 199         custom_values = dict()
 200         if message.model and message.res_id and self.pool.get(message.model) and hasattr(self.pool[message.model], 'message_get_email_values'):
 201             custom_values = self.pool[message.model].message_get_email_values(cr, uid, message.res_id, message, context=context)
 202
 203         # create email values
 204         max_recipients = 50
 205         chunks = [email_pids[x:x + max_recipients] for x in xrange(0, len(email_pids), max_recipients)]
 206         email_ids = []
 207         for chunk in chunks:
 208             mail_values = {
 209                 'mail_message_id': message.id,
 210                 'auto_delete': True,
 211                 'body_html': body_html,
 212                 'recipient_ids': [(4, id) for id in chunk],
 213                 'references': references,
 214             }
 215             mail_values.update(custom_values)
 216             email_ids.append(self.pool.get('mail.mail').create(cr, uid, mail_values, context=context))
 217         if force_send and len(chunks) < 2:  # for more than 50 followers, use the queue system
 218             self.pool.get('mail.mail').send(cr, uid, email_ids, context=context)
 219         return True
 220
 221     def _notify(self, cr, uid, message_id, partners_to_notify=None, context=None,
 222                 force_send=False, user_signature=True):
 223         """ Send by email the notification depending on the user preferences
 224
 225             :param list partners_to_notify: optional list of partner ids restricting
 226                 the notifications to process
 227             :param bool force_send: if True, the generated mail.mail is
 228                 immediately sent after being created, as if the scheduler
 229                 was executed for this message only.
 230             :param bool user_signature: if True, the generated mail.mail body is
 231                 the body of the related mail.message with the author's signature
 232         """
 233         notif_ids = self.search(cr, SUPERUSER_ID, [('message_id', '=', message_id), ('partner_id', 'in', partners_to_notify)], context=context)
 234
 235         # update or create notifications
 236         new_notif_ids = self.update_message_notification(cr, SUPERUSER_ID, notif_ids, message_id, partners_to_notify, context=context)
 237
 238         # mail_notify_noemail (do not send email) or no partner_ids: do not send, return
 239         if context and context.get('mail_notify_noemail'):
 240             return True
 241
 242         # browse as SUPERUSER_ID because of access to res_partner not necessarily allowed
 243         self._notify_email(cr, SUPERUSER_ID, new_notif_ids, message_id, force_send, user_signature, context=context)