def setUp(self):
self.user = User.objects.create(username="******",
password="******",
email="*****@*****.**")
self.station = Station.objects.create(latitude=1.0,
longtitude=1.5,
address="Baker Street",
number="221B",
zipcode="NW16XE",
city="London",
country="United Kingdom",
operator=self.user)
self.car = Car.objects.create(user_id=self.user, licence="221B")
self.point = Point.objects.create(station_id=self.station)
self.pricing = Pricing.objects.create(station_id=self.station,
description="capitalism",
price=1000)
self.payment_choices = ['CD', 'CH']
self.protocol_choices = ['WR', 'WD']
self.ch_sess = ChargeSession.objects.create(
car_id=self.car,
point_id=self.point,
pricing_id=self.pricing,
energy_delivered=42,
total_cost=17,
start=get_now() + token_expires_delta(past=True),
end=now(),
payment=self.payment_choices[0],
protocol=self.protocol_choices[0])
def get(self, request, user, point_id, date_from, date_to):
requested_format = self.request.GET.get('format', 'json')
try:
start = datetime_from_string(date_from)
end = datetime_from_string(date_to) + datetime.timedelta(milliseconds=999)
except ValueError:
return HttpResponseBadRequest("Invalid date format.")
try:
point = Point.objects.get(id=point_id)
except ObjectDoesNotExist:
return HttpResponseBadRequest("Point does not exist.")
except ValueError:
return HttpResponseBadRequest("Invalid point id")
if point.station_id.operator != user:
return HttpResponse("Unauthorized. Point does not belong to you.", status=401)
sessions = ChargeSession.objects.filter(point_id=point,
start__gte=start, end__lte=end).order_by('start')
resp = {
"Point": point.id,
"PointOperator": point.station_id.operator.username,
"RequestTimestamp": datetime_to_string(get_now()),
"PeriodFrom": datetime_to_string(start),
"PeriodTo": datetime_to_string(end),
"NumberOfChargingSessions": len(sessions),
"ChargingSessionsList": []
}
for idx, session in enumerate(sessions, start=1):
item = {
"SessionIndex": idx,
"SessionID": session.id,
"StartedOn": datetime_to_string(session.start),
"FinishedOn": datetime_to_string(session.end),
"Protocol": session.protocol,
"EnergyDelivered": session.energy_delivered,
"Payment": session.payment,
"SessionCost": session.total_cost
}
if session.car_id:
item["VehicleType"] = session.car_id.type
resp["ChargingSessionsList"].append(item)
if requested_format == 'csv':
root_keys = ["Point", "PointOperator", "RequestTimestamp", "PeriodFrom", "PeriodTo",
"NumberOfChargingSessions"]
lst_keys = ["SessionIndex", "SessionID", "StartedOn", "FinishedOn", "Protocol",
"EnergyDelivered", "Payment", "VehicleType"]
return produce_csv_response(resp, root_keys, lst_keys, "ChargingSessionsList")
elif requested_format == "json":
return JsonResponse(resp)
else:
return HttpResponseBadRequest("Invalid format.")
def test_logout_valid(self):
token = self._login_and_get_token(self.username, self.password)
resp = self._logout(token)
self.assertEqual(resp.status_code, 200)
self.assertEqual(len(resp.content), 0)
session = UserSession.objects.get(token=token)
self.assertTrue(session.expires < get_now())
def test_expiration(self):
token = create_auth_token()
expires = get_now() - token_expires_delta()
session = UserSession.objects.create(user_id=self.user,
token=token,
expires=expires)
session.save()
# Check that session has expired
self.assertTrue(session.has_expired())
expires = get_now() + token_expires_delta()
token = create_auth_token()
session = UserSession.objects.create(user_id=self.user,
token=token,
expires=expires)
session.save()
# check for session that has not expired
self.assertFalse(session.has_expired())
def test_login_valid(self):
resp = self._login(self.username, self.password)
self.assertEqual(resp.status_code, 200)
self.assertTrue(isinstance(resp, JsonResponse))
body = json.loads(resp.content)
self.assertTrue(body.get("token", False))
# check session object
session = UserSession.objects.get(token=body['token'])
self.assertTrue(session.expires > get_now())
self.assertEquals(session.user_id, self.user)
def test_unique_token(self):
token = create_auth_token()
expires = get_now() - token_expires_delta()
session = UserSession.objects.create(user_id=self.user,
token=token,
expires=expires)
session.save()
# check that integrity error raised for duplicate token
with self.assertRaises(IntegrityError):
session = UserSession.objects.create(user_id=self.user,
token=token,
expires=expires)
def _create_dummy_sessions(self):
ChargeSession.objects.create(
car_id=None, point_id=None, pricing_id=None,
energy_delivered=30, total_cost=300,
start=get_now(), end=get_now(),
payment='CD', protocol='WR')
ChargeSession.objects.create(
car_id=None, point_id=None, pricing_id=None,
energy_delivered=10, total_cost=100,
start=get_now(), end=get_now(),
payment='CD', protocol='WR')
ChargeSession.objects.create(
car_id=None, point_id=None, pricing_id=None,
energy_delivered=20, total_cost=200,
start=get_now(), end=get_now(),
payment='CD', protocol='WR')
def _elapsed(self, dt):
return datetime.datetime.timestamp(
get_now()) - datetime.datetime.timestamp(datetime_from_string(dt))
def _get_prev_days(self, days):
return get_now() - datetime.timedelta(days=days)
def get(self, request, user, station_id, date_from, date_to):
requested_format = self.request.GET.get('format', 'json')
try:
start = datetime_from_string(date_from)
end = datetime_from_string(date_to) + datetime.timedelta(
milliseconds=999)
except ValueError:
return HttpResponseBadRequest("Invalid date format.")
try:
station = Station.objects.get(id=station_id)
except ObjectDoesNotExist:
return HttpResponseBadRequest("Station does not exist.")
except ValueError:
return HttpResponseBadRequest("Invalid station id")
if station.operator != user:
return HttpResponse(
"Unauthorized. Station does not belong to you.", status=401)
points = Point.objects.filter(station_id=station)
resp = {
"StationID": station.id,
"Operator": station.operator.username,
"RequestTimestamp": datetime_to_string(get_now()),
"PeriodFrom": datetime_to_string(start),
"PeriodTo": datetime_to_string(end),
"TotalEnergyDelivered": 0,
"NumberOfChargingSessions": 0,
"NumberOfActivePoints": 0,
"SessionsSummaryList": []
}
for point in points:
sessions = ChargeSession.objects.filter(
point_id=point, start__gte=start,
end__lte=end).order_by('start')
if len(sessions):
energy_delivered = sum([x.energy_delivered for x in sessions])
resp['NumberOfChargingSessions'] += len(sessions)
resp['NumberOfActivePoints'] += 1
resp["SessionsSummaryList"].append({
"PointID":
point.id,
"PointSessions":
len(sessions),
"EnergyDelivered":
energy_delivered
})
resp['TotalEnergyDelivered'] += energy_delivered
if requested_format == 'csv':
root_keys = [
"StationID", "Operator", "RequestTimestamp", "PeriodFrom",
"PeriodTo", "TotalEnergyDelivered", "NumberOfChargingSessions",
"NumberOfActivePoints"
]
lst_keys = ["PointID", "PointSessions", "EnergyDelivered"]
return produce_csv_response(resp, root_keys, lst_keys,
"SessionsSummaryList")
elif requested_format == "json":
return JsonResponse(resp)
else:
return HttpResponseBadRequest("Invalid format.")
def get(self, request, user, vehicle_id, date_from, date_to):
requested_format = self.request.GET.get('format', 'json')
try:
start = datetime_from_string(date_from)
end = datetime_from_string(date_to) + datetime.timedelta(
milliseconds=999)
except ValueError:
return HttpResponseBadRequest("Invalid date format.")
try:
car = Car.objects.get(licence=vehicle_id)
except ObjectDoesNotExist:
return HttpResponseBadRequest("EV does not exist.")
if car.user_id != user:
return HttpResponse(
"Unauthorized. Vehicle does not belong to you.", status=401)
sessions = ChargeSession.objects.filter(car_id=car,
start__gte=start,
end__lte=end).order_by('start')
resp = {
"VehicleID": car.licence,
"RequestTimestamp": datetime_to_string(get_now()),
"PeriodFrom": datetime_to_string(start),
"PeriodTo": datetime_to_string(end),
"TotalEnergyConsumed": 0,
"NumberOfVisitedPoints": 0,
"NumberOfVehicleChargingSessions": len(sessions),
"VehicleChargingSessionsList": []
}
visited_points = set()
for idx, session in enumerate(sessions, start=1):
item = {
"SessionIndex": idx,
"SessionID": session.id,
"EnergyProvider": None,
"StartedOn": datetime_to_string(session.start),
"FinishedOn": datetime_to_string(session.end),
"EnergyDelivered": session.energy_delivered,
"SessionCost": session.total_cost
}
if session.pricing_id:
item["PricePolicyRef"] = session.pricing_id.description
item["CostPerKWh"] = session.pricing_id.price
resp["VehicleChargingSessionsList"].append(item)
resp["TotalEnergyConsumed"] += session.energy_delivered
if session.point_id:
visited_points.add(session.point_id.id)
resp["NumberOfVisitedPoints"] = len(visited_points)
if requested_format == 'csv':
root_keys = [
"VehicleID", "RequestTimestamp", "PeriodFrom", "PeriodTo",
"TotalEnergyConsumed", "NumberOfVisitedPoints",
"NumberOfVehicleChargingSessions"
]
lst_keys = [
"SessionIndex", "SessionID", "EnergyProvider", "StartedOn",
"FinishedOn", "EnergyDelivered", "PricePolicyRef",
"CostPerKWh", "SessionCost"
]
return produce_csv_response(resp, root_keys, lst_keys,
"VehicleChargingSessionsList")
elif requested_format == "json":
return JsonResponse(resp)
else:
return HttpResponseBadRequest("Invalid format.")
def post(self, request, user):
token = request.headers.get('x-auth-observatory', None)
session = UserSession.objects.get(token=token)
session.expires = get_now()
session.save()
return HttpResponse()
def has_expired(self):
if self.expires < get_now():
return True
return False
