diff --git a/golem_mail/wizard/mail_compose_message.py b/golem_mail/wizard/mail_compose_message.py new file mode 100644 index 0000000..fbecede --- /dev/null +++ b/golem_mail/wizard/mail_compose_message.py @@ -0,0 +1,182 @@ +# -*- coding: utf-8 -*- + +# Copyright 2018 Youssef El Ouahby +# Copyright 2018 Fabien Bourgeois +# +# 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 . +""" Mail Compose Message Adaptations """ + +from odoo import _, api, fields, models, SUPERUSER_ID, tools +from odoo.tools.safe_eval import safe_eval + + + +class MailComposer(models.TransientModel): + """ Mail Compose Message Adaptations """ + _inherit = 'mail.compose.message' + + from_presend_wizard = fields.Boolean() + + @api.multi + def send_mail(self, auto_commit=False): + """ Process the wizard content and proceed with sending the related + email(s), rendering any template patterns on the fly if needed. """ + for wizard in self: + # Duplicate attachments linked to the email.template. + # Indeed, basic mail.compose.message wizard duplicates attachments in mass + # mailing mode. But in 'single post' mode, attachments of an email template + # also have to be duplicated to avoid changing their ownership. + if wizard.attachment_ids and wizard.composition_mode != 'mass_mail' and wizard.template_id: + new_attachment_ids = [] + for attachment in wizard.attachment_ids: + if attachment in wizard.template_id.attachment_ids: + new_attachment_ids.append(attachment.copy({'res_model': 'mail.compose.message', 'res_id': wizard.id}).id) + else: + new_attachment_ids.append(attachment.id) + wizard.write({'attachment_ids': [(6, 0, new_attachment_ids)]}) + + # Mass Mailing + mass_mode = wizard.composition_mode in ('mass_mail', 'mass_post') + + Mail = self.env['mail.mail'] + ActiveModel = self.env[wizard.model if wizard.model else 'mail.thread'] + if wizard.template_id: + # template user_signature is added when generating body_html + # mass mailing: use template auto_delete value -> note, for emails mass mailing only + Mail = Mail.with_context(mail_notify_user_signature=False) + ActiveModel = ActiveModel.with_context(mail_notify_user_signature=False, mail_auto_delete=wizard.template_id.auto_delete) + if not hasattr(ActiveModel, 'message_post'): + ActiveModel = self.env['mail.thread'].with_context(thread_model=wizard.model) + if wizard.composition_mode == 'mass_post': + # do not send emails directly but use the queue instead + # add context key to avoid subscribing the author + ActiveModel = ActiveModel.with_context(mail_notify_force_send=False, mail_create_nosubscribe=True) + # wizard works in batch mode: [res_id] or active_ids or active_domain + if mass_mode and wizard.use_active_domain and wizard.model: + res_ids = self.env[wizard.model].search(safe_eval(wizard.active_domain)).ids + elif mass_mode and wizard.model and self._context.get('active_ids'): + if wizard.from_presend_wizard: + res_ids = self._context['partners_from_wizard'] + else: + res_ids = self._context['active_ids'] + else: + res_ids = [wizard.res_id] + + batch_size = int(self.env['ir.config_parameter'].sudo().get_param('mail.batch_size')) or self._batch_size + sliced_res_ids = [res_ids[i:i + batch_size] for i in range(0, len(res_ids), batch_size)] + + if wizard.composition_mode == 'mass_mail' or wizard.is_log or (wizard.composition_mode == 'mass_post' and not wizard.notify): # log a note: subtype is False + subtype_id = False + elif wizard.subtype_id: + subtype_id = wizard.subtype_id.id + else: + subtype_id = self.sudo().env.ref('mail.mt_comment', raise_if_not_found=False).id + + for res_ids in sliced_res_ids: + batch_mails = Mail + if wizard.from_presend_wizard: + emails_values, all_mail_values = wizard.get_mail_values(res_ids) + for email_val in emails_values: + batch_mails |= Mail.create(email_val) + else: + all_mail_values = wizard.get_mail_values(res_ids) + for res_id, mail_values in all_mail_values.iteritems(): + if wizard.composition_mode == 'mass_mail': + batch_mails |= Mail.create(mail_values) + else: + ActiveModel.browse(res_id).message_post( + message_type=wizard.message_type, + subtype_id=subtype_id, + **mail_values) + + if wizard.composition_mode == 'mass_mail': + batch_mails.send(auto_commit=auto_commit) + + return {'type': 'ir.actions.act_window_close'} + + @api.multi + def get_mail_values(self, res_ids): + """Generate the values that will be used by send_mail to create mail_messages + or mail_mails. """ + self.ensure_one() + results = dict.fromkeys(res_ids, False) + rendered_values = {} + mass_mail_mode = self.composition_mode == 'mass_mail' + + # render all template-based value at once + if mass_mail_mode and self.model: + rendered_values = self.render_message(res_ids) + # compute alias-based reply-to in batch + reply_to_value = dict.fromkeys(res_ids, None) + if mass_mail_mode and not self.no_auto_thread: + # reply_to_value = self.env['mail.thread'].with_context(thread_model=self.model).browse(res_ids).message_get_reply_to(default=self.email_from) + reply_to_value = self.env['mail.thread'].with_context(thread_model=self.model).message_get_reply_to(res_ids, default=self.email_from) + for res_id in res_ids: + # static wizard (mail.message) values + mail_values = { + 'subject': self.subject, + 'body': self.body or '', + 'parent_id': self.parent_id and self.parent_id.id, + 'partner_ids': [partner.id for partner in self.partner_ids], + 'attachment_ids': [attach.id for attach in self.attachment_ids], + 'author_id': self.author_id.id, + 'email_from': self.email_from, + 'record_name': self.record_name, + 'no_auto_thread': self.no_auto_thread, + 'mail_server_id': self.mail_server_id.id, + } + + # mass mailing: rendering override wizard static values + if mass_mail_mode and self.model: + if self.model in self.env and hasattr(self.env[self.model], 'message_get_email_values'): + mail_values.update(self.env[self.model].browse(res_id).message_get_email_values()) + # keep a copy unless specifically requested, reset record name (avoid browsing records) + mail_values.update(notification=not self.auto_delete_message, model=self.model, res_id=res_id, record_name=False) + # auto deletion of mail_mail + if self.auto_delete or self.template_id.auto_delete: + mail_values['auto_delete'] = True + # rendered values using template + email_dict = rendered_values[res_id] + mail_values['partner_ids'] += email_dict.pop('partner_ids', []) + mail_values.update(email_dict) + if not self.no_auto_thread: + mail_values.pop('reply_to') + if reply_to_value.get(res_id): + mail_values['reply_to'] = reply_to_value[res_id] + if self.no_auto_thread and not mail_values.get('reply_to'): + mail_values['reply_to'] = mail_values['email_from'] + # mail_mail values: body -> body_html, partner_ids -> recipient_ids + mail_values['body_html'] = mail_values.get('body', '') + mail_values['recipient_ids'] = [(4, id) for id in mail_values.pop('partner_ids', [])] + + # process attachments: should not be encoded before being processed by message_post / mail_mail create + mail_values['attachments'] = [(name, base64.b64decode(enc_cont)) for name, enc_cont in email_dict.pop('attachments', list())] + attachment_ids = [] + for attach_id in mail_values.pop('attachment_ids'): + new_attach_id = self.env['ir.attachment'].browse(attach_id).copy({'res_model': self._name, 'res_id': self.id}) + attachment_ids.append(new_attach_id.id) + mail_values['attachment_ids'] = self.env['mail.thread']._message_preprocess_attachments( + mail_values.pop('attachments', []), + attachment_ids, 'mail.message', 0) + results[res_id] = mail_values + emails_result = [] + if self.from_presend_wizard: + for email in self._context['emails_from_wizard']: + result = results[res_ids[0]] + result.pop('recipient_ids', []) + result.pop('res_id', []) + result['email_to'] = email + emails_result.append(dict(result)) + return emails_result, results + return results