def find_requests(from_dt=None, to_dt=None, contribs_and_sessions=True):
"""Finds requests matching certain criteria.
:param from_dt: earliest event/contribution to include
:param to_dt: latest event/contribution to include
:param contribs_and_sessions: whether it should return contributions and sessions or only request
"""
from definition import VCAssistanceRequest
query = Request.query.join(Event).filter(
~Event.is_deleted, Request.type == VCAssistanceRequest.name,
Request.state == RequestState.accepted)
if from_dt is not None or to_dt is not None:
query = query.filter(Event.happens_between(from_dt, to_dt))
# We only want the latest one for each event
query = limit_groups(query, Request, Request.event_id,
Request.created_dt.desc(), 1)
query = query.options(joinedload('event'))
for req in query:
event = req.event
if to_dt is not None and event.start_dt > to_dt:
continue
if not contribs_and_sessions:
yield req
else:
contribs = [x[0] for x in get_capable(req, get_contributions)]
session_blocks = [
x[0] for x in get_capable(req, get_session_blocks)
]
yield req, contribs, session_blocks
def get_with_data(*args, **kwargs):
filters = kwargs.pop('filters', None)
limit = kwargs.pop('limit', None)
offset = kwargs.pop('offset', 0)
order = kwargs.pop('order', Reservation.start_dt)
limit_per_room = kwargs.pop('limit_per_room', False)
occurs_on = kwargs.pop('occurs_on')
if kwargs:
raise ValueError('Unexpected kwargs: {}'.format(kwargs))
query = Reservation.query.options(joinedload(Reservation.room))
if filters:
query = query.filter(*filters)
if occurs_on:
query = query.filter(
Reservation.id.in_(db.session.query(ReservationOccurrence.reservation_id)
.filter(ReservationOccurrence.date.in_(occurs_on),
ReservationOccurrence.is_valid))
)
if limit_per_room and (limit or offset):
query = limit_groups(query, Reservation, Reservation.room_id, order, limit, offset)
query = query.order_by(order, Reservation.created_dt)
if not limit_per_room:
if limit:
query = query.limit(limit)
if offset:
query = query.offset(offset)
result = OrderedDict((r.id, {'reservation': r}) for r in query)
if 'vc_equipment' in args:
vc_id_subquery = db.session.query(EquipmentType.id) \
.correlate(Reservation) \
.filter_by(name='Video conference') \
.join(RoomEquipmentAssociation) \
.filter(RoomEquipmentAssociation.c.room_id == Reservation.room_id) \
.as_scalar()
# noinspection PyTypeChecker
vc_equipment_data = dict(db.session.query(Reservation.id, static_array.array_agg(EquipmentType.name))
.join(ReservationEquipmentAssociation, EquipmentType)
.filter(Reservation.id.in_(result.iterkeys()))
.filter(EquipmentType.parent_id == vc_id_subquery)
.group_by(Reservation.id))
for id_, data in result.iteritems():
data['vc_equipment'] = vc_equipment_data.get(id_, ())
if 'occurrences' in args:
occurrence_data = OrderedMultiDict(db.session.query(ReservationOccurrence.reservation_id,
ReservationOccurrence)
.filter(ReservationOccurrence.reservation_id.in_(result.iterkeys()))
.order_by(ReservationOccurrence.start_dt))
for id_, data in result.iteritems():
data['occurrences'] = occurrence_data.getlist(id_)
return result.values()
def find_requests(talks=False,
from_dt=None,
to_dt=None,
services=None,
states=None):
"""Finds requests matching certain criteria.
:param talks: if True, yield ``(request, contrib, start_dt)`` tuples
instead of just requests, i.e. the same request may be
yielded multiple times
:param from_dt: earliest event/contribution to include
:param to_dt: latest event/contribution to include
:param states: acceptable request states (by default anything but withdrawn)
:param services: set of services that must have been requested
"""
from indico_audiovisual.definition import AVRequest
query = Request.query.filter_by(type=AVRequest.name)
if states is not None:
query = query.filter(Request.state.in_(states))
else:
query = query.filter(Request.state != RequestState.withdrawn)
if from_dt is not None or to_dt is not None:
query = query.join(Event).filter(Event.happens_between(from_dt, to_dt))
# We only want the latest one for each event
query = limit_groups(query, Request, Request.event_id,
Request.created_dt.desc(), 1)
query = query.options(joinedload('event'))
for req in query:
event = req.event
# Skip requests which do not have the requested services or are outside the date range
if services and not (set(req.data['services']) & services):
continue
elif to_dt is not None and event.start_dt > to_dt:
continue
if not talks:
yield req
continue
# Lectures don't have contributions so we use the event info directly
if event.type == 'lecture':
yield req, event, event.start_dt
continue
contribs = [x[0] for x in get_selected_contributions(req)]
for contrib in contribs:
contrib_start = _get_start_date(contrib)
contrib_end = _get_end_date(contrib)
if from_dt is not None and to_dt is not None and not overlaps(
(contrib_start, contrib_end), (from_dt, to_dt)):
continue
elif from_dt and _get_start_date(contrib) < from_dt:
continue
elif to_dt and _get_end_date(contrib) > to_dt:
continue
yield req, contrib, _get_start_date(contrib)
def find_latest_for_event(cls, event, type_=None):
"""Returns the latest requests for a given event.
:param event: the event to find the requests for
:param type_: the request type to retrieve, or `None` to get all
:return: a dict mapping request types to a :class:`Request`
or if `type_` was specified, a single :class:`Request` or `None`
"""
query = event.requests
if type_ is not None:
return (query.filter_by(type=type_)
.order_by(cls.created_dt.desc())
.first())
else:
query = limit_groups(query, cls, cls.type, cls.created_dt.desc(), 1)
return {req.type: req for req in query}
def find_latest_for_event(cls, event, type_=None):
"""Returns the latest requests for a given event.
:param event: the event to find the requests for
:param type_: the request type to retrieve, or `None` to get all
:return: a dict mapping request types to a :class:`Request`
or if `type_` was specified, a single :class:`Request` or `None`
"""
query = Request.query.with_parent(event)
if type_ is not None:
return (query.filter_by(type=type_).order_by(
cls.created_dt.desc()).first())
else:
query = limit_groups(query, cls, cls.type, cls.created_dt.desc(),
1)
return {req.type: req for req in query}
def get_with_data(*args, **kwargs):
filters = kwargs.pop('filters', None)
limit = kwargs.pop('limit', None)
offset = kwargs.pop('offset', 0)
order = kwargs.pop('order', Reservation.start_dt)
limit_per_room = kwargs.pop('limit_per_room', False)
occurs_on = kwargs.pop('occurs_on')
if kwargs:
raise ValueError(f'Unexpected kwargs: {kwargs}')
query = Reservation.query.options(joinedload(Reservation.room))
if filters:
query = query.filter(*filters)
if occurs_on:
query = query.filter(
Reservation.id.in_(
db.session.query(
ReservationOccurrence.reservation_id).filter(
ReservationOccurrence.date.in_(occurs_on),
ReservationOccurrence.is_valid)))
if limit_per_room and (limit or offset):
query = limit_groups(query, Reservation, Reservation.room_id,
order, limit, offset)
query = query.order_by(order, Reservation.created_dt)
if not limit_per_room:
if limit:
query = query.limit(limit)
if offset:
query = query.offset(offset)
result = {r.id: {'reservation': r} for r in query}
if 'occurrences' in args:
occurrence_data = OrderedMultiDict(
db.session.query(ReservationOccurrence.reservation_id,
ReservationOccurrence).filter(
ReservationOccurrence.reservation_id.in_(
result.keys())).order_by(
ReservationOccurrence.start_dt))
for id_, data in result.items():
data['occurrences'] = occurrence_data.getlist(id_)
return list(result.values())
def get_with_data(*args, **kwargs):
filters = kwargs.pop('filters', None)
limit = kwargs.pop('limit', None)
offset = kwargs.pop('offset', 0)
order = kwargs.pop('order', Reservation.start_dt)
limit_per_room = kwargs.pop('limit_per_room', False)
occurs_on = kwargs.pop('occurs_on')
if kwargs:
raise ValueError('Unexpected kwargs: {}'.format(kwargs))
query = Reservation.query.options(joinedload(Reservation.room))
if filters:
query = query.filter(*filters)
if occurs_on:
query = query.filter(
Reservation.id.in_(db.session.query(ReservationOccurrence.reservation_id)
.filter(ReservationOccurrence.date.in_(occurs_on),
ReservationOccurrence.is_valid))
)
if limit_per_room and (limit or offset):
query = limit_groups(query, Reservation, Reservation.room_id, order, limit, offset)
query = query.order_by(order, Reservation.created_dt)
if not limit_per_room:
if limit:
query = query.limit(limit)
if offset:
query = query.offset(offset)
result = OrderedDict((r.id, {'reservation': r}) for r in query)
if 'occurrences' in args:
occurrence_data = OrderedMultiDict(db.session.query(ReservationOccurrence.reservation_id,
ReservationOccurrence)
.filter(ReservationOccurrence.reservation_id.in_(result.iterkeys()))
.order_by(ReservationOccurrence.start_dt))
for id_, data in result.iteritems():
data['occurrences'] = occurrence_data.getlist(id_)
return result.values()
def get_with_data(*args, **kwargs):
filters = kwargs.pop('filters', None)
limit = kwargs.pop('limit', None)
offset = kwargs.pop('offset', 0)
order = kwargs.pop('order', Reservation.start_dt)
limit_per_room = kwargs.pop('limit_per_room', False)
occurs_on = kwargs.pop('occurs_on')
if kwargs:
raise ValueError('Unexpected kwargs: {}'.format(kwargs))
query = Reservation.query.options(joinedload(Reservation.room))
if filters:
query = query.filter(*filters)
if occurs_on:
query = query.filter(
Reservation.id.in_(
db.session.query(
ReservationOccurrence.reservation_id).filter(
ReservationOccurrence.date.in_(occurs_on),
ReservationOccurrence.is_valid)))
if limit_per_room and (limit or offset):
query = limit_groups(query, Reservation, Reservation.room_id,
order, limit, offset)
query = query.order_by(order, Reservation.created_dt)
if not limit_per_room:
if limit:
query = query.limit(limit)
if offset:
query = query.offset(offset)
result = OrderedDict((r.id, {'reservation': r}) for r in query)
if 'vc_equipment' in args:
vc_id_subquery = db.session.query(EquipmentType.id) \
.correlate(Reservation) \
.filter_by(name='Video conference') \
.join(RoomEquipmentAssociation) \
.filter(RoomEquipmentAssociation.c.room_id == Reservation.room_id) \
.as_scalar()
# noinspection PyTypeChecker
vc_equipment_data = dict(
db.session.query(
Reservation.id,
static_array.array_agg(EquipmentType.name)).join(
ReservationEquipmentAssociation, EquipmentType).filter(
Reservation.id.in_(result.iterkeys())).filter(
EquipmentType.parent_id ==
vc_id_subquery).group_by(Reservation.id))
for id_, data in result.iteritems():
data['vc_equipment'] = vc_equipment_data.get(id_, ())
if 'occurrences' in args:
occurrence_data = OrderedMultiDict(
db.session.query(ReservationOccurrence.reservation_id,
ReservationOccurrence).filter(
ReservationOccurrence.reservation_id.in_(
result.iterkeys())).order_by(
ReservationOccurrence.start_dt))
for id_, data in result.iteritems():
data['occurrences'] = occurrence_data.getlist(id_)
return result.values()
