addons/mail/mail_alias.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Business Applications
   5 #    Copyright (C) 2012 OpenERP S.A. (<http://openerp.com>).
   6 #
   7 #    This program is free software: you can redistribute it and/or modify
   8 #    it under the terms of the GNU Affero General Public License as
   9 #    published by the Free Software Foundation, either version 3 of the
  10 #    License, or (at your option) any later version.
  11 #
  12 #    This program is distributed in the hope that it will be useful,
  13 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 #    GNU Affero General Public License for more details.
  16 #
  17 #    You should have received a copy of the GNU Affero General Public License
  18 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20 ##############################################################################
  21
  22 import logging
  23 import re
  24 import unicodedata
  25
  26 from openerp.osv import fields, osv
  27 from openerp.tools import ustr
  28 from openerp.modules.registry import RegistryManager
  29 from openerp import SUPERUSER_ID
  30
  31 _logger = logging.getLogger(__name__)
  32
  33 # Inspired by http://stackoverflow.com/questions/517923
  34 def remove_accents(input_str):
  35     """Suboptimal-but-better-than-nothing way to replace accented
  36     latin letters by an ASCII equivalent. Will obviously change the
  37     meaning of input_str and work only for some cases"""
  38     input_str = ustr(input_str)
  39     nkfd_form = unicodedata.normalize('NFKD', input_str)
  40     return u''.join([c for c in nkfd_form if not unicodedata.combining(c)])
  41
  42 class mail_alias(osv.Model):
  43     """A Mail Alias is a mapping of an email address with a given OpenERP Document
  44        model. It is used by OpenERP's mail gateway when processing incoming emails
  45        sent to the system. If the recipient address (To) of the message matches
  46        a Mail Alias, the message will be either processed following the rules
  47        of that alias. If the message is a reply it will be attached to the
  48        existing discussion on the corresponding record, otherwise a new
  49        record of the corresponding model will be created.
  50
  51        This is meant to be used in combination with a catch-all email configuration
  52        on the company's mail server, so that as soon as a new mail.alias is
  53        created, it becomes immediately usable and OpenERP will accept email for it.
  54      """
  55     _name = 'mail.alias'
  56     _description = "Email Aliases"
  57     _rec_name = 'alias_name'
  58     _order = 'alias_model_id, alias_name'
  59
  60     def _get_alias_domain(self, cr, uid, ids, name, args, context=None):
  61         ir_config_parameter = self.pool.get("ir.config_parameter")
  62         domain = ir_config_parameter.get_param(cr, uid, "mail.catchall.domain", context=context)
  63         return dict.fromkeys(ids, domain or "")
  64
  65     _columns = {
  66         'alias_name': fields.char('Alias', required=True,
  67                             help="The name of the email alias, e.g. 'jobs' "
  68                                  "if you want to catch emails for <jobs@example.my.openerp.com>",),
  69         'alias_model_id': fields.many2one('ir.model', 'Aliased Model', required=True, ondelete="cascade",
  70                                           help="The model (OpenERP Document Kind) to which this alias "
  71                                                "corresponds. Any incoming email that does not reply to an "
  72                                                "existing record will cause the creation of a new record "
  73                                                "of this model (e.g. a Project Task)",
  74                                           # hack to only allow selecting mail_thread models (we might
  75                                           # (have a few false positives, though)
  76                                           domain="[('field_id.name', '=', 'message_ids')]"),
  77         'alias_user_id': fields.many2one('res.users', 'Owner',
  78                                            help="The owner of records created upon receiving emails on this alias. "
  79                                                 "If this field is not set the system will attempt to find the right owner "
  80                                                 "based on the sender (From) address, or will use the Administrator account "
  81                                                 "if no system user is found for that address."),
  82         'alias_defaults': fields.text('Default Values', required=True,
  83                                       help="A Python dictionary that will be evaluated to provide "
  84                                            "default values when creating new records for this alias."),
  85         'alias_force_thread_id': fields.integer('Record Thread ID',
  86                                       help="Optional ID of a thread (record) to which all incoming "
  87                                            "messages will be attached, even if they did not reply to it. "
  88                                            "If set, this will disable the creation of new records completely."),
  89         'alias_domain': fields.function(_get_alias_domain, string="Alias domain", type='char', size=None),
  90     }
  91
  92     _defaults = {
  93         'alias_defaults': '{}',
  94         'alias_user_id': lambda self,cr,uid,context: uid,
  95         # looks better when creating new aliases - even if the field is informative only
  96         'alias_domain': lambda self,cr,uid,context: self._get_alias_domain(cr, SUPERUSER_ID,[1],None,None)[1]
  97     }
  98
  99     _sql_constraints = [
 100         ('alias_unique', 'UNIQUE(alias_name)', 'Unfortunately this email alias is already used, please choose a unique one')
 101     ]
 102
 103     def _check_alias_defaults(self, cr, uid, ids, context=None):
 104         try:
 105             for record in self.browse(cr, uid, ids, context=context):
 106                 dict(eval(record.alias_defaults))
 107         except Exception:
 108             return False
 109         return True
 110
 111     _constraints = [
 112         (_check_alias_defaults, '''Invalid expression, it must be a literal python dictionary definition e.g. "{'field': 'value'}"''', ['alias_defaults']),
 113     ]
 114
 115     def name_get(self, cr, uid, ids, context=None):
 116         """Return the mail alias display alias_name, inclusing the implicit
 117            mail catchall domain from config.
 118            e.g. `jobs@openerp.my.openerp.com` or `sales@openerp.my.openerp.com`
 119         """
 120         return [(record['id'], "%s@%s" % (record['alias_name'], record['alias_domain']))
 121                     for record in self.read(cr, uid, ids, ['alias_name', 'alias_domain'], context=context)]
 122
 123     def _find_unique(self, cr, uid, name, context=None):
 124         """Find a unique alias name similar to ``name``. If ``name`` is
 125            already taken, make a variant by adding an integer suffix until
 126            an unused alias is found.
 127         """
 128         sequence = None
 129         while True:
 130             new_name = "%s%s" % (name, sequence) if sequence is not None else name
 131             if not self.search(cr, uid, [('alias_name', '=', new_name)]):
 132                 break
 133             sequence = (sequence + 1) if sequence else 2
 134         return new_name
 135
 136     def migrate_to_alias(self, cr, child_model_name, child_table_name, child_model_auto_init_fct,
 137         alias_id_column, alias_key, alias_prefix = '', alias_force_key = '', alias_defaults = {}, context=None):
 138         """ Installation hook to create aliases for all users and avoid constraint errors.
 139
 140             :param child_model_name: model name of the child class (i.e. res.users)
 141             :param child_table_name: table name of the child class (i.e. res_users)
 142             :param child_model_auto_init_fct: pointer to the _auto_init function
 143                 (i.e. super(res_users,self)._auto_init(cr, context=context))
 144             :param alias_id_column: alias_id column (i.e. self._columns['alias_id'])
 145             :param alias_key: name of the column used for the unique name (i.e. 'login')
 146             :param alias_prefix: prefix for the unique name (i.e. 'jobs' + ...)
 147             :param alias_force_key': name of the column for force_thread_id;
 148                 if empty string, not taken into account
 149             :param alias_defaults: dict, keys = mail.alias columns, values = child
 150                 model column name used for default values (i.e. {'job_id': 'id'})
 151         """
 152
 153         # disable the unique alias_id not null constraint, to avoid spurious warning during
 154         # super.auto_init. We'll reinstall it afterwards.
 155         alias_id_column.required = False
 156
 157         # call _auto_init
 158         child_model_auto_init_fct(cr, context=context)
 159
 160         registry = RegistryManager.get(cr.dbname)
 161         mail_alias = registry.get('mail.alias')
 162         child_class_model = registry.get(child_model_name)
 163         no_alias_ids = child_class_model.search(cr, SUPERUSER_ID, [('alias_id', '=', False)], context={'active_test':False})
 164         # Use read() not browse(), to avoid prefetching uninitialized inherited fields
 165         for obj_data in child_class_model.read(cr, SUPERUSER_ID, no_alias_ids, [alias_key]):
 166             alias_vals = {'alias_name': '%s%s' % (alias_prefix, obj_data[alias_key]) }
 167             if alias_force_key:
 168                 alias_vals['alias_force_thread_id'] = obj_data[alias_force_key]
 169             alias_vals['alias_defaults'] = dict( (k, obj_data[v]) for k, v in alias_defaults.iteritems())
 170             alias_id = mail_alias.create_unique_alias(cr, SUPERUSER_ID, alias_vals, model_name=child_model_name)
 171             child_class_model.write(cr, SUPERUSER_ID, obj_data['id'], {'alias_id': alias_id})
 172             _logger.info('Mail alias created for %s %s (uid %s)', child_model_name, obj_data[alias_key], obj_data['id'])
 173
 174         # Finally attempt to reinstate the missing constraint
 175         try:
 176             cr.execute('ALTER TABLE %s ALTER COLUMN alias_id SET NOT NULL' % (child_table_name))
 177         except Exception:
 178             _logger.warning("Table '%s': unable to set a NOT NULL constraint on column '%s' !\n"\
 179                             "If you want to have it, you should update the records and execute manually:\n"\
 180                             "ALTER TABLE %s ALTER COLUMN %s SET NOT NULL",
 181                             child_table_name, 'alias_id', child_table_name, 'alias_id')
 182
 183         # set back the unique alias_id constraint
 184         alias_id_column.required = True
 185
 186     def create_unique_alias(self, cr, uid, vals, model_name=None, context=None):
 187         """Creates an email.alias record according to the values provided in ``vals``,
 188         with 2 alterations: the ``alias_name`` value may be suffixed in order to
 189         make it unique, and the ``alias_model_id`` value will set to the
 190         model ID of the ``model_name`` value, if provided,
 191         """
 192         alias_name = re.sub(r'[^\w+]', '-', remove_accents(vals['alias_name'])).lower()
 193         alias_name = self._find_unique(cr, uid, alias_name, context=context)
 194         vals['alias_name'] = alias_name
 195         if model_name:
 196             model_id = self.pool.get('ir.model').search(cr, uid, [('model', '=', model_name)], context=context)[0]
 197             vals['alias_model_id'] = model_id
 198         return self.create(cr, uid, vals, context=context)