mirror of
https://github.com/bringout/oca-ocb-core.git
synced 2026-04-20 06:52:01 +02:00
195 lines
10 KiB
Python
195 lines
10 KiB
Python
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from odoo import api, fields, models, _
|
|
from odoo.exceptions import UserError
|
|
from odoo.tools.misc import formatLang
|
|
|
|
|
|
class EventEventTicket(models.Model):
|
|
""" Ticket model allowing to have different kind of registrations for a given
|
|
event. Ticket are based on ticket type as they share some common fields
|
|
and behavior. Those models come from <= v13 Odoo event.event.ticket that
|
|
modeled both concept: tickets for event templates, and tickets for events. """
|
|
_name = 'event.event.ticket'
|
|
_inherit = ['event.type.ticket']
|
|
_description = 'Event Ticket'
|
|
_order = "event_id, sequence, name, id"
|
|
|
|
@api.model
|
|
def default_get(self, fields):
|
|
res = super().default_get(fields)
|
|
if 'name' in fields and (not res.get('name') or res['name'] == _('Registration')) and self.env.context.get('default_event_name'):
|
|
res['name'] = _('Registration for %s', self.env.context['default_event_name'])
|
|
return res
|
|
|
|
# description
|
|
event_type_id = fields.Many2one(ondelete='set null', required=False)
|
|
event_id = fields.Many2one(
|
|
'event.event', string="Event",
|
|
ondelete='cascade', required=True, index=True)
|
|
company_id = fields.Many2one('res.company', related='event_id.company_id')
|
|
# sale
|
|
start_sale_datetime = fields.Datetime(string="Registration Start")
|
|
end_sale_datetime = fields.Datetime(string="Registration End")
|
|
is_launched = fields.Boolean(string='Are sales launched', compute='_compute_is_launched')
|
|
is_expired = fields.Boolean(string='Is Expired', compute='_compute_is_expired')
|
|
sale_available = fields.Boolean(
|
|
string='Is Available', compute='_compute_sale_available', compute_sudo=True,
|
|
help='Whether it is possible to sell these tickets')
|
|
registration_ids = fields.One2many('event.registration', 'event_ticket_id', string='Registrations')
|
|
# seats
|
|
seats_reserved = fields.Integer(string='Reserved Seats', compute='_compute_seats', store=False)
|
|
seats_available = fields.Integer(string='Available Seats', compute='_compute_seats', store=False)
|
|
seats_used = fields.Integer(string='Used Seats', compute='_compute_seats', store=False)
|
|
seats_taken = fields.Integer(string="Taken Seats", compute="_compute_seats", store=False)
|
|
limit_max_per_order = fields.Integer(string='Limit per Order', default=0,
|
|
help="Maximum of this product per order.\nSet to 0 to ignore this rule")
|
|
is_sold_out = fields.Boolean(
|
|
'Sold Out', compute='_compute_is_sold_out', help='Whether seats are not available for this ticket.')
|
|
# reports
|
|
color = fields.Char('Color', default="#875A7B")
|
|
|
|
@api.depends('end_sale_datetime', 'event_id.date_tz')
|
|
def _compute_is_expired(self):
|
|
for ticket in self:
|
|
ticket = ticket._set_tz_context()
|
|
current_datetime = fields.Datetime.context_timestamp(ticket, fields.Datetime.now())
|
|
if ticket.end_sale_datetime:
|
|
end_sale_datetime = fields.Datetime.context_timestamp(ticket, ticket.end_sale_datetime)
|
|
ticket.is_expired = end_sale_datetime < current_datetime
|
|
else:
|
|
ticket.is_expired = False
|
|
|
|
@api.depends('start_sale_datetime', 'event_id.date_tz')
|
|
def _compute_is_launched(self):
|
|
now = fields.Datetime.now()
|
|
for ticket in self:
|
|
if not ticket.start_sale_datetime:
|
|
ticket.is_launched = True
|
|
else:
|
|
ticket = ticket._set_tz_context()
|
|
current_datetime = fields.Datetime.context_timestamp(ticket, now)
|
|
start_sale_datetime = fields.Datetime.context_timestamp(ticket, ticket.start_sale_datetime)
|
|
ticket.is_launched = start_sale_datetime <= current_datetime
|
|
|
|
@api.depends('is_expired', 'start_sale_datetime', 'event_id.date_tz', 'seats_available', 'seats_max')
|
|
def _compute_sale_available(self):
|
|
for ticket in self:
|
|
ticket.sale_available = ticket.is_launched and not ticket.is_expired and not ticket.is_sold_out
|
|
|
|
@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 + compute seats availability
|
|
for ticket in self:
|
|
ticket.seats_reserved = ticket.seats_used = ticket.seats_available = 0
|
|
# aggregate registrations by ticket and by state
|
|
results = {}
|
|
if self.ids:
|
|
state_field = {
|
|
'open': 'seats_reserved',
|
|
'done': 'seats_used',
|
|
}
|
|
query = """ SELECT event_ticket_id, state, count(event_id)
|
|
FROM event_registration
|
|
WHERE event_ticket_id IN %s AND state IN ('open', 'done') AND active = true
|
|
GROUP BY event_ticket_id, state
|
|
"""
|
|
self.env['event.registration'].flush_model(['event_id', 'event_ticket_id', 'state', 'active'])
|
|
self.env.cr.execute(query, (tuple(self.ids),))
|
|
for event_ticket_id, state, num in self.env.cr.fetchall():
|
|
results.setdefault(event_ticket_id, {})[state_field[state]] = num
|
|
|
|
# compute seats_available
|
|
for ticket in self:
|
|
ticket.update(results.get(ticket._origin.id or ticket.id, {}))
|
|
if ticket.seats_max > 0:
|
|
ticket.seats_available = ticket.seats_max - (ticket.seats_reserved + ticket.seats_used)
|
|
ticket.seats_taken = ticket.seats_reserved + ticket.seats_used
|
|
|
|
@api.depends('seats_limited', 'seats_available', 'event_id.event_registrations_sold_out')
|
|
def _compute_is_sold_out(self):
|
|
for ticket in self:
|
|
ticket.is_sold_out = (
|
|
(ticket.seats_limited and not ticket.seats_available)
|
|
or ticket.event_id.event_registrations_sold_out
|
|
)
|
|
|
|
@api.constrains('start_sale_datetime', 'end_sale_datetime')
|
|
def _constrains_dates_coherency(self):
|
|
for ticket in self:
|
|
if ticket.start_sale_datetime and ticket.end_sale_datetime and ticket.start_sale_datetime > ticket.end_sale_datetime:
|
|
raise UserError(_('The stop date cannot be earlier than the start date. '
|
|
'Please check ticket %(ticket_name)s', ticket_name=ticket.name))
|
|
|
|
@api.constrains('limit_max_per_order', 'seats_max')
|
|
def _constrains_limit_max_per_order(self):
|
|
for ticket in self:
|
|
if ticket.seats_max and ticket.limit_max_per_order > ticket.seats_max:
|
|
raise UserError(_('The limit per order cannot be greater than the maximum seats number. '
|
|
'Please check ticket %(ticket_name)s', ticket_name=ticket.name))
|
|
if ticket.limit_max_per_order > ticket.event_id.EVENT_MAX_TICKETS:
|
|
raise UserError(_('The limit per order cannot be greater than %(limit_orderable)s. '
|
|
'Please check ticket %(ticket_name)s', limit_orderable=ticket.event_id.EVENT_MAX_TICKETS, ticket_name=ticket.name))
|
|
if ticket.limit_max_per_order < 0:
|
|
raise UserError(_('The limit per order must be positive. '
|
|
'Please check ticket %(ticket_name)s', ticket_name=ticket.name))
|
|
|
|
@api.depends('seats_max', 'seats_available')
|
|
@api.depends_context('name_with_seats_availability')
|
|
def _compute_display_name(self):
|
|
"""Adds ticket seats availability if requested by context.
|
|
Always display the name without availabilities if the event is multi slots
|
|
because the availability displayed won't be relative to the possible slot combinations
|
|
but only relative to the event and this will confuse the user.
|
|
"""
|
|
if not self.env.context.get('name_with_seats_availability'):
|
|
return super()._compute_display_name()
|
|
for ticket in self:
|
|
if not ticket.seats_max or ticket.event_id.is_multi_slots:
|
|
name = ticket.name
|
|
elif not ticket.seats_available:
|
|
name = _('%(ticket_name)s (Sold out)', ticket_name=ticket.name)
|
|
else:
|
|
name = _(
|
|
'%(ticket_name)s (%(count)s seats remaining)',
|
|
ticket_name=ticket.name,
|
|
count=formatLang(self.env, ticket.seats_available, digits=0),
|
|
)
|
|
ticket.display_name = name
|
|
|
|
def _get_current_limit_per_order(self, event_slot=False, event=False):
|
|
""" Compute the maximum possible number of tickets for an order, taking
|
|
into account the given event_slot if applicable.
|
|
If no ticket is created (alone event), event_id argument is used. Then
|
|
return the dictionary with False as key. """
|
|
event_slot.ensure_one() if event_slot else None
|
|
if self:
|
|
slots_seats_available = self.event_id._get_seats_availability([[event_slot, ticket] for ticket in self])
|
|
else:
|
|
return {False: event_slot.seats_available if event_slot else (event.seats_available if event.seats_limited else event.EVENT_MAX_TICKETS)}
|
|
availabilities = {}
|
|
for ticket, seats_available in zip(self, slots_seats_available):
|
|
if not seats_available: # "No limit"
|
|
seats_available = ticket.limit_max_per_order or ticket.event_id.EVENT_MAX_TICKETS
|
|
else:
|
|
seats_available = min(ticket.limit_max_per_order or seats_available, seats_available)
|
|
availabilities[ticket.id] = seats_available
|
|
return availabilities
|
|
|
|
def _get_ticket_multiline_description(self):
|
|
""" Compute a multiline description of this ticket. It is used when ticket
|
|
description are necessary without having to encode it manually, like sales
|
|
information. """
|
|
return '%s\n%s' % (self.display_name, self.event_id.display_name)
|
|
|
|
def _set_tz_context(self):
|
|
self.ensure_one()
|
|
return self.with_context(tz=self.event_id.date_tz or 'UTC')
|
|
|
|
@api.ondelete(at_uninstall=False)
|
|
def _unlink_except_if_registrations(self):
|
|
if self.registration_ids:
|
|
raise UserError(_(
|
|
"The following tickets cannot be deleted while they have one or more registrations linked to them:\n- %s",
|
|
'\n- '.join(self.mapped('name'))))
|