# -*- coding: utf-8 -*- # Part of Odoo. See LICENSE file for full copyright and licensing details. import logging import pytz from datetime import timedelta from odoo import _, api, Command, fields, models, tools from odoo.addons.base.models.res_partner import _tz_get from odoo.exceptions import UserError, ValidationError from odoo.osv import expression from odoo.tools import format_datetime, is_html_empty from odoo.tools.misc import formatLang 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' def _default_event_mail_type_ids(self): return [(0, 0, {'notification_type': 'mail', 'interval_nbr': 0, 'interval_unit': 'now', 'interval_type': 'after_sub', 'template_ref': 'mail.template, %i' % self.env.ref('event.event_subscription').id, }), (0, 0, {'notification_type': 'mail', 'interval_nbr': 1, 'interval_unit': 'hours', 'interval_type': 'before_event', 'template_ref': 'mail.template, %i' % self.env.ref('event.event_reminder').id, }), (0, 0, {'notification_type': 'mail', 'interval_nbr': 3, 'interval_unit': 'days', 'interval_type': 'before_event', 'template_ref': 'mail.template, %i' % self.env.ref('event.event_reminder').id, })] name = fields.Char('Event Template', required=True, translate=True) note = fields.Html(string='Note') sequence = fields.Integer(default=10) # tickets event_type_ticket_ids = fields.One2many('event.type.ticket', 'event_type_id', string='Tickets') tag_ids = fields.Many2many('event.tag', string="Tags") # registration has_seats_limitation = fields.Boolean('Limited Seats') seats_max = fields.Integer( 'Maximum Registrations', compute='_compute_seats_max', readonly=False, store=True, help="It will select this default maximum value when you choose this event") default_timezone = fields.Selection( _tz_get, string='Timezone', default=lambda self: self.env.user.tz or 'UTC') # communication event_type_mail_ids = fields.One2many( 'event.type.mail', 'event_type_id', string='Mail Schedule', default=_default_event_mail_type_ids) # ticket reports ticket_instructions = fields.Html('Ticket Instructions', translate=True, help="This information will be printed on your tickets.") @api.depends('has_seats_limitation') def _compute_seats_max(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, id' @api.model def default_get(self, fields_list): result = super().default_get(fields_list) if 'date_begin' in fields_list and 'date_begin' not in result: now = fields.Datetime.now() # Round the datetime to the nearest half hour (e.g. 08:17 => 08:30 and 08:37 => 09:00) result['date_begin'] = now.replace(second=0, microsecond=0) + timedelta(minutes=-now.minute % 30) if 'date_end' in fields_list and 'date_end' not in result and result.get('date_begin'): result['date_end'] = result['date_begin'] + timedelta(days=1) return result def _get_default_stage_id(self): return self.env['event.stage'].search([], limit=1) def _default_description(self): # avoid template branding with rendering_bundle=True return self.env['ir.ui.view'].with_context(rendering_bundle=True) \ ._render_template('event.event_default_descripton') def _default_event_mail_ids(self): return self.env['event.type']._default_event_mail_type_ids() @api.model def _lang_get(self): return self.env['res.lang'].get_installed() name = fields.Char(string='Event', translate=True, required=True) note = fields.Html(string='Note', store=True, compute="_compute_note", readonly=False) 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) use_barcode = fields.Boolean(compute='_compute_use_barcode') 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, check_company=True) 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") # properties registration_properties_definition = fields.PropertiesDefinition('Registration Properties') # Kanban fields kanban_state = fields.Selection([('normal', 'In Progress'), ('done', 'Done'), ('blocked', 'Blocked')], default='normal', copy=False) 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, copy=False) 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', 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('Limit Attendees', required=True, compute='_compute_seats_limited', precompute=True, readonly=False, store=True) seats_reserved = fields.Integer( string='Number of Registrations', store=False, readonly=True, compute='_compute_seats') seats_available = fields.Integer( string='Available Seats', store=False, readonly=True, compute='_compute_seats') seats_used = fields.Integer( string='Number of Attendees', store=False, readonly=True, compute='_compute_seats') seats_taken = fields.Integer( string='Number of Taken Seats', store=False, readonly=True, compute='_compute_seats') # Registration fields 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_started = fields.Boolean( 'Registrations started', compute='_compute_event_registrations_started', help="registrations have started if the current datetime is after the earliest starting date of tickets." ) 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_datetime = fields.Datetime( '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', precompute=True, 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') is_finished = fields.Boolean(compute='_compute_is_finished', search='_search_is_finished') # Location and communication address_id = fields.Many2one( 'res.partner', string='Venue', default=lambda self: self.env.company.partner_id.id, check_company=True, tracking=True ) address_search = fields.Many2one( 'res.partner', string='Address', compute='_compute_address_search', search='_search_address_search') address_inline = fields.Char( string='Venue (formatted for one line uses)', compute='_compute_address_inline', compute_sudo=True) country_id = fields.Many2one( 'res.country', 'Country', related='address_id.country_id', readonly=False, store=True) lang = fields.Selection(_lang_get, string='Language', help="All the communication emails sent to attendees will be translated in this language.") # ticket reports badge_format = fields.Selection( string='Badge Dimension', selection=[ ('A4_french_fold', 'A4 foldable'), ('A6', 'A6'), ('four_per_sheet', '4 per sheet') ], default='A6', required=True) badge_image = fields.Image('Badge Background', max_width=1024, max_height=1024) ticket_instructions = fields.Html('Ticket Instructions', translate=True, compute='_compute_ticket_instructions', store=True, readonly=False, help="This information will be printed on your tickets.") def _compute_use_barcode(self): use_barcode = self.env['ir.config_parameter'].sudo().get_param('event.use_event_barcode') == 'True' for record in self: record.use_barcode = use_barcode @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', 'registration_ids.active') def _compute_seats(self): """ Determine available, reserved, used and taken seats. """ # initialize fields to 0 for event in self: event.seats_reserved = event.seats_used = event.seats_available = 0 # aggregate registrations by event and by state state_field = { '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 ('open', 'done') AND active = true GROUP BY event_id, state """ self.env['event.registration'].flush_model(['event_id', 'state', 'active']) 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 and expected 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) event.seats_taken = event.seats_reserved + event.seats_used @api.depends('date_tz', 'start_sale_datetime') def _compute_event_registrations_started(self): for event in self: event = event._set_tz_context() if event.start_sale_datetime: current_datetime = fields.Datetime.context_timestamp(event, fields.Datetime.now()) start_sale_datetime = fields.Datetime.context_timestamp(event, event.start_sale_datetime) event.event_registrations_started = (current_datetime >= start_sale_datetime) else: event.event_registrations_started = True @api.depends('date_tz', 'event_registrations_started', 'date_end', 'seats_available', 'seats_limited', 'seats_max', '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_datetime -> lowest start date of tickets (if any; start_sale_datetime 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.event_registrations_started and \ (date_end_tz >= current_datetime if date_end_tz else True) and \ (not event.seats_limited or not event.seats_max 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_datetime') 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_datetime for ticket in event.event_ticket_ids if not ticket.is_expired] event.start_sale_datetime = min(start_dates) if start_dates and all(start_dates) else False @api.depends('event_ticket_ids.sale_available', 'seats_available', 'seats_limited') def _compute_event_registrations_sold_out(self): """Note that max seats limits for events and sum of limits for all its tickets may not be equal to enable flexibility. E.g. max 20 seats for ticket A, 20 seats for ticket B * With max 20 seats for the event * Without limit set on the event (=40, but the customer didn't explicitly write 40) """ for event in self: event.event_registrations_sold_out = ( (event.seats_limited and event.seats_max and not event.seats_available) or (event.event_ticket_ids and all(ticket.is_sold_out for ticket in event.event_ticket_ids)) ) @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 UserError(_('This operator is not supported')) if not isinstance(value, bool): raise UserError(_('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)] return domain @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('date_end') def _compute_is_finished(self): for event in self: if not event.date_end: event.is_finished = False continue event = event._set_tz_context() current_datetime = fields.Datetime.context_timestamp(event, fields.Datetime.now()) datetime_end = fields.Datetime.context_timestamp(event, event.date_end) event.is_finished = datetime_end <= current_datetime def _search_is_finished(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_end', '<=', now)] else: domain = [('date_end', '>', now)] return domain @api.depends('event_type_id') def _compute_date_tz(self): for event in self: if 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' @api.depends('address_id') def _compute_address_search(self): for event in self: event.address_search = event.address_id def _search_address_search(self, operator, value): if operator != 'ilike' or not isinstance(value, str): raise NotImplementedError(_('Operation not supported.')) return expression.OR([ [('address_id.name', 'ilike', value)], [('address_id.street', 'ilike', value)], [('address_id.street2', 'ilike', value)], [('address_id.city', 'ilike', value)], [('address_id.zip', 'ilike', value)], [('address_id.state_id', 'ilike', value)], [('address_id.country_id', 'ilike', value)], ]) # 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_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 = self._default_event_mail_ids() 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_done) and not(mail._origin.mail_registration_ids) ) command = [Command.unlink(mail.id) for mail in mails_to_remove] # lines to add: those which do not have the exact copy available in lines to keep if event.event_type_id.event_type_mail_ids: mails_to_keep_vals = {mail._prepare_event_mail_values() for mail in event.event_mail_ids - mails_to_remove} for mail in event.event_type_id.event_type_mail_ids: mail_values = mail._prepare_event_mail_values() if mail_values not in mails_to_keep_vals: command.append(Command.create(mail_values._asdict())) 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_datetime 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.event_type_ticket_ids: 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.depends('event_type_id') def _compute_note(self): for event in self: if event.event_type_id and not is_html_empty(event.event_type_id.note): event.note = event.event_type_id.note @api.depends('event_type_id') def _compute_ticket_instructions(self): for event in self: if is_html_empty(event.ticket_instructions) and not \ is_html_empty(event.event_type_id.ticket_instructions): event.ticket_instructions = event.event_type_id.ticket_instructions @api.depends('address_id') def _compute_address_inline(self): """Use venue address if available, otherwise its name, finally ''. """ for event in self: if (event.address_id.contact_address or '').strip(): event.address_inline = ', '.join( frag.strip() for frag in event.address_id.contact_address.split('\n') if frag.strip() ) else: event.address_inline = event.address_id.name or '' @api.constrains('seats_max', 'seats_limited', 'registration_ids') def _check_seats_availability(self, minimal_availability=0): sold_out_events = [] for event in self: if event.seats_limited and event.seats_max and event.seats_available < minimal_availability: sold_out_events.append( (_('- "%(event_name)s": Missing %(nb_too_many)i seats.', event_name=event.name, nb_too_many=-event.seats_available))) if sold_out_events: raise ValidationError(_('There are not enough seats available for:') + '\n%s\n' % '\n'.join(sold_out_events)) @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.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): events = super(EventEvent, self).create(vals_list) for res in events: if res.organizer_id: res.message_subscribe([res.organizer_id.id]) self.env.flush_all() 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.depends('event_registrations_sold_out', 'seats_limited', 'seats_max', 'seats_available') @api.depends_context('name_with_seats_availability') def _compute_display_name(self): """Adds ticket seats availability if requested by context.""" if not self.env.context.get('name_with_seats_availability'): return super()._compute_display_name() for event in self: # event or its tickets are sold out if event.event_registrations_sold_out: name = _('%(event_name)s (Sold out)', event_name=event.name) elif event.seats_limited and event.seats_max: name = _( '%(event_name)s (%(count)s seats remaining)', event_name=event.name, count=formatLang(self.env, event.seats_available, digits=0), ) else: name = event.name event.display_name = name @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) @api.model def _get_mail_message_access(self, res_ids, operation, model_name=None): if ( operation == 'create' and self.env.user.has_group('event.group_event_registration_desk') and (not model_name or model_name == 'event.event') ): # allow the registration desk users to post messages on Event # can not be done with "_mail_post_access" otherwise public user will be # able to post on published Event (see website_event) return 'read' return super(EventEvent, self)._get_mail_message_access(res_ids, operation, model_name) 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)], limit=1, order='sequence') if first_ended_stage: self.write({'stage_id': first_ended_stage.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 = event.date_begin.astimezone(pytz.timezone(event.date_tz)) cal_event.add('dtend').value = event.date_end.astimezone(pytz.timezone(event.date_tz)) cal_event.add('summary').value = event.name if event.address_id: cal_event.add('location').value = event.address_inline result[event.id] = cal.serialize().encode('utf-8') return result def _get_tickets_access_hash(self, registration_ids): """ Returns the ground truth hash for accessing the tickets in route /event//my_tickets. The dl links are always made event-dependant, hence the method linked to the record in self. """ self.ensure_one() return tools.hmac(self.env(su=True), 'event-registration-ticket-report-access', (self.id, sorted(registration_ids))) @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()