1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
# -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.
import uuid
import base64
import logging
from collections import defaultdict
from odoo import api, fields, models, _
from odoo.addons.base.models.res_partner import _tz_get
from odoo.exceptions import UserError
from odoo.tools.misc import clean_context
from odoo.tools import split_every
_logger = logging.getLogger(__name__)
class Attendee(models.Model):
""" Calendar Attendee Information """
_name = 'calendar.attendee'
_rec_name = 'common_name'
_description = 'Calendar Attendee Information'
_order = 'create_date ASC'
def _default_access_token(self):
return uuid.uuid4().hex
STATE_SELECTION = [
('needsAction', 'Needs Action'),
('tentative', 'Maybe'),
('declined', 'No'),
('accepted', 'Yes'),
]
# event
event_id = fields.Many2one('calendar.event', 'Meeting linked', required=True, ondelete='cascade')
recurrence_id = fields.Many2one('calendar.recurrence', related='event_id.recurrence_id')
# attendee
partner_id = fields.Many2one('res.partner', 'Attendee', required=True, readonly=True, ondelete='cascade')
email = fields.Char('Email', related='partner_id.email')
phone = fields.Char('Phone', related='partner_id.phone')
common_name = fields.Char('Common name', compute='_compute_common_name', store=True)
access_token = fields.Char('Invitation Token', default=_default_access_token)
mail_tz = fields.Selection(_tz_get, compute='_compute_mail_tz', help='Timezone used for displaying time in the mail template')
# state
state = fields.Selection(STATE_SELECTION, string='Status', default='needsAction')
availability = fields.Selection(
[('free', 'Available'), ('busy', 'Busy')], 'Available/Busy', readonly=True)
@api.depends('partner_id', 'partner_id.name', 'email')
def _compute_common_name(self):
for attendee in self:
attendee.common_name = attendee.partner_id.name or attendee.email
def _compute_mail_tz(self):
for attendee in self:
attendee.mail_tz = attendee.partner_id.tz
@api.model_create_multi
def create(self, vals_list):
for values in vals_list:
# by default, if no state is given for the attendee corresponding to the current user
# that means he's the event organizer so we can set his state to "accepted"
if 'state' not in values and values.get('partner_id') == self.env.user.partner_id.id:
values['state'] = 'accepted'
if not values.get("email") and values.get("common_name"):
common_nameval = values.get("common_name").split(':')
email = [x for x in common_nameval if '@' in x]
values['email'] = email[0] if email else ''
values['common_name'] = values.get("common_name")
attendees = super().create(vals_list)
attendees._subscribe_partner()
return attendees
def unlink(self):
self._unsubscribe_partner()
return super().unlink()
def copy(self, default=None):
raise UserError(_('You cannot duplicate a calendar attendee.'))
def _subscribe_partner(self):
mapped_followers = defaultdict(lambda: self.env['calendar.event'])
for event in self.event_id:
partners = (event.attendee_ids & self).partner_id - event.message_partner_ids
# current user is automatically added as followers, don't add it twice.
partners -= self.env.user.partner_id
mapped_followers[partners] |= event
for partners, events in mapped_followers.items():
events.message_subscribe(partner_ids=partners.ids)
def _unsubscribe_partner(self):
for event in self.event_id:
partners = (event.attendee_ids & self).partner_id & event.message_partner_ids
event.message_unsubscribe(partner_ids=partners.ids)
def _send_invitation_emails(self):
""" Hook to be able to override the invitation email sending process.
Notably inside appointment to use a different mail template from the appointment type. """
self._send_mail_to_attendees(
self.env.ref('calendar.calendar_template_meeting_invitation', raise_if_not_found=False),
force_send=True,
)
def _send_mail_to_attendees(self, mail_template, force_send=False):
""" Send mail for event invitation to event attendees.
:param mail_template: a mail.template record
:param force_send: if set to True, the mail(s) will be sent immediately (instead of the next queue processing)
"""
if force_send:
force_send_limit = int(self.env['ir.config_parameter'].sudo().get_param('mail.mail_force_send_limit', 100))
notified_attendees = self
for event, attendees in self.grouped('event_id').items():
if event._skip_send_mail_status_update():
notified_attendees -= attendees
if isinstance(mail_template, str):
raise ValueError('Template should be a template record, not an XML ID anymore.')
if self.env['ir.config_parameter'].sudo().get_param('calendar.block_mail') or self._context.get("no_mail_to_attendees"):
return False
if not mail_template:
_logger.warning("No template passed to %s notification process. Skipped.", self)
return False
# get ics file for all meetings
ics_files = notified_attendees.event_id._get_ics_file()
# If the mail template has attachments, prepare copies for each attendee (to be added to each attendee's mail)
if mail_template.attachment_ids:
# Setting res_model to ensure attachments are linked to the msg (otherwise only internal users are allowed link attachments)
attachments_values = [a.copy_data({'res_id': 0, 'res_model': 'mail.compose.message'})[0] for a in mail_template.attachment_ids]
attachments_values *= len(self)
attendee_attachment_ids = self.env['ir.attachment'].create(attachments_values).ids
# Map attendees to their respective attachments
template_attachment_count = len(mail_template.attachment_ids)
attendee_id_attachment_id_map = dict(zip(self.ids, split_every(template_attachment_count, attendee_attachment_ids, list)))
mail_messages = self.env['mail.message']
for attendee in notified_attendees:
if attendee.email and attendee._should_notify_attendee():
event_id = attendee.event_id.id
ics_file = ics_files.get(event_id)
# Add template attachments copies to the attendee's email, if available
attachment_ids = attendee_id_attachment_id_map[attendee.id] if mail_template.attachment_ids else []
if ics_file:
context = {
**clean_context(self.env.context),
'no_document': True, # An ICS file must not create a document
}
attachment_ids += self.env['ir.attachment'].with_context(context).create({
'datas': base64.b64encode(ics_file),
'description': 'invitation.ics',
'mimetype': 'text/calendar',
'res_id': 0,
'res_model': 'mail.compose.message',
'name': 'invitation.ics',
}).ids
body = mail_template._render_field(
'body_html',
attendee.ids,
compute_lang=True)[attendee.id]
subject = mail_template._render_field(
'subject',
attendee.ids,
compute_lang=True)[attendee.id]
mail_messages += attendee.event_id.with_context(no_document=True).sudo().message_notify(
email_from=attendee.event_id.user_id.email_formatted or self.env.user.email_formatted,
author_id=attendee.event_id.user_id.partner_id.id or self.env.user.partner_id.id,
body=body,
subject=subject,
partner_ids=attendee.partner_id.ids,
email_layout_xmlid='mail.mail_notification_light',
attachment_ids=attachment_ids,
force_send=False,
)
# batch sending at the end
if force_send and len(notified_attendees) < force_send_limit:
mail_messages.sudo().mail_ids.send_after_commit()
def _should_notify_attendee(self):
""" Utility method that determines if the attendee should be notified.
By default, we do not want to notify (aka no message and no mail) the current user
if he is part of the attendees. But for reminders, mail_notify_author could be forced
(Override in appointment to ignore that rule and notify all attendees if it's an appointment)
"""
self.ensure_one()
partner_not_sender = self.partner_id != self.env.user.partner_id
mail_notify_author = self.env.context.get('mail_notify_author')
return partner_not_sender or mail_notify_author
def do_tentative(self):
""" Makes event invitation as Tentative. """
return self.write({'state': 'tentative'})
def do_accept(self):
""" Marks event invitation as Accepted. """
for attendee in self:
attendee.event_id.message_post(
author_id=attendee.partner_id.id,
body=_("%s has accepted the invitation", attendee.common_name),
subtype_xmlid="calendar.subtype_invitation",
)
return self.write({'state': 'accepted'})
def do_decline(self):
""" Marks event invitation as Declined. """
for attendee in self:
attendee.event_id.message_post(
author_id=attendee.partner_id.id,
body=_("%s has declined the invitation", attendee.common_name),
subtype_xmlid="calendar.subtype_invitation",
)
return self.write({'state': 'declined'})
|
