class NonBookablePeriodSchema(mm.SQLAlchemyAutoSchema):
start_dt = NaiveDateTime()
end_dt = NaiveDateTime()
class Meta:
model = NonBookablePeriod
fields = ('start_dt', 'end_dt')
def test_NaiveDateTime_deserialize():
now = datetime.now()
utc_now = pytz.utc.localize(datetime.utcnow())
field = NaiveDateTime()
assert field.deserialize(now.isoformat()) == now
with pytest.raises(ValidationError):
field.deserialize(utc_now.isoformat())
class ReservationDetailsSchema(mm.SQLAlchemyAutoSchema):
booked_for_user = Nested(UserSchema, only=('id', 'identifier', 'full_name', 'phone', 'email'))
created_by_user = Nested(UserSchema, only=('id', 'identifier', 'full_name', 'email'))
edit_logs = Nested(ReservationEditLogSchema, many=True)
can_accept = Function(lambda booking: booking.can_accept(session.user))
can_cancel = Function(lambda booking: booking.can_cancel(session.user))
can_delete = Function(lambda booking: booking.can_delete(session.user))
can_edit = Function(lambda booking: booking.can_edit(session.user))
can_reject = Function(lambda booking: booking.can_reject(session.user))
permissions = Method('_get_permissions')
state = EnumField(ReservationState)
is_linked_to_object = Function(lambda booking: booking.link is not None)
link = Nested(ReservationLinkSchema)
start_dt = NaiveDateTime()
end_dt = NaiveDateTime()
class Meta:
model = Reservation
fields = ('id', 'start_dt', 'end_dt', 'repetition', 'booking_reason', 'created_dt', 'booked_for_user',
'room_id', 'created_by_user', 'edit_logs', 'permissions',
'is_cancelled', 'is_rejected', 'is_accepted', 'is_pending', 'rejection_reason',
'is_linked_to_object', 'link', 'state', 'external_details_url')
def _get_permissions(self, booking):
methods = ('can_accept', 'can_cancel', 'can_delete', 'can_edit', 'can_reject')
admin_permissions = None
user_permissions = {x: getattr(booking, x)(session.user, allow_admin=False) for x in methods}
if rb_is_admin(session.user):
admin_permissions = {x: getattr(booking, x)(session.user) for x in methods}
return {'user': user_permissions, 'admin': admin_permissions}
class ReservationSchema(mm.SQLAlchemyAutoSchema):
start_dt = NaiveDateTime()
end_dt = NaiveDateTime()
class Meta:
model = Reservation
fields = ('id', 'booking_reason', 'booked_for_name', 'room_id', 'is_accepted', 'start_dt', 'end_dt')
class ReservationDetailsOccurrenceSchema(mm.ModelSchema):
start_dt = NaiveDateTime()
end_dt = NaiveDateTime()
class Meta:
model = ReservationOccurrence
fields = ('start_dt', 'end_dt', 'is_valid', 'rejection_reason')
def test_NaiveDateTime_deserialize():
now = datetime.now()
utc_now = pytz.utc.localize(datetime.utcnow())
field = NaiveDateTime()
assert field.deserialize(now.isoformat()) == now
with pytest.raises(ValidationError):
field.deserialize(utc_now.isoformat())
class RHCheckRoomAvailable(RHRoomBase):
@use_kwargs({
'start_dt': NaiveDateTime(),
'end_dt': NaiveDateTime(),
})
def _process(self, start_dt, end_dt):
return jsonify(check_room_available(self.room, start_dt, end_dt))
class ReservationDetailsSchema(mm.ModelSchema):
booked_for_user = Nested(UserSchema, only=('full_name', 'phone', 'email'))
created_by_user = Nested(UserSchema, only=('full_name', ))
edit_logs = Nested(ReservationEditLogSchema, many=True)
can_accept = Function(
lambda booking: booking.can_be_accepted(session.user))
can_cancel = Function(
lambda booking: booking.can_be_cancelled(session.user))
can_delete = Function(lambda booking: booking.can_be_deleted(session.user))
can_modify = Function(
lambda booking: booking.can_be_modified(session.user))
can_reject = Function(
lambda booking: booking.can_be_rejected(session.user))
is_linked_to_event = Function(lambda booking: booking.event_id is not None)
start_dt = NaiveDateTime()
end_dt = NaiveDateTime()
class Meta:
model = Reservation
fields = ('id', 'start_dt', 'end_dt', 'repetition', 'booking_reason',
'created_dt', 'booked_for_user', 'room_id',
'created_by_user', 'edit_logs', 'can_accept', 'can_cancel',
'can_delete', 'can_modify', 'can_reject', 'is_cancelled',
'is_rejected', 'is_accepted', 'is_pending',
'rejection_reason', 'is_linked_to_event')
class ReservationOccurrenceSchema(mm.ModelSchema):
reservation = Nested(ReservationSchema)
start_dt = NaiveDateTime()
end_dt = NaiveDateTime()
class Meta:
model = ReservationOccurrence
fields = ('start_dt', 'end_dt', 'is_valid', 'reservation')
class ReservationOccurrenceSchema(mm.SQLAlchemyAutoSchema):
reservation = Nested(ReservationSchema)
state = EnumField(ReservationState)
start_dt = NaiveDateTime()
end_dt = NaiveDateTime()
class Meta:
model = ReservationOccurrence
fields = ('start_dt', 'end_dt', 'is_valid', 'reservation', 'rejection_reason', 'state')
def test_NaiveDateTime_serialize():
now = datetime.now()
utc_now = pytz.utc.localize(datetime.utcnow())
obj = type(b'Test', (object, ), {
b'naive': now,
b'aware': utc_now,
})
field = NaiveDateTime()
assert field.serialize('naive', obj) == now.isoformat()
with pytest.raises(AssertionError):
field.serialize('aware', obj)
def test_NaiveDateTime_serialize():
now = datetime.now()
utc_now = pytz.utc.localize(datetime.utcnow())
obj = type(b'Test', (object,), {
b'naive': now,
b'aware': utc_now,
})
field = NaiveDateTime()
assert field.serialize('naive', obj) == now.isoformat()
with pytest.raises(AssertionError):
field.serialize('aware', obj)
class RHPrepareEvent(RH):
"""Prepare the creation of an event with some data."""
CSRF_ENABLED = False
@use_kwargs({
'title': fields.String(required=True),
'start_dt': NaiveDateTime(required=True),
'tz': fields.String(missing=config.DEFAULT_TIMEZONE, validate=lambda v: v in common_timezones_set),
'duration': fields.Integer(required=True, validate=lambda v: v > 0),
'event_type': fields.String(missing='meeting'),
})
def _process(self, title, start_dt, tz, duration, event_type):
event_key = str(uuid4())
start_dt = timezone(tz).localize(start_dt)
prepared_event_data_store.set(
event_key,
{
'title': title,
'start_dt': start_dt,
'duration': duration,
'event_type': event_type,
},
3600
)
return jsonify(url=url_for_index(_external=True, _anchor=f'create-event:meeting::{event_key}'))
def _add_missing_time(field, data, time_):
ds = dict2schema({field: fields.Date()})()
dts = dict2schema({field: NaiveDateTime()})()
try:
# let's see if we can load this as a DateTime
dts.load({field: data[field]})
except ValidationError:
# if not, we assume it's a valid date and append the time
date = ds.load({field: data[field]})[field]
data[field] = dts.dump({field: datetime.combine(date, time_)})[field]
