def now_plus_24(self, location):
now = now_rounded()
now_plus_24 = now + timedelta(hours=24)
return self.filter(
Q(origin=location, departure__range=(now, now_plus_24))
| Q(destination=location, arrival__range=(now, now_plus_24)))
def now_minus_24(self, location):
now = now_rounded()
now_minus_24 = now - datetime.timedelta(hours=24)
return self.filter(location=location,
minute__datetime__range=(now_minus_24, now)) \
.order_by('-minute__datetime')
def now_minus_24(self, location):
now = now_rounded()
now_minus_24 = now - datetime.timedelta(hours=24)
return self.filter(location=location,
minute__datetime__range=(now_minus_24, now)) \
.order_by('-minute__datetime')
def sea_level_windows_now(self, location_slug, sea_level):
now = now_rounded()
# Limit to looking 30 days ahead, otherwise the return set is large
now_plus_1d = now + timedelta(days=1)
windows = self.sea_level_windows(location_slug, sea_level, now,
now_plus_1d)
return list(windows)[:1] if windows else None
def now_plus_24(self, location):
now = now_rounded()
now_24 = now + datetime.timedelta(hours=24)
return self.filter(location=location) \
.filter(Q(minute_from__datetime__range=(now, now_24)) |
Q(minute_to__datetime__range=(now, now_24))) \
.order_by('minute_from__datetime')
def sea_level_windows_now(self, location_slug, sea_level):
now = now_rounded()
# Limit to looking 30 days ahead, otherwise the return set is large
now_plus_1d = now + timedelta(days=1)
windows = self.sea_level_windows(location_slug, sea_level, now,
now_plus_1d)
return list(windows)[:1] if windows else None
def now_plus_24(self, location):
now = now_rounded()
now_plus_24 = now + timedelta(hours=24)
return self.filter(Q(origin=location,
departure__datetime__range=(now, now_plus_24)) |
Q(destination=location,
arrival__datetime__range=(now, now_plus_24)))
def now_plus_24(self, location):
now = now_rounded()
now_24 = now + datetime.timedelta(hours=24)
return self.filter(location=location) \
.filter(Q(minute_from__datetime__range=(now, now_24)) |
Q(minute_to__datetime__range=(now, now_24))) \
.order_by('minute_from__datetime')
def latest_object(self, location):
now = now_rounded()
objects = self.filter(location=location) \
.filter(minute_from__datetime__gte=now) \
.order_by('minute_from__datetime')
if not objects.exists():
return []
return [objects[0]]
def latest_object(self, location):
now = now_rounded()
objects = self.filter(location=location) \
.filter(minute_from__datetime__gte=now) \
.order_by('minute_from__datetime')
if not objects.exists():
return []
return [objects[0]]
def expire(login_code, status='success'):
login_expire, created = LoginCodeExpired.objects.get_or_create(
datetime=now_rounded(),
status=status,
code=login_code.code,
user=login_code.user)
if not created:
login_expire.attempts = login_expire.attempts + 1
login_expire.save()
if login_expire.attempts >= settings.NOPASSWORD_LOGIN_CODE_EXPIRE:
login_code.delete()
def get_queryset(self, *args, **kwargs):
new_query_params = self.request.query_params.copy() # make it mutable
now = now_rounded()
now_plus_24 = now + datetime.timedelta(hours=24)
new_query_params.update({
'start': format_datetime(now),
'end': format_datetime(now_plus_24),
})
return super(TideLevelsNow, self).get_queryset(
query_params=new_query_params, *args, **kwargs)
def get_queryset(self):
location = self.get_location()
query_params = self.request.query_params
time_range = parse_time_range(
query_params.get('start', None),
query_params.get('end', None)
)
if time_range.end > now_rounded():
raise InvalidParameterError(_("End range cannot be in the future"))
queryset = WeatherObservation.objects.date_range(location, time_range)
return queryset
def expire(login_code, status='success', code_expire=None):
if not login_code.user.user_profile.codes_timeout:
return False
if not code_expire:
code_expire = settings.NOPASSWORD_LOGIN_CODE_EXPIRE
login_expire, created = LoginCodeExpired.objects.get_or_create(
status=status,
code=login_code.code,
user=login_code.user,
defaults={'datetime': now_rounded()})
if not created:
login_expire.attempts = login_expire.attempts + 1
login_expire.save()
if login_expire.attempts >= code_expire:
login_code.delete()
def test_that_code_expires(self):
code = LoginCode.objects.create(user=self.user)
data = json.dumps({'code': code.code})
url = '/1/authenticate/code/'
now = now_rounded()
with freeze_time(now):
response = self.client.post(url, data=data,
content_type='application/json')
self.assertEqual(200, response.status_code)
self.assertEqual(0, LoginCode.objects.all().count())
self.assertEqual(1, LoginCodeExpired.objects.all().count())
expired_code = LoginCodeExpired.objects.get()
self.assertEqual(code.code, expired_code.code)
self.assertEqual("success", expired_code.status)
self.assertEqual(self.user, expired_code.user)
self.assertEqual(now, expired_code.datetime)
def test_that_code_expires(self):
code = LoginCode.objects.create(user=self.user, code='1234')
data = json.dumps({'code': code.code, 'email': self.user.email})
url = '/1/authenticate/code'
now = now_rounded()
with freeze_time(now):
for i in range(0, settings.NOPASSWORD_LOGIN_CODE_EXPIRE):
response = self.client.post(url, data=data,
content_type='application/json')
self.assertEqual(200, response.status_code)
self.assertEqual(0, LoginCode.objects.all().count())
self.assertEqual(1, LoginCodeExpired.objects.all().count())
expired_code = LoginCodeExpired.objects.get()
self.assertEqual(code.code, expired_code.code)
self.assertEqual("success", expired_code.status)
self.assertEqual(self.user, expired_code.user)
self.assertEqual(now, expired_code.datetime)
def test_that_code_expires(self):
code = LoginCode.objects.create(user=self.user, code='1234')
data = json.dumps({'code': code.code, 'email': self.user.email})
url = '/1/authenticate/code'
now = now_rounded()
with freeze_time(now):
for i in range(0, settings.NOPASSWORD_LOGIN_CODE_EXPIRE):
response = self.client.post(url,
data=data,
content_type='application/json')
self.assertEqual(200, response.status_code)
self.assertEqual(0, LoginCode.objects.all().count())
self.assertEqual(1, LoginCodeExpired.objects.all().count())
expired_code = LoginCodeExpired.objects.get()
self.assertEqual(code.code, expired_code.code)
self.assertEqual("success", expired_code.status)
self.assertEqual(self.user, expired_code.user)
self.assertEqual(now, expired_code.datetime)
def create_schedule_now(self, payload=None, **kwargs):
kwargs['departure'] = format_datetime(now_rounded())
kwargs['arrival'] = format_datetime(delta(hours=2))
return self.create_schedule(payload, **kwargs)
def test_that_weather_observations_alerts_can_be_disabled(self):
now = now_rounded()
with freeze_time(now):
disable_alert_until(self.location, AlertType.weather_predictions,
delta(hours=1))
self.assert_status(True, 'OK (alert disabled)', self.location)
def latest_object(self, location):
now = now_rounded()
qs = self.filter(location=location,
datetime__gte=now) \
.order_by('datetime')
return qs[:1] if qs.count() else None
def test_that_schedule_alerts_can_be_disabled(self):
now = now_rounded()
with freeze_time(now):
disable_alert_until(self.origin, AlertType.schedule,
delta(hours=1))
self.assert_status(True, 'OK (alert disabled)', self.origin)
def now_plus_24(self):
now = now_rounded()
now_plus_24 = now + datetime.timedelta(hours=24)
return self.filter(datetime__range=(now, now_plus_24))
def latest_object(self, location):
now = now_rounded()
qs = self.filter(location=location,
datetime__gte=now) \
.order_by('datetime')
return qs[:1] if qs.count() else None
def create_tideprediction_now(self, payload=TIDEPREDICTION_A, **kwargs):
kwargs['minute__datetime'] = format_datetime(now_rounded())
return self.create_tideprediction(payload, **kwargs)
def now_plus_24(self):
now = now_rounded()
now_plus_24 = now + datetime.timedelta(hours=24)
return self.filter(datetime__range=(now, now_plus_24))
def create_tideprediction_now(self, payload=TIDEPREDICTION_A, **kwargs):
kwargs['minute__datetime'] = format_datetime(now_rounded())
return self.create_tideprediction(payload, **kwargs)
def test_that_schedule_alerts_can_be_disabled(self):
now = now_rounded()
with freeze_time(now):
disable_alert_until(self.origin, AlertType.schedule,
delta(hours=1))
self.assert_status(True, 'OK (alert disabled)', self.origin)
def create_surgeprediction_now(self, data=SURGEPREDICTION_A, **kwargs):
kwargs['minute__datetime'] = format_datetime(now_rounded())
return self.create_surgeprediction(data, **kwargs)
def delta(**deltatime):
now = now_rounded()
return now + datetime.timedelta(**deltatime)
def create_surgeprediction_now(self, data=SURGEPREDICTION_A, **kwargs):
kwargs['minute__datetime'] = format_datetime(now_rounded())
return self.create_surgeprediction(data, **kwargs)
def create_schedule_now(self, payload=None, **kwargs):
kwargs['departure__datetime'] = format_datetime(now_rounded())
kwargs['arrival__datetime'] = format_datetime(delta(hours=2))
return self.create_schedule(payload, **kwargs)
def expire(login_code, status='success'):
LoginCodeExpired.objects.create(datetime=now_rounded(),
status=status,
code=login_code.code,
user=login_code.user)
login_code.delete()