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 test_is_active_at(create_blocking, check_date, expected):
start_date = date(2014, 12, 5)
end_date = date(2014, 12, 7)
check_date = datetime.strptime(check_date, '%Y-%m-%d').date()
blocking = create_blocking(start_date=start_date, end_date=end_date)
assert blocking.is_active_at(check_date) == expected
assert Blocking.find_first(Blocking.is_active_at(check_date)) == (blocking if expected else None)
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):
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 create_blocking(room_ids, allowed, start_date, end_date, reason, created_by):
blocking = Blocking()
blocking.start_date = start_date
blocking.end_date = end_date
blocking.created_by_user = created_by
_populate_blocking(blocking, room_ids, allowed, reason)
db.session.add(blocking)
db.session.flush()
return blocking
def create_blocking(room_ids, allowed, start_date, end_date, reason, created_by):
blocking = Blocking()
blocking.start_date = start_date
blocking.end_date = end_date
blocking.created_by_user = created_by
_populate_blocking(blocking, room_ids, allowed, reason)
db.session.add(blocking)
db.session.flush()
return blocking
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 get_blocked_rooms(self, *dates, **kwargs):
states = kwargs.get('states', (BlockedRoom.State.accepted,))
return (self.blocked_rooms
.join(BlockedRoom.blocking)
.options(contains_eager(BlockedRoom.blocking))
.filter(or_(Blocking.is_active_at(d) for d in dates),
BlockedRoom.state.in_(states))
.all())
def _checkParams(self):
self._blocking = Blocking.get(request.view_args['blocking_id'])
if self._blocking is None:
raise IndicoError('A blocking with this ID does not exist.')
defaults = FormDefaults(self._blocking, attrs={'reason'},
principals=self._blocking.allowed,
blocked_rooms=[br.room_id for br in self._blocking.blocked_rooms])
self._form = BlockingForm(obj=defaults)
self._form._blocking = self._blocking
def _process_args(self):
self._blocking = Blocking.get(request.view_args['blocking_id'])
if self._blocking is None:
raise IndicoError('A blocking with this ID does not exist.')
defaults = FormDefaults(self._blocking, attrs={'reason'},
principals=self._blocking.allowed,
blocked_rooms=[br.room_id for br in self._blocking.blocked_rooms])
self._form = BlockingForm(obj=defaults)
self._form._blocking = self._blocking
def create_blocking(rooms, start_date, end_date, reason, allowed_principals):
blocking = Blocking()
blocking.start_date = start_date
blocking.end_date = end_date
blocking.reason = reason
blocking.created_by_user = session.user
blocking.allowed = allowed_principals
blocking.blocked_rooms = [BlockedRoom(room_id=room.id) for room in rooms]
db.session.add(blocking)
db.session.flush()
return blocking
def _process_args(self):
blocking_id = self._params.get('blocking_id')
self._room = Room.get(self._params['room_id'])
self._blocking = Blocking.get(blocking_id) if blocking_id else None
if 'start_dt' in self._params and 'end_dt' in self._params:
start_dt = datetime.strptime(self._params['start_dt'], '%H:%M %Y-%m-%d')
end_dt = datetime.strptime(self._params['end_dt'], '%H:%M %Y-%m-%d')
self._nonbookable = bool(NonBookablePeriod.find_first(NonBookablePeriod.room_id == self._room.id,
NonBookablePeriod.overlaps(start_dt, end_dt)))
else:
self._nonbookable = False
def _save(self):
self._blocking = blocking = Blocking()
blocking.start_date = self._form.start_date.data
blocking.end_date = self._form.end_date.data
blocking.created_by_user = session.user
blocking.reason = self._form.reason.data
blocking.allowed = self._form.principals.data
blocking.blocked_rooms = [BlockedRoom(room_id=room_id) for room_id in self._form.blocked_rooms.data]
db.session.add(blocking)
db.session.flush() # synchronizes relationships (e.g. BlockedRoom.room)
flash(_(u'Blocking created'), 'success')
self._process_blocked_rooms(blocking.blocked_rooms)
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 _process(self):
criteria = []
if self.only_mine:
criteria += [Blocking.created_by_id == self._getUser().getId()]
if self.timeframe == 'year':
criteria += [Blocking.start_date <= date(date.today().year, 12, 31),
Blocking.end_date >= date(date.today().year, 1, 1)]
elif self.timeframe == 'recent':
criteria += [Blocking.end_date >= date.today()]
blockings = Blocking.find(*criteria, _eager_all='blocked_rooms.room').order_by(Blocking.start_date.desc()).all()
return WPRoomBookingBlockingList(self, blockings=blockings).display()
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 migrate_blockings(self):
state_map = {
None: BlockedRoom.State.pending,
False: BlockedRoom.State.rejected,
True: BlockedRoom.State.accepted
}
print cformat('%{white!}migrating blockings')
for old_blocking_id, old_blocking in self.rb_root['RoomBlocking'][
'Blockings'].iteritems():
b = Blocking(id=old_blocking.id,
created_by_id=self.merged_avatars.get(
old_blocking._createdBy, old_blocking._createdBy),
created_dt=as_utc(old_blocking._utcCreatedDT),
start_date=old_blocking.startDate,
end_date=old_blocking.endDate,
reason=convert_to_unicode(old_blocking.message))
print cformat(u'- %{cyan}{}').format(b.reason)
for old_blocked_room in old_blocking.blockedRooms:
br = BlockedRoom(
state=state_map[old_blocked_room.active],
rejected_by=old_blocked_room.rejectedBy,
rejection_reason=convert_to_unicode(
old_blocked_room.rejectionReason),
)
room = Room.get(get_room_id(old_blocked_room.roomGUID))
room.blocked_rooms.append(br)
b.blocked_rooms.append(br)
print cformat(u' %{blue!}Room:%{reset} {} ({})').format(
room.full_name,
BlockedRoom.State(br.state).title)
for old_principal in old_blocking.allowed:
principal_id = old_principal._id
if old_principal._type == 'Avatar':
principal_id = int(
self.merged_avatars.get(old_principal._id,
old_principal._id))
principal_type = 'User'
else:
principal_type = 'Group'
bp = BlockingPrincipal(
_principal=[principal_type, principal_id])
b._allowed.add(bp)
print cformat(u' %{blue!}Allowed:%{reset} {}({})').format(
bp.entity_type, bp.entity_id)
db.session.add(b)
db.session.commit()
def _create_blocking(**params):
room = params.pop('room', dummy_room)
state = params.pop('state', BlockedRoom.State.pending)
params.setdefault('start_date', date.today())
params.setdefault('end_date', date.today())
params.setdefault('reason', u'Blocked')
params.setdefault('created_by_user', dummy_user)
blocking = Blocking(**params)
if room is not None:
br = BlockedRoom(room=room, state=state, blocking=blocking)
if state == BlockedRoom.State.accepted:
br.approve(notify_blocker=False)
db.session.add(blocking)
db.session.flush()
return blocking
def _process_args(self):
blocking_id = self._params.get('blocking_id')
self._room = Room.get(self._params['room_id'])
self._blocking = Blocking.get(blocking_id) if blocking_id else None
if 'start_dt' in self._params and 'end_dt' in self._params:
start_dt = datetime.strptime(self._params['start_dt'],
'%H:%M %Y-%m-%d')
end_dt = datetime.strptime(self._params['end_dt'],
'%H:%M %Y-%m-%d')
self._nonbookable = bool(
NonBookablePeriod.find_first(
NonBookablePeriod.room_id == self._room.id,
NonBookablePeriod.overlaps(start_dt, end_dt)))
else:
self._nonbookable = False
def _process(self):
criteria = []
if self.only_mine:
criteria += [Blocking.created_by_user == session.user]
if self.timeframe == 'year':
criteria += [
Blocking.start_date <= date(date.today().year, 12, 31),
Blocking.end_date >= date(date.today().year, 1, 1)
]
elif self.timeframe == 'recent':
criteria += [Blocking.end_date >= date.today()]
blockings = (Blocking.find(*criteria).options(
joinedload('blocked_rooms').joinedload('room')).order_by(
Blocking.start_date.desc()).all())
return WPRoomBookingBlockingList(self, blockings=blockings).display()
def _process(self):
criteria = []
if self.only_mine:
criteria += [Blocking.created_by_user == session.user]
if self.timeframe == "year":
criteria += [
Blocking.start_date <= date(date.today().year, 12, 31),
Blocking.end_date >= date(date.today().year, 1, 1),
]
elif self.timeframe == "recent":
criteria += [Blocking.end_date >= date.today()]
blockings = (
Blocking.find(*criteria)
.options(joinedload("blocked_rooms").joinedload("room"))
.order_by(Blocking.start_date.desc())
.all()
)
return WPRoomBookingBlockingList(self, blockings=blockings).display()
def get_room_blockings(start_dt=None,
end_dt=None,
created_by=None,
in_rooms_owned_by=None):
query = Blocking.query
if start_dt and not end_dt:
query = query.filter(Blocking.is_active_at(start_dt))
elif start_dt and end_dt:
query = query.filter(
db_dates_overlap(Blocking, 'start_date', start_dt, 'end_date',
end_dt))
criteria = []
if created_by:
criteria.append(Blocking.created_by_user == created_by)
if in_rooms_owned_by:
criteria.append(Room.owner == in_rooms_owned_by)
query = (query.join(Blocking.blocked_rooms).join(BlockedRoom.room))
query = query.filter(db.or_(*criteria))
return query.all()
def _process_args(self):
self._blocking = Blocking.get(request.view_args['blocking_id'])
if not self._blocking:
raise NotFound('A blocking with this ID does not exist.')
def _checkParams(self):
self._blocking = Blocking.get(request.view_args["blocking_id"])
if not self._blocking:
raise IndicoError("A blocking with this ID does not exist.")
def _checkParams(self):
self._block = Blocking.get(request.view_args['blocking_id'])
if not self._block:
raise IndicoError('A blocking with this ID does not exist.')
def _process_args(self):
self._block = Blocking.get(request.view_args['blocking_id'])
if not self._block:
raise NotFound('A blocking with this ID does not exist.')
def _process_args(self):
self.blocking = Blocking.get_one(request.view_args['blocking_id'])
def _checkParams(self):
blocking_id = self._params.get('blocking_id')
self._room = Room.get(self._params['room_id'])
self._blocking = Blocking.get(blocking_id) if blocking_id else None
def _process_args(self):
self._blocking = Blocking.get(request.view_args['blocking_id'])
if not self._blocking:
raise IndicoError('A blocking with this ID does not exist.')
def _process_args(self):
self.blocking = Blocking.get_or_404(request.view_args['blocking_id'])
def _checkParams(self):
blocking_id = self._params.get('blocking_id')
self._room = Room.get(self._params['room_id'])
self._blocking = Blocking.get(blocking_id) if blocking_id else None
