def _merge_users(target, source, **kwargs):
BlockingPrincipal.merge_users(target, source, 'blocking')
Blocking.find(created_by_id=source.id).update({Blocking.created_by_id: target.id})
Reservation.find(created_by_id=source.id).update({Reservation.created_by_id: target.id})
Reservation.find(booked_for_id=source.id).update({Reservation.booked_for_id: target.id})
Room.find(owner_id=source.id).update({Room.owner_id: target.id})
rb_settings.acls.merge_users(target, source)
def _merge_users(target, source, **kwargs):
BlockingPrincipal.merge_users(target, source, 'blocking')
Blocking.find(created_by_id=source.id).update({Blocking.created_by_id: target.id})
Reservation.find(created_by_id=source.id).update({Reservation.created_by_id: target.id})
Reservation.find(booked_for_id=source.id).update({Reservation.booked_for_id: target.id})
Room.find(owner_id=source.id).update({Room.owner_id: target.id})
rb_settings.acls.merge_users(target, source)
def rb_merge_users(new_id, old_id):
"""Updates RB data after an Avatar merge
:param new_id: Target user
:param old_id: Source user (being deleted in the merge)
"""
from indico.modules.rb import settings as rb_settings
from indico.modules.rb.models.blocking_principals import BlockingPrincipal
from indico.modules.rb.models.blockings import Blocking
from indico.modules.rb.models.reservations import Reservation
from indico.modules.rb.models.rooms import Room
old_user = User.get(int(old_id))
new_user = User.get(int(new_id))
for bp in BlockingPrincipal.find():
if bp.principal == old_user:
bp.principal = new_user
Blocking.find(created_by_id=old_id).update({'created_by_id': new_id})
Reservation.find(created_by_id=old_id).update({'created_by_id': new_id})
Reservation.find(booked_for_id=old_id).update({'booked_for_id': new_id})
Room.find(owner_id=old_id).update({'owner_id': new_id})
for key in ('authorized_principals', 'admin_principals'):
principals = rb_settings.get(key)
principals = principals_merge_users(principals, new_id, old_id)
rb_settings.set(key, principals)
def rb_merge_users(new_id, old_id):
"""Updates RB data after an Avatar merge
:param new_id: Target user
:param old_id: Source user (being deleted in the merge)
"""
from indico.modules.rb import settings as rb_settings
from indico.modules.rb.models.blocking_principals import BlockingPrincipal
from indico.modules.rb.models.blockings import Blocking
from indico.modules.rb.models.reservations import Reservation
from indico.modules.rb.models.rooms import Room
old_user = User.get(int(old_id))
new_user = User.get(int(new_id))
for bp in BlockingPrincipal.find():
if bp.principal == old_user:
bp.principal = new_user
Blocking.find(created_by_id=old_id).update({'created_by_id': new_id})
Reservation.find(created_by_id=old_id).update({'created_by_id': new_id})
Reservation.find(booked_for_id=old_id).update({'booked_for_id': new_id})
Room.find(owner_id=old_id).update({'owner_id': new_id})
for key in ('authorized_principals', 'admin_principals'):
principals = rb_settings.get(key)
principals = principals_merge_users(principals, new_id, old_id)
rb_settings.set(key, principals)
def _merge_users(target, source, **kwargs):
source_principals = set(source.in_blocking_acls.options(joinedload(BlockingPrincipal.blocking)))
target_blockings = {x.blocking for x in target.in_blocking_acls.options(joinedload(BlockingPrincipal.blocking))}
for principal in source_principals:
if principal.blocking not in target_blockings:
principal.user_id = target.id
else:
db.session.delete(principal)
Blocking.find(created_by_id=source.id).update({Blocking.created_by_id: target.id})
Reservation.find(created_by_id=source.id).update({Reservation.created_by_id: target.id})
Reservation.find(booked_for_id=source.id).update({Reservation.booked_for_id: target.id})
Room.find(owner_id=source.id).update({Room.owner_id: target.id})
settings.acls.merge_users(target, source)
def _event_deleted(event, user, **kwargs):
reservations = Reservation.find(Reservation.event_id == int(event.id),
~Reservation.is_cancelled,
~Reservation.is_rejected)
for resv in reservations:
resv.event_id = None
resv.cancel(user or session.user, 'Associated event was deleted')
def compose_rooms_stats(rooms):
reservations = Reservation.find(
Reservation.room_id.in_(r.id for r in rooms))
return {
'active': {
'valid':
reservations.filter(Reservation.is_accepted,
~Reservation.is_archived).count(),
'pending':
reservations.filter(Reservation.is_pending,
~Reservation.is_archived).count(),
'cancelled':
reservations.filter(Reservation.is_cancelled,
~Reservation.is_archived).count(),
'rejected':
reservations.filter(Reservation.is_rejected,
~Reservation.is_archived).count(),
},
'archived': {
'valid':
reservations.filter(Reservation.is_accepted,
Reservation.is_archived).count(),
'pending':
reservations.filter(Reservation.is_pending,
Reservation.is_archived).count(),
'cancelled':
reservations.filter(Reservation.is_cancelled,
Reservation.is_archived).count(),
'rejected':
reservations.filter(Reservation.is_rejected,
Reservation.is_archived).count()
}
}
def _process(self):
rooms = sorted(self._location.rooms,
key=lambda r: natural_sort_key(r.full_name))
kpi = {}
if self._with_kpi:
kpi['occupancy'] = calculate_rooms_occupancy(self._location.rooms)
kpi['total_rooms'] = len(self._location.rooms)
kpi['active_rooms'] = sum(1 for room in self._location.rooms
if room.is_active)
kpi['reservable_rooms'] = sum(1 for room in self._location.rooms
if room.is_reservable)
kpi['reservable_capacity'] = sum(room.capacity or 0
for room in self._location.rooms
if room.is_reservable)
kpi['reservable_surface'] = sum(room.surface_area or 0
for room in self._location.rooms
if room.is_reservable)
kpi['booking_stats'] = compose_rooms_stats(self._location.rooms)
kpi['booking_count'] = Reservation.find(
Reservation.room.has(Room.location == self._location)).count()
return WPRoomBookingAdminLocation(
self,
'rb-rooms',
location=self._location,
rooms=rooms,
action_succeeded=self._actionSucceeded,
equipment_types=self._location.equipment_types.all(),
attributes=self._location.attributes.all(),
kpi=kpi).display()
def calculate_rooms_booked_time(rooms, start_date=None, end_date=None):
if end_date is None:
end_date = date.today() - relativedelta(days=1)
if start_date is None:
start_date = end_date - relativedelta(days=29)
# Reservations on working days
reservations = Reservation.find(
Reservation.room_id.in_(r.id for r in rooms),
db.extract('dow', ReservationOccurrence.start_dt).between(1, 5),
db.cast(ReservationOccurrence.start_dt, db.Date) >= start_date,
db.cast(ReservationOccurrence.end_dt, db.Date) <= end_date,
ReservationOccurrence.is_valid,
_join=ReservationOccurrence)
rsv_start = db.cast(ReservationOccurrence.start_dt, db.TIME)
rsv_end = db.cast(ReservationOccurrence.end_dt, db.TIME)
slots = ((db.cast(start, db.TIME), db.cast(end, db.TIME))
for start, end in Location.working_time_periods)
# this basically handles all possible ways an occurrence overlaps with each one of the working time slots
overlaps = sum(
db.case([((rsv_start < start) & (rsv_end > end),
db.extract('epoch', end - start)),
((rsv_start < start) & (rsv_end > start) & (rsv_end <= end),
db.extract('epoch', rsv_end - start)),
((rsv_start >= start) & (rsv_start < end) & (rsv_end > end),
db.extract('epoch', end - rsv_start)),
((rsv_start >= start) & (rsv_end <= end),
db.extract('epoch', rsv_end - rsv_start))],
else_=0) for start, end in slots)
return reservations.with_entities(db.func.sum(overlaps)).scalar() or 0
def _process(self):
rooms = sorted(self._location.rooms,
key=lambda r: natural_sort_key(r.full_name))
kpi = {}
if self._with_kpi:
kpi['occupancy'] = calculate_rooms_occupancy(
self._location.rooms.all())
kpi['total_rooms'] = self._location.rooms.count()
kpi['active_rooms'] = self._location.rooms.filter_by(
is_active=True).count()
kpi['reservable_rooms'] = self._location.rooms.filter_by(
is_reservable=True).count()
kpi['reservable_capacity'] = (self._location.rooms.with_entities(
func.sum(
Room.capacity)).filter_by(is_reservable=True).scalar())
kpi['reservable_surface'] = (self._location.rooms.with_entities(
func.sum(
Room.surface_area)).filter_by(is_reservable=True).scalar())
kpi['booking_stats'] = compose_rooms_stats(
self._location.rooms.all())
kpi['booking_count'] = Reservation.find(
Reservation.room_id.in_(
r.id for r in self._location.rooms)).count()
return WPRoomBookingAdminLocation(
self,
location=self._location,
rooms=rooms,
action_succeeded=self._actionSucceeded,
equipment_types=self._location.equipment_types.all(),
attributes=self._location.attributes.all(),
kpi=kpi).display()
def calculate_rooms_booked_time(rooms, start_date=None, end_date=None):
if end_date is None:
end_date = date.today() - relativedelta(days=1)
if start_date is None:
start_date = end_date - relativedelta(days=29)
# Reservations on working days
reservations = Reservation.find(Reservation.room_id.in_(r.id for r in rooms),
db.extract('dow', ReservationOccurrence.start_dt).between(1, 5),
db.cast(ReservationOccurrence.start_dt, db.Date) >= start_date,
db.cast(ReservationOccurrence.end_dt, db.Date) <= end_date,
ReservationOccurrence.is_valid,
_join=ReservationOccurrence)
rsv_start = db.cast(ReservationOccurrence.start_dt, db.TIME)
rsv_end = db.cast(ReservationOccurrence.end_dt, db.TIME)
slots = ((db.cast(start, db.TIME), db.cast(end, db.TIME)) for start, end in WORKING_TIME_PERIODS)
# this basically handles all possible ways an occurrence overlaps with each one of the working time slots
overlaps = sum(db.case([
((rsv_start < start) & (rsv_end > end), db.extract('epoch', end - start)),
((rsv_start < start) & (rsv_end > start) & (rsv_end <= end), db.extract('epoch', rsv_end - start)),
((rsv_start >= start) & (rsv_start < end) & (rsv_end > end), db.extract('epoch', end - rsv_start)),
((rsv_start >= start) & (rsv_end <= end), db.extract('epoch', rsv_end - rsv_start))
], else_=0) for start, end in slots)
return reservations.with_entities(db.func.sum(overlaps)).scalar() or 0
def _createTabCtrl(self):
self._tabCtrl = TabControl()
self._tabExistBookings = self._tabCtrl.newTab('existing', 'Existing Bookings',
url_for('event_mgmt.rooms_booking_list', self._conf))
self._tabNewBooking = self._tabCtrl.newTab('new', 'New Booking',
url_for('event_mgmt.rooms_choose_event', self._conf))
if not Reservation.find(event_id=self._conf.getId()).count():
self._tabExistBookings.setEnabled(False)
self._setActiveTab()
def _createTabCtrl(self):
self._tabCtrl = TabControl()
self._tabExistBookings = self._tabCtrl.newTab('existing', 'Existing Bookings',
url_for('event_mgmt.rooms_booking_list', self._conf))
self._tabNewBooking = self._tabCtrl.newTab('new', 'New Booking',
url_for('event_mgmt.rooms_choose_event', self._conf))
if not Reservation.find(event_id=self._conf.getId()).count():
self._tabExistBookings.setEnabled(False)
self._setActiveTab()
def rb_merge_users(new_id, old_id):
"""Updates RB data after an Avatar merge
:param new_id: Target user
:param old_id: Source user (being deleted in the merge)
"""
from indico.modules.rb import settings
from indico.modules.rb.models.blocking_principals import BlockingPrincipal
from indico.modules.rb.models.blockings import Blocking
from indico.modules.rb.models.reservations import Reservation
from indico.modules.rb.models.rooms import Room
BlockingPrincipal.find(entity_type='Avatar', entity_id=old_id).update({'entity_id': new_id})
Blocking.find(created_by_id=old_id).update({'created_by_id': new_id})
Reservation.find(created_by_id=old_id).update({'created_by_id': new_id})
Reservation.find(booked_for_id=old_id).update({'booked_for_id': new_id})
Room.find(owner_id=old_id).update({'owner_id': new_id})
for key in ('authorized_principals', 'admin_principals'):
principals = settings.get(key, [])
principals = principals_merge_users(principals, new_id, old_id)
settings.set(key, principals)
def rb_merge_users(new_id, old_id):
"""Updates RB data after an Avatar merge
:param new_id: Target user
:param old_id: Source user (being deleted in the merge)
"""
from indico.modules.rb import settings
from indico.modules.rb.models.blocking_principals import BlockingPrincipal
from indico.modules.rb.models.blockings import Blocking
from indico.modules.rb.models.reservations import Reservation
from indico.modules.rb.models.rooms import Room
BlockingPrincipal.find(entity_type='Avatar',
entity_id=old_id).update({'entity_id': new_id})
Blocking.find(created_by_id=old_id).update({'created_by_id': new_id})
Reservation.find(created_by_id=old_id).update({'created_by_id': new_id})
Reservation.find(booked_for_id=old_id).update({'booked_for_id': new_id})
Room.find(owner_id=old_id).update({'owner_id': new_id})
for key in ('authorized_principals', 'admin_principals'):
principals = settings.get(key, [])
principals = principals_merge_users(principals, new_id, old_id)
settings.set(key, principals)
def compose_rooms_stats(rooms):
reservations = Reservation.find(Reservation.room_id.in_(r.id for r in rooms))
return {
'active': {
'valid': reservations.filter(Reservation.is_valid, ~Reservation.is_archived).count(),
'pending': reservations.filter(Reservation.is_pending, ~Reservation.is_archived).count(),
'cancelled': reservations.filter(Reservation.is_cancelled, ~Reservation.is_archived).count(),
'rejected': reservations.filter(Reservation.is_rejected, ~Reservation.is_archived).count(),
},
'archived': {
'valid': reservations.filter(Reservation.is_valid, Reservation.is_archived).count(),
'pending': reservations.filter(Reservation.is_pending, Reservation.is_archived).count(),
'cancelled': reservations.filter(Reservation.is_cancelled, Reservation.is_archived).count(),
'rejected': reservations.filter(Reservation.is_rejected, Reservation.is_archived).count()
}
}
def calculate_rooms_booked_time(rooms, start_date=None, end_date=None):
if end_date is None:
end_date = date.today() - relativedelta(days=1)
if start_date is None:
start_date = end_date - relativedelta(days=29)
# Reservations on working days
reservations = Reservation.find(Reservation.room_id.in_(r.id for r in rooms),
extract('dow', ReservationOccurrence.start_dt).between(1, 5),
ReservationOccurrence.start_dt >= start_date,
ReservationOccurrence.end_dt <= end_date,
ReservationOccurrence.is_valid,
_join=ReservationOccurrence)
# Take into account only working hours
earliest_time = greatest(cast(ReservationOccurrence.start_dt, TIME), Location.working_time_start)
latest_time = least(cast(ReservationOccurrence.end_dt, TIME), Location.working_time_end)
booked_time = reservations.with_entities(func.sum(latest_time - earliest_time)).scalar()
return (booked_time or timedelta()).total_seconds()
def calculate_rooms_booked_time(rooms, start_date=None, end_date=None):
if end_date is None:
end_date = date.today() - relativedelta(days=1)
if start_date is None:
start_date = end_date - relativedelta(days=29)
# Reservations on working days
reservations = Reservation.find(Reservation.room_id.in_(r.id for r in rooms),
extract('dow', ReservationOccurrence.start_dt).between(1, 5),
ReservationOccurrence.start_dt >= start_date,
ReservationOccurrence.end_dt <= end_date,
ReservationOccurrence.is_valid,
_join=ReservationOccurrence)
# Take into account only working hours
earliest_time = least(greatest(cast(ReservationOccurrence.start_dt, TIME), Location.working_time_start),
Location.working_time_end)
latest_time = greatest(least(cast(ReservationOccurrence.end_dt, TIME), Location.working_time_end),
Location.working_time_start)
booked_time = reservations.with_entities(func.sum(latest_time - earliest_time)).scalar()
return (booked_time or timedelta()).total_seconds()
def _process(self):
rooms = sorted(self._location.rooms, key=lambda r: natural_sort_key(r.full_name))
kpi = {}
if self._with_kpi:
kpi['occupancy'] = calculate_rooms_occupancy(self._location.rooms)
kpi['total_rooms'] = len(self._location.rooms)
kpi['active_rooms'] = sum(1 for room in self._location.rooms if room.is_active)
kpi['reservable_rooms'] = sum(1 for room in self._location.rooms if room.is_reservable)
kpi['reservable_capacity'] = sum(room.capacity or 0 for room in self._location.rooms if room.is_reservable)
kpi['reservable_surface'] = sum(room.surface_area or 0 for room in self._location.rooms
if room.is_reservable)
kpi['booking_stats'] = compose_rooms_stats(self._location.rooms)
kpi['booking_count'] = Reservation.find(Reservation.room.has(Room.location == self._location)).count()
return WPRoomBookingAdminLocation(self, 'rb-rooms',
location=self._location,
rooms=rooms,
action_succeeded=self._actionSucceeded,
equipment_types=self._location.equipment_types.all(),
attributes=self._location.attributes.all(),
kpi=kpi).display()
def _process(self):
rooms = sorted(self._location.rooms, key=lambda r: natural_sort_key(r.full_name))
kpi = {}
if self._with_kpi:
kpi['occupancy'] = calculate_rooms_occupancy(self._location.rooms.all())
kpi['total_rooms'] = self._location.rooms.count()
kpi['active_rooms'] = self._location.rooms.filter_by(is_active=True).count()
kpi['reservable_rooms'] = self._location.rooms.filter_by(is_reservable=True).count()
kpi['reservable_capacity'] = (self._location.rooms.with_entities(func.sum(Room.capacity))
.filter_by(is_reservable=True).scalar())
kpi['reservable_surface'] = (self._location.rooms.with_entities(func.sum(Room.surface_area))
.filter_by(is_reservable=True).scalar())
kpi['booking_stats'] = compose_rooms_stats(self._location.rooms.all())
kpi['booking_count'] = Reservation.find(Reservation.room_id.in_(r.id for r in self._location.rooms)).count()
return WPRoomBookingAdminLocation(self,
location=self._location,
rooms=rooms,
action_succeeded=self._actionSucceeded,
equipment_types=self._location.equipment_types.all(),
attributes=self._location.attributes.all(),
kpi=kpi).display()
def _event_deleted(event, user, **kwargs):
reservations = Reservation.find(Reservation.event_id == int(event.id),
~Reservation.is_cancelled,
~Reservation.is_rejected)
for resv in reservations:
resv.cancel(user or session.user, 'Associated event was deleted')
