Damien Abeloos
498eb0cfed
* In the Communication tab, prevent inserting multiple duplicate lines
upon switching template.
- Before, when the user was switching between templates, the lines
introduced with the last template were not removed, and the amount of
lines only kept increasing.
- Now, only the lines that are linked to a registration are kept
* In the Tickets tab, prevent inserting multiple duplicate lines upon
switching template (Ticketing) if there was already tickets linked to a registration.
- Same problem as in the Communication tab, multiple lines could be introduced.
- Now, only the lines that are linked to a registration are kept
* Add 2 tests (compute mails and tickets) to ensure those behaviors are properly
maintained in future updates. As the issue occured only in a non-saved Form when
switching event_type templates, the tests are a little low level (since we have
to check the computed results directly in the Form).
* Remove the last 2 steps of the event_tour :
- They are a bit out of scope and they break the rythm (better to end on a high note)
Task ID : 2410217
PR : https://github.com/odoo/odoo/pull/63370
573 lines
27 KiB
Python
573 lines
27 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
import logging
|
|
import pytz
|
|
|
|
from odoo import _, api, Command, fields, models
|
|
from odoo.addons.base.models.res_partner import _tz_get
|
|
from odoo.tools import format_datetime
|
|
from odoo.exceptions import ValidationError
|
|
from odoo.tools.translate import html_translate
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
try:
|
|
import vobject
|
|
except ImportError:
|
|
_logger.warning("`vobject` Python module not found, iCal file generation disabled. Consider installing this module if you want to generate iCal files")
|
|
vobject = None
|
|
|
|
|
|
class EventType(models.Model):
|
|
_name = 'event.type'
|
|
_description = 'Event Template'
|
|
_order = 'sequence, id'
|
|
|
|
name = fields.Char('Event Template', required=True, translate=True)
|
|
sequence = fields.Integer()
|
|
# tickets
|
|
use_ticket = fields.Boolean('Ticketing')
|
|
event_type_ticket_ids = fields.One2many(
|
|
'event.type.ticket', 'event_type_id',
|
|
string='Tickets', compute='_compute_event_type_ticket_ids',
|
|
readonly=False, store=True)
|
|
tag_ids = fields.Many2many('event.tag', string="Tags")
|
|
# registration
|
|
has_seats_limitation = fields.Boolean('Limited Seats')
|
|
seats_max = fields.Integer(
|
|
'Maximum Registrations', compute='_compute_default_registration',
|
|
readonly=False, store=True,
|
|
help="It will select this default maximum value when you choose this event")
|
|
auto_confirm = fields.Boolean(
|
|
'Automatically Confirm Registrations', default=True,
|
|
help="Events and registrations will automatically be confirmed "
|
|
"upon creation, easing the flow for simple events.")
|
|
# location
|
|
use_timezone = fields.Boolean('Use Default Timezone')
|
|
default_timezone = fields.Selection(
|
|
_tz_get, string='Timezone', default=lambda self: self.env.user.tz or 'UTC')
|
|
# communication
|
|
use_mail_schedule = fields.Boolean(
|
|
'Automatically Send Emails', default=True)
|
|
event_type_mail_ids = fields.One2many(
|
|
'event.type.mail', 'event_type_id',
|
|
string='Mail Schedule', compute='_compute_event_type_mail_ids',
|
|
readonly=False, store=True)
|
|
|
|
@api.depends('use_mail_schedule')
|
|
def _compute_event_type_mail_ids(self):
|
|
for template in self:
|
|
if not template.use_mail_schedule:
|
|
template.event_type_mail_ids = [(5, 0)]
|
|
elif not template.event_type_mail_ids:
|
|
template.event_type_mail_ids = [(0, 0, {
|
|
'notification_type': 'mail',
|
|
'interval_unit': 'now',
|
|
'interval_type': 'after_sub',
|
|
'template_id': self.env.ref('event.event_subscription').id,
|
|
}), (0, 0, {
|
|
'notification_type': 'mail',
|
|
'interval_nbr': 10,
|
|
'interval_unit': 'days',
|
|
'interval_type': 'before_event',
|
|
'template_id': self.env.ref('event.event_reminder').id,
|
|
})]
|
|
|
|
@api.depends('use_ticket')
|
|
def _compute_event_type_ticket_ids(self):
|
|
for template in self:
|
|
if not template.use_ticket:
|
|
template.event_type_ticket_ids = [(5, 0)]
|
|
elif not template.event_type_ticket_ids:
|
|
template.event_type_ticket_ids = [(0, 0, {
|
|
'name': _('Registration'),
|
|
})]
|
|
|
|
@api.depends('has_seats_limitation')
|
|
def _compute_default_registration(self):
|
|
for template in self:
|
|
if not template.has_seats_limitation:
|
|
template.seats_max = 0
|
|
|
|
|
|
class EventEvent(models.Model):
|
|
"""Event"""
|
|
_name = 'event.event'
|
|
_description = 'Event'
|
|
_inherit = ['mail.thread', 'mail.activity.mixin']
|
|
_order = 'date_begin'
|
|
|
|
def _get_default_stage_id(self):
|
|
event_stages = self.env['event.stage'].search([])
|
|
return event_stages[0] if event_stages else False
|
|
|
|
def _default_description(self):
|
|
return self.env['ir.ui.view']._render_template('event.event_default_descripton')
|
|
|
|
name = fields.Char(string='Event', translate=True, required=True)
|
|
note = fields.Text(string='Note')
|
|
description = fields.Html(string='Description', translate=html_translate, sanitize_attributes=False, sanitize_form=False, default=_default_description)
|
|
active = fields.Boolean(default=True)
|
|
user_id = fields.Many2one(
|
|
'res.users', string='Responsible', tracking=True,
|
|
default=lambda self: self.env.user)
|
|
company_id = fields.Many2one(
|
|
'res.company', string='Company', change_default=True,
|
|
default=lambda self: self.env.company,
|
|
required=False)
|
|
organizer_id = fields.Many2one(
|
|
'res.partner', string='Organizer', tracking=True,
|
|
default=lambda self: self.env.company.partner_id,
|
|
domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
|
|
event_type_id = fields.Many2one('event.type', string='Template', ondelete='set null')
|
|
event_mail_ids = fields.One2many(
|
|
'event.mail', 'event_id', string='Mail Schedule', copy=True,
|
|
compute='_compute_event_mail_ids', readonly=False, store=True)
|
|
tag_ids = fields.Many2many(
|
|
'event.tag', string="Tags", readonly=False,
|
|
store=True, compute="_compute_tag_ids")
|
|
# Kanban fields
|
|
kanban_state = fields.Selection([('normal', 'In Progress'), ('done', 'Done'), ('blocked', 'Blocked')], default='normal')
|
|
kanban_state_label = fields.Char(
|
|
string='Kanban State Label', compute='_compute_kanban_state_label',
|
|
store=True, tracking=True)
|
|
stage_id = fields.Many2one(
|
|
'event.stage', ondelete='restrict', default=_get_default_stage_id,
|
|
group_expand='_read_group_stage_ids', tracking=True)
|
|
legend_blocked = fields.Char(related='stage_id.legend_blocked', string='Kanban Blocked Explanation', readonly=True)
|
|
legend_done = fields.Char(related='stage_id.legend_done', string='Kanban Valid Explanation', readonly=True)
|
|
legend_normal = fields.Char(related='stage_id.legend_normal', string='Kanban Ongoing Explanation', readonly=True)
|
|
# Seats and computation
|
|
seats_max = fields.Integer(
|
|
string='Maximum Attendees Number',
|
|
compute='_compute_seats_max', readonly=False, store=True,
|
|
help="For each event you can define a maximum registration of seats(number of attendees), above this numbers the registrations are not accepted.")
|
|
seats_limited = fields.Boolean('Maximum Attendees', required=True, compute='_compute_seats_limited',
|
|
readonly=False, store=True)
|
|
seats_reserved = fields.Integer(
|
|
string='Reserved Seats',
|
|
store=True, readonly=True, compute='_compute_seats')
|
|
seats_available = fields.Integer(
|
|
string='Available Seats',
|
|
store=True, readonly=True, compute='_compute_seats')
|
|
seats_unconfirmed = fields.Integer(
|
|
string='Unconfirmed Seat Reservations',
|
|
store=True, readonly=True, compute='_compute_seats')
|
|
seats_used = fields.Integer(
|
|
string='Number of Participants',
|
|
store=True, readonly=True, compute='_compute_seats')
|
|
seats_expected = fields.Integer(
|
|
string='Number of Expected Attendees',
|
|
compute_sudo=True, readonly=True, compute='_compute_seats_expected')
|
|
# Registration fields
|
|
auto_confirm = fields.Boolean(
|
|
string='Autoconfirmation', compute='_compute_auto_confirm', readonly=False, store=True,
|
|
help='Autoconfirm Registrations. Registrations will automatically be confirmed upon creation.')
|
|
registration_ids = fields.One2many('event.registration', 'event_id', string='Attendees')
|
|
event_ticket_ids = fields.One2many(
|
|
'event.event.ticket', 'event_id', string='Event Ticket', copy=True,
|
|
compute='_compute_event_ticket_ids', readonly=False, store=True)
|
|
event_registrations_open = fields.Boolean(
|
|
'Registration open', compute='_compute_event_registrations_open', compute_sudo=True,
|
|
help="Registrations are open if:\n"
|
|
"- the event is not ended\n"
|
|
"- there are seats available on event\n"
|
|
"- the tickets are sellable (if ticketing is used)")
|
|
event_registrations_sold_out = fields.Boolean(
|
|
'Sold Out', compute='_compute_event_registrations_sold_out', compute_sudo=True,
|
|
help='The event is sold out if no more seats are available on event. If ticketing is used and all tickets are sold out, the event will be sold out.')
|
|
start_sale_date = fields.Date(
|
|
'Start sale date', compute='_compute_start_sale_date',
|
|
help='If ticketing is used, contains the earliest starting sale date of tickets.')
|
|
# Date fields
|
|
date_tz = fields.Selection(
|
|
_tz_get, string='Timezone', required=True,
|
|
compute='_compute_date_tz', readonly=False, store=True)
|
|
date_begin = fields.Datetime(string='Start Date', required=True, tracking=True)
|
|
date_end = fields.Datetime(string='End Date', required=True, tracking=True)
|
|
date_begin_located = fields.Char(string='Start Date Located', compute='_compute_date_begin_tz')
|
|
date_end_located = fields.Char(string='End Date Located', compute='_compute_date_end_tz')
|
|
is_ongoing = fields.Boolean('Is Ongoing', compute='_compute_is_ongoing', search='_search_is_ongoing')
|
|
is_one_day = fields.Boolean(compute='_compute_field_is_one_day')
|
|
# Location and communication
|
|
address_id = fields.Many2one(
|
|
'res.partner', string='Venue', default=lambda self: self.env.company.partner_id.id,
|
|
tracking=True, domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
|
|
country_id = fields.Many2one(
|
|
'res.country', 'Country', related='address_id.country_id', readonly=False, store=True)
|
|
# badge fields
|
|
badge_front = fields.Html(string='Badge Front')
|
|
badge_back = fields.Html(string='Badge Back')
|
|
badge_innerleft = fields.Html(string='Badge Inner Left')
|
|
badge_innerright = fields.Html(string='Badge Inner Right')
|
|
event_logo = fields.Html(string='Event Logo')
|
|
|
|
@api.depends('stage_id', 'kanban_state')
|
|
def _compute_kanban_state_label(self):
|
|
for event in self:
|
|
if event.kanban_state == 'normal':
|
|
event.kanban_state_label = event.stage_id.legend_normal
|
|
elif event.kanban_state == 'blocked':
|
|
event.kanban_state_label = event.stage_id.legend_blocked
|
|
else:
|
|
event.kanban_state_label = event.stage_id.legend_done
|
|
|
|
@api.depends('seats_max', 'registration_ids.state')
|
|
def _compute_seats(self):
|
|
""" Determine reserved, available, reserved but unconfirmed and used seats. """
|
|
# initialize fields to 0
|
|
for event in self:
|
|
event.seats_unconfirmed = event.seats_reserved = event.seats_used = event.seats_available = 0
|
|
# aggregate registrations by event and by state
|
|
state_field = {
|
|
'draft': 'seats_unconfirmed',
|
|
'open': 'seats_reserved',
|
|
'done': 'seats_used',
|
|
}
|
|
base_vals = dict((fname, 0) for fname in state_field.values())
|
|
results = dict((event_id, dict(base_vals)) for event_id in self.ids)
|
|
if self.ids:
|
|
query = """ SELECT event_id, state, count(event_id)
|
|
FROM event_registration
|
|
WHERE event_id IN %s AND state IN ('draft', 'open', 'done')
|
|
GROUP BY event_id, state
|
|
"""
|
|
self.env['event.registration'].flush(['event_id', 'state'])
|
|
self._cr.execute(query, (tuple(self.ids),))
|
|
res = self._cr.fetchall()
|
|
for event_id, state, num in res:
|
|
results[event_id][state_field[state]] += num
|
|
|
|
# compute seats_available
|
|
for event in self:
|
|
event.update(results.get(event._origin.id or event.id, base_vals))
|
|
if event.seats_max > 0:
|
|
event.seats_available = event.seats_max - (event.seats_reserved + event.seats_used)
|
|
|
|
@api.depends('seats_unconfirmed', 'seats_reserved', 'seats_used')
|
|
def _compute_seats_expected(self):
|
|
for event in self:
|
|
event.seats_expected = event.seats_unconfirmed + event.seats_reserved + event.seats_used
|
|
|
|
@api.depends('date_tz', 'start_sale_date', 'date_end', 'seats_available', 'seats_limited', 'event_ticket_ids.sale_available')
|
|
def _compute_event_registrations_open(self):
|
|
""" Compute whether people may take registrations for this event
|
|
|
|
* event.date_end -> if event is done, registrations are not open anymore;
|
|
* event.start_sale_date -> lowest start date of tickets (if any; start_sale_date
|
|
is False if no ticket are defined, see _compute_start_sale_date);
|
|
* any ticket is available for sale (seats available) if any;
|
|
* seats are unlimited or seats are available;
|
|
"""
|
|
for event in self:
|
|
event = event._set_tz_context()
|
|
current_datetime = fields.Datetime.context_timestamp(event, fields.Datetime.now())
|
|
date_end_tz = event.date_end.astimezone(pytz.timezone(event.date_tz or 'UTC')) if event.date_end else False
|
|
event.event_registrations_open = (event.start_sale_date <= current_datetime.date() if event.start_sale_date else True) and \
|
|
(date_end_tz >= current_datetime if date_end_tz else True) and \
|
|
(not event.seats_limited or event.seats_available) and \
|
|
(not event.event_ticket_ids or any(ticket.sale_available for ticket in event.event_ticket_ids))
|
|
|
|
@api.depends('event_ticket_ids.start_sale_date')
|
|
def _compute_start_sale_date(self):
|
|
""" Compute the start sale date of an event. Currently lowest starting sale
|
|
date of tickets if they are used, of False. """
|
|
for event in self:
|
|
start_dates = [ticket.start_sale_date for ticket in event.event_ticket_ids if not ticket.is_expired]
|
|
event.start_sale_date = min(start_dates) if start_dates and all(start_dates) else False
|
|
|
|
@api.depends('event_ticket_ids.sale_available')
|
|
def _compute_event_registrations_sold_out(self):
|
|
for event in self:
|
|
if event.seats_limited and not event.seats_available:
|
|
event.event_registrations_sold_out = True
|
|
elif event.event_ticket_ids:
|
|
event.event_registrations_sold_out = not any(
|
|
ticket.seats_available > 0 if ticket.seats_limited else True for ticket in event.event_ticket_ids
|
|
)
|
|
else:
|
|
event.event_registrations_sold_out = False
|
|
|
|
@api.depends('date_tz', 'date_begin')
|
|
def _compute_date_begin_tz(self):
|
|
for event in self:
|
|
if event.date_begin:
|
|
event.date_begin_located = format_datetime(
|
|
self.env, event.date_begin, tz=event.date_tz, dt_format='medium')
|
|
else:
|
|
event.date_begin_located = False
|
|
|
|
@api.depends('date_tz', 'date_end')
|
|
def _compute_date_end_tz(self):
|
|
for event in self:
|
|
if event.date_end:
|
|
event.date_end_located = format_datetime(
|
|
self.env, event.date_end, tz=event.date_tz, dt_format='medium')
|
|
else:
|
|
event.date_end_located = False
|
|
|
|
@api.depends('date_begin', 'date_end')
|
|
def _compute_is_ongoing(self):
|
|
now = fields.Datetime.now()
|
|
for event in self:
|
|
event.is_ongoing = event.date_begin <= now < event.date_end
|
|
|
|
def _search_is_ongoing(self, operator, value):
|
|
if operator not in ['=', '!=']:
|
|
raise ValueError(_('This operator is not supported'))
|
|
if not isinstance(value, bool):
|
|
raise ValueError(_('Value should be True or False (not %s)'), value)
|
|
now = fields.Datetime.now()
|
|
if (operator == '=' and value) or (operator == '!=' and not value):
|
|
domain = [('date_begin', '<=', now), ('date_end', '>', now)]
|
|
else:
|
|
domain = ['|', ('date_begin', '>', now), ('date_end', '<=', now)]
|
|
event_ids = self.env['event.event']._search(domain)
|
|
return [('id', 'in', event_ids)]
|
|
|
|
@api.depends('date_begin', 'date_end', 'date_tz')
|
|
def _compute_field_is_one_day(self):
|
|
for event in self:
|
|
# Need to localize because it could begin late and finish early in
|
|
# another timezone
|
|
event = event._set_tz_context()
|
|
begin_tz = fields.Datetime.context_timestamp(event, event.date_begin)
|
|
end_tz = fields.Datetime.context_timestamp(event, event.date_end)
|
|
event.is_one_day = (begin_tz.date() == end_tz.date())
|
|
|
|
@api.depends('event_type_id')
|
|
def _compute_date_tz(self):
|
|
for event in self:
|
|
if event.event_type_id.use_timezone and event.event_type_id.default_timezone:
|
|
event.date_tz = event.event_type_id.default_timezone
|
|
if not event.date_tz:
|
|
event.date_tz = self.env.user.tz or 'UTC'
|
|
|
|
# seats
|
|
|
|
@api.depends('event_type_id')
|
|
def _compute_seats_max(self):
|
|
""" Update event configuration from its event type. Depends are set only
|
|
on event_type_id itself, not its sub fields. Purpose is to emulate an
|
|
onchange: if event type is changed, update event configuration. Changing
|
|
event type content itself should not trigger this method. """
|
|
for event in self:
|
|
if not event.event_type_id:
|
|
event.seats_max = event.seats_max or 0
|
|
else:
|
|
event.seats_max = event.event_type_id.seats_max or 0
|
|
|
|
@api.depends('event_type_id')
|
|
def _compute_seats_limited(self):
|
|
""" Update event configuration from its event type. Depends are set only
|
|
on event_type_id itself, not its sub fields. Purpose is to emulate an
|
|
onchange: if event type is changed, update event configuration. Changing
|
|
event type content itself should not trigger this method. """
|
|
for event in self:
|
|
if event.event_type_id.has_seats_limitation != event.seats_limited:
|
|
event.seats_limited = event.event_type_id.has_seats_limitation
|
|
if not event.seats_limited:
|
|
event.seats_limited = False
|
|
|
|
@api.depends('event_type_id')
|
|
def _compute_auto_confirm(self):
|
|
""" Update event configuration from its event type. Depends are set only
|
|
on event_type_id itself, not its sub fields. Purpose is to emulate an
|
|
onchange: if event type is changed, update event configuration. Changing
|
|
event type content itself should not trigger this method. """
|
|
for event in self:
|
|
event.auto_confirm = event.event_type_id.auto_confirm
|
|
|
|
@api.depends('event_type_id')
|
|
def _compute_event_mail_ids(self):
|
|
""" Update event configuration from its event type. Depends are set only
|
|
on event_type_id itself, not its sub fields. Purpose is to emulate an
|
|
onchange: if event type is changed, update event configuration. Changing
|
|
event type content itself should not trigger this method.
|
|
|
|
When synchronizing mails:
|
|
|
|
* lines that are not sent and have no registrations linked are remove;
|
|
* type lines are added;
|
|
"""
|
|
for event in self:
|
|
if not event.event_type_id and not event.event_mail_ids:
|
|
event.event_mail_ids = False
|
|
continue
|
|
|
|
# lines to keep: those with already sent emails or registrations
|
|
mails_to_remove = event.event_mail_ids.filtered(
|
|
lambda mail: not(mail._origin.mail_sent or mail._origin.mail_registration_ids)
|
|
)
|
|
command = [Command.unlink(mail.id) for mail in mails_to_remove]
|
|
if event.event_type_id.use_mail_schedule:
|
|
command += [
|
|
Command.create({
|
|
attribute_name: line[attribute_name] if not isinstance(line[attribute_name], models.BaseModel) else line[attribute_name].id
|
|
for attribute_name in self.env['event.type.mail']._get_event_mail_fields_whitelist()
|
|
}) for line in event.event_type_id.event_type_mail_ids
|
|
]
|
|
if command:
|
|
event.event_mail_ids = command
|
|
|
|
@api.depends('event_type_id')
|
|
def _compute_tag_ids(self):
|
|
""" Update event configuration from its event type. Depends are set only
|
|
on event_type_id itself, not its sub fields. Purpose is to emulate an
|
|
onchange: if event type is changed, update event configuration. Changing
|
|
event type content itself should not trigger this method. """
|
|
for event in self:
|
|
if not event.tag_ids and event.event_type_id.tag_ids:
|
|
event.tag_ids = event.event_type_id.tag_ids
|
|
|
|
@api.depends('event_type_id')
|
|
def _compute_event_ticket_ids(self):
|
|
""" Update event configuration from its event type. Depends are set only
|
|
on event_type_id itself, not its sub fields. Purpose is to emulate an
|
|
onchange: if event type is changed, update event configuration. Changing
|
|
event type content itself should not trigger this method.
|
|
|
|
When synchronizing tickets:
|
|
|
|
* lines that have no registrations linked are remove;
|
|
* type lines are added;
|
|
|
|
Note that updating event_ticket_ids triggers _compute_start_sale_date
|
|
(start_sale_date computation) so ensure result to avoid cache miss.
|
|
"""
|
|
for event in self:
|
|
if not event.event_type_id and not event.event_ticket_ids:
|
|
event.event_ticket_ids = False
|
|
continue
|
|
|
|
# lines to keep: those with existing registrations
|
|
tickets_to_remove = event.event_ticket_ids.filtered(lambda ticket: not ticket._origin.registration_ids)
|
|
command = [Command.unlink(ticket.id) for ticket in tickets_to_remove]
|
|
if event.event_type_id.use_ticket:
|
|
command += [
|
|
Command.create({
|
|
attribute_name: line[attribute_name] if not isinstance(line[attribute_name], models.BaseModel) else line[attribute_name].id
|
|
for attribute_name in self.env['event.type.ticket']._get_event_ticket_fields_whitelist()
|
|
}) for line in event.event_type_id.event_type_ticket_ids
|
|
]
|
|
event.event_ticket_ids = command
|
|
|
|
@api.constrains('seats_max', 'seats_available', 'seats_limited')
|
|
def _check_seats_limit(self):
|
|
if any(event.seats_limited and event.seats_max and event.seats_available < 0 for event in self):
|
|
raise ValidationError(_('No more available seats.'))
|
|
|
|
@api.constrains('date_begin', 'date_end')
|
|
def _check_closing_date(self):
|
|
for event in self:
|
|
if event.date_end < event.date_begin:
|
|
raise ValidationError(_('The closing date cannot be earlier than the beginning date.'))
|
|
|
|
@api.depends('name', 'date_begin', 'date_end')
|
|
def name_get(self):
|
|
result = []
|
|
for event in self:
|
|
date_begin = fields.Datetime.from_string(event.date_begin)
|
|
date_end = fields.Datetime.from_string(event.date_end)
|
|
dates = [fields.Date.to_string(fields.Datetime.context_timestamp(event, dt)) for dt in [date_begin, date_end] if dt]
|
|
dates = sorted(set(dates))
|
|
result.append((event.id, '%s (%s)' % (event.name, ' - '.join(dates))))
|
|
return result
|
|
|
|
@api.model
|
|
def _read_group_stage_ids(self, stages, domain, order):
|
|
return self.env['event.stage'].search([])
|
|
|
|
@api.model_create_multi
|
|
def create(self, vals_list):
|
|
for vals in vals_list:
|
|
# Temporary fix for ``seats_limited`` and ``date_tz`` required fields
|
|
vals.update(self._sync_required_computed(vals))
|
|
|
|
events = super(EventEvent, self).create(vals_list)
|
|
for res in events:
|
|
if res.organizer_id:
|
|
res.message_subscribe([res.organizer_id.id])
|
|
events.flush()
|
|
return events
|
|
|
|
def write(self, vals):
|
|
if 'stage_id' in vals and 'kanban_state' not in vals:
|
|
# reset kanban state when changing stage
|
|
vals['kanban_state'] = 'normal'
|
|
res = super(EventEvent, self).write(vals)
|
|
if vals.get('organizer_id'):
|
|
self.message_subscribe([vals['organizer_id']])
|
|
return res
|
|
|
|
@api.returns('self', lambda value: value.id)
|
|
def copy(self, default=None):
|
|
self.ensure_one()
|
|
default = dict(default or {}, name=_("%s (copy)") % (self.name))
|
|
return super(EventEvent, self).copy(default)
|
|
|
|
def _sync_required_computed(self, values):
|
|
# TODO: See if the change to seats_limited affects this ?
|
|
""" Call compute fields in cache to find missing values for required fields
|
|
(seats_limited and date_tz) in case they are not given in values """
|
|
missing_fields = list(set(['seats_limited', 'date_tz']).difference(set(values.keys())))
|
|
if missing_fields and values:
|
|
cache_event = self.new(values)
|
|
cache_event._compute_seats_limited()
|
|
cache_event._compute_date_tz()
|
|
return dict((fname, cache_event[fname]) for fname in missing_fields)
|
|
else:
|
|
return {}
|
|
|
|
def _set_tz_context(self):
|
|
self.ensure_one()
|
|
return self.with_context(tz=self.date_tz or 'UTC')
|
|
|
|
def action_set_done(self):
|
|
"""
|
|
Action which will move the events
|
|
into the first next (by sequence) stage defined as "Ended"
|
|
(if they are not already in an ended stage)
|
|
"""
|
|
first_ended_stage = self.env['event.stage'].search([('pipe_end', '=', True)], order='sequence')
|
|
if first_ended_stage:
|
|
self.write({'stage_id': first_ended_stage[0].id})
|
|
|
|
def mail_attendees(self, template_id, force_send=False, filter_func=lambda self: self.state != 'cancel'):
|
|
for event in self:
|
|
for attendee in event.registration_ids.filtered(filter_func):
|
|
self.env['mail.template'].browse(template_id).send_mail(attendee.id, force_send=force_send)
|
|
|
|
def _get_ics_file(self):
|
|
""" Returns iCalendar file for the event invitation.
|
|
:returns a dict of .ics file content for each event
|
|
"""
|
|
result = {}
|
|
if not vobject:
|
|
return result
|
|
|
|
for event in self:
|
|
cal = vobject.iCalendar()
|
|
cal_event = cal.add('vevent')
|
|
|
|
cal_event.add('created').value = fields.Datetime.now().replace(tzinfo=pytz.timezone('UTC'))
|
|
cal_event.add('dtstart').value = fields.Datetime.from_string(event.date_begin).replace(tzinfo=pytz.timezone('UTC'))
|
|
cal_event.add('dtend').value = fields.Datetime.from_string(event.date_end).replace(tzinfo=pytz.timezone('UTC'))
|
|
cal_event.add('summary').value = event.name
|
|
if event.address_id:
|
|
cal_event.add('location').value = event.sudo().address_id.contact_address
|
|
|
|
result[event.id] = cal.serialize().encode('utf-8')
|
|
return result
|
|
|
|
@api.autovacuum
|
|
def _gc_mark_events_done(self):
|
|
""" move every ended events in the next 'ended stage' """
|
|
ended_events = self.env['event.event'].search([
|
|
('date_end', '<', fields.Datetime.now()),
|
|
('stage_id.pipe_end', '=', False),
|
|
])
|
|
if ended_events:
|
|
ended_events.action_set_done()
|