def daterange(self):
now = utils.utcnow()
since = now - timedelta(days=self.end)
until = now - timedelta(days=self.start)
return since, until
def remove_reservation_from_session(session_id, token):
""" Removes the reservation with the given session_id and token. """
assert token and session_id
query = reservations_by_session(session_id)
query = query.filter(Reservation.token == token)
reservation = query.one()
Session.delete(reservation)
# if we get here the token must be valid, we should then check if the
# token is used in the reserved slots, because with autoapproval these
# slots may be created straight away.
slots = Session.query(ReservedSlot).filter(
ReservedSlot.reservation_token == token
)
slots.delete('fetch')
# we also update the timestamp of existing reservations within
# the same session to ensure that we account for the user's activity
# properly during the session expiration cronjob. Otherwise it is
# possible that a user removes the latest reservations only to see
# the rest of them vanish because his older reservations were
# already old enough to be counted as expired.
query = Session.query(Reservation)
query = query.filter(Reservation.session_id == session_id)
query.update({"modified": utils.utcnow()})
def daterange(self):
now = utils.utcnow()
since = now - timedelta(days=self.end)
until = now - timedelta(days=self.start)
return since, until
def human_date(date):
# timezones are currently naive and implicity the one used by
# the users - we don't have international reservations yet
now = utils.utcnow()
this_morning = datetime(
now.year, now.month, now.day
).replace(tzinfo=now.tzinfo)
time = utils.localize_date(date, time_only=True)
if date >= this_morning:
return _(u'Today, at ${time}', mapping={'time': time})
days = (now.date() - date.date()).days
if days <= 1:
return _(u'Yesterday, at ${time}', mapping={
'time': time
})
else:
return _(u'${days} days ago, at ${time}', mapping={
'days': days,
'time': time
})
def test_session_removal_is_complete(self):
sc = Scheduler(new_uuid())
start, end = datetime(2013, 9, 27, 9, 0), datetime(2013, 9, 27, 10)
sc.allocate(dates=(start, end))
session_id = new_uuid()
token = sc.reserve(
reservation_email, (start, end), session_id=session_id
)
self.assertEqual(db.Session.query(db.Reservation).count(), 1)
self.assertEqual(db.Session.query(db.Allocation).count(), 1)
self.assertEqual(db.Session.query(db.ReservedSlot).count(), 0)
sc.approve_reservation(token)
self.assertEqual(db.Session.query(db.Reservation).count(), 1)
self.assertEqual(db.Session.query(db.Allocation).count(), 1)
self.assertEqual(db.Session.query(db.ReservedSlot).count(), 1)
db.remove_expired_reservation_sessions(
utils.utcnow() + timedelta(seconds=15*60)
)
self.assertEqual(db.Session.query(db.Reservation).count(), 0)
self.assertEqual(db.Session.query(db.Allocation).count(), 1)
self.assertEqual(db.Session.query(db.ReservedSlot).count(), 0)
def daterange_label(self):
since, until = self.daterange
if until.date() == utils.utcnow().date():
return ' - '.join((utils.localize_date(since, long_format=False),
self.translate(_(u'Today'))))
return ' - '.join((utils.localize_date(since, long_format=False),
utils.localize_date(until, long_format=False)))
def daterange_label(self):
since, until = self.daterange
if until.date() == utils.utcnow().date():
return ' - '.join((
utils.localize_date(since, long_format=False),
self.translate(_(u'Today'))
))
return ' - '.join((
utils.localize_date(since, long_format=False),
utils.localize_date(until, long_format=False)
))
def find_expired_reservation_sessions(expiration_date):
""" Goes through all reservations and returns the session ids of the
unconfirmed ones which are older than the given expiration date.
By default the expiration date is now - 15 minutes.
Note that this method goes through ALL RESERVATIONS OF THE DATABASE. If
this is not desired have a look at buildout/database.cfg.example to
setup each site with its own database.
"""
expiration_date = expiration_date or (
utils.utcnow() - timedelta(minutes=15)
)
# first get the session ids which are expired
query = Session.query(
Reservation.session_id,
func.max(Reservation.created),
func.max(Reservation.modified)
)
query = query.group_by(Reservation.session_id)
# != null() because != None is not allowed by PEP8
query = query.filter(Reservation.session_id != null())
# the idea is to remove all reservations belonging to sessions whose
# latest update is expired - either delete the whole session or let
# all of it be
expired_sessions = []
for session_id, created, modified in query.all():
modified = modified or created
assert created and modified
if max(created, modified) < expiration_date:
expired_sessions.append(session_id)
return expired_sessions
def test_session_expiration(self):
sc = Scheduler(new_uuid())
session_id = new_uuid()
start, end = datetime(2013, 5, 1, 13, 0), datetime(2013, 5, 1, 14)
sc.allocate(dates=(start, end), approve_manually=True)
sc.reserve(u'*****@*****.**', (start, end), session_id=session_id)
created = utils.utcnow()
db.Session.query(db.Reservation).filter(
db.Reservation.session_id == session_id
).update({'created': created, 'modified': None})
expired = db.find_expired_reservation_sessions(expiration_date=created)
self.assertEqual(len(expired), 0)
expired = db.find_expired_reservation_sessions(
expiration_date=created + timedelta(microseconds=1)
)
self.assertEqual(len(expired), 1)
db.Session.query(db.Reservation).filter(
db.Reservation.session_id == session_id
).update({
'created': created,
'modified': created + timedelta(microseconds=1)
})
expired = db.find_expired_reservation_sessions(
expiration_date=created + timedelta(microseconds=1)
)
self.assertEqual(len(expired), 0)
expired = db.find_expired_reservation_sessions(
expiration_date=created + timedelta(microseconds=2)
)
self.assertEqual(len(expired), 1)
def human_date(date):
# timezones are currently naive and implicity the the one used by
# the users - we don't have international reservations yet
now = utils.utcnow()
this_morning = datetime(now.year, now.month,
now.day).replace(tzinfo=now.tzinfo)
time = date.strftime('%H:%M')
if date >= this_morning:
return _(u'Today, at ${time}', mapping={'time': time})
days = (now.date() - date.date()).days
if days <= 1:
return _(u'Yesterday, at ${time}', mapping={'time': time})
else:
return _(u'${days} days ago, at ${time}',
mapping={
'days': days,
'time': time
})
def latest_reservations(resources, reservations='*', days=30):
schedulers = {}
for uuid in resources.keys():
schedulers[uuid] = db.Scheduler(uuid)
since = utils.utcnow() - timedelta(days=days)
query = Session.query(Reservation)
query = query.filter(Reservation.resource.in_(resources.keys()))
query = query.filter(Reservation.created > since)
query = query.order_by(desc(Reservation.created))
if reservations != '*':
query = query.filter(Reservation.token.in_(reservations))
result = utils.OrderedDict()
for reservation in query.all():
if reservation.token in result:
result.append(reservation)
else:
result[reservation.token] = [reservation]
return result
def latest_reservations(resources, reservations='*', days=30):
schedulers = {}
for uuid in resources.keys():
schedulers[uuid] = db.Scheduler(uuid)
since = utils.utcnow() - timedelta(days=days)
query = Session.query(Reservation)
query = query.filter(Reservation.resource.in_(resources.keys()))
query = query.filter(Reservation.created > since)
query = query.order_by(desc(Reservation.created))
if reservations != '*':
query = query.filter(Reservation.token.in_(reservations))
result = utils.OrderedDict()
for reservation in query.all():
if reservation.token in result:
result.append(reservation)
else:
result[reservation.token] = [reservation]
return result
