class IssueView(BaseView):
"""
Gets an issue by its id
"""
url = "/issues/{id}"
with_issue = match_getter(get_issue, "issue", iid="id")
@with_issue
@docs(summary="Get An Issue")
@returns(JSendSchema.of(issue=IssueSchema()))
async def get(self, issue):
return {
"status": JSendStatus.SUCCESS,
"data": {"issue": issue.serialize(self.request.app.router)}
}
@with_issue
@docs(summary="Modify An Issue")
@expects(IssueUpdateSchema())
@returns(JSendSchema.of(issue=IssueSchema()))
async def patch(self, issue):
issue = await update_issue(
issue,
self.request["data"].get("status"),
self.request["data"].get("resolution", None)
)
return {
"status": JSendStatus.SUCCESS,
"data": {"issue": issue.serialize(self.request.app.router)}
}
class PickupReservationsView(BaseView):
"""
Gets or adds to a pickup point's list of reservations.
"""
url = f"/pickups/{{id:{PICKUP_IDENTIFIER_REGEX}}}/reservations"
with_user = match_getter(get_user, "user", firebase_id=GetFrom.AUTH_HEADER)
with_pickup = match_getter(get_pickup_point, "pickup", pickup_id="id")
@with_user
@docs(summary="Get All Reservations For Pickup Point")
@requires(UserIsAdmin())
@returns(JSendSchema.of(reservations=Many(ReservationSchema())))
async def get(self, user):
reservation_ids = self.reservation_manager.reservations_in(
self.request.match_info["id"])
return {
"status": JSendStatus.SUCCESS,
"data": {
"reservations": [
reservation.serialize(self.request.app.router,
self.reservation_manager)
for reservation in await get_reservations(*reservation_ids)
]
}
}
@with_pickup
@with_user
@docs(summary="Create Reservation At Pickup Point")
@expects(CreateReservationSchema())
@returns(error=JSendSchema(),
success=JSendSchema.of(reservation=ReservationSchema()))
async def post(self, user, pickup):
"""
To claim a reservation, simply rent a bike from the same pickup point as you usually
would do. This will automatically claim that bike for you, ending your reservation,
and starting your rental.
"""
time = self.request["data"]["reserved_for"]
try:
reservation = await self.reservation_manager.reserve(
user, pickup, time)
except ReservationError as e:
return "error", {
"status": JSendStatus.FAIL,
"data": {
"message": str(e)
}
}
else:
return "success", {
"status": JSendStatus.SUCCESS,
"data": {
"reservation":
reservation.serialize(self.request.app.router,
self.reservation_manager)
}
}
class BikesView(BaseView):
"""
Gets the bikes, or adds a new bike.
"""
url = "/bikes"
with_user = match_getter(get_user,
Optional("user"),
firebase_id=Optional(GetFrom.AUTH_HEADER))
@with_user
@docs(summary="Get All Bikes")
@returns(JSendSchema.of(bikes=Many(BikeSchema(exclude=("public_key", )))))
async def get(self, user):
"""Gets all the bikes from the system."""
bikes = [
bike.serialize(self.bike_connection_manager,
self.rental_manager,
self.reservation_manager,
include_location=user is not None
and user.type is not UserType.USER)
for bike in await get_bikes()
]
if self.request.query.get("available") == "true":
bikes = (bike for bike in bikes if bike["status"] == "available")
return {"status": JSendStatus.SUCCESS, "data": {"bikes": bikes}}
@docs(summary="Register New Bike")
@expects(BikeRegisterSchema())
@returns(bad_key=(JSendSchema(), web.HTTPBadRequest),
registered=JSendSchema.of(bike=BikeSchema(only=('identifier',
'available'))))
async def post(self):
""" Registers a bike with the system."""
try:
bike = await register_bike(self.request["data"]["public_key"],
self.request["data"]["master_key"])
except BadKeyError as error:
return "bad_key", {
"status": JSendStatus.FAIL,
"data": {
"message": "The supplied master key is invalid.",
"errors": error.args
},
}
else:
return "registered", {
"status": JSendStatus.SUCCESS,
"data": {
"bike":
bike.serialize(self.bike_connection_manager,
self.rental_manager,
self.reservation_manager)
}
}
class UserIssuesView(BaseView):
"""
Gets or adds to the users' list of issues.
"""
url = f"/users/{{id:{USER_IDENTIFIER_REGEX}}}/issues"
name = "user_issues"
with_issues = match_getter(get_issues, "issues", user='******')
with_user = match_getter(get_user, 'user', user_id='id')
@with_user
@with_issues
@docs(summary="Get All Issues For User")
@requires(UserMatchesToken() | UserIsAdmin())
@returns(JSendSchema.of(issues=Many(IssueSchema())))
async def get(self, user, issues):
return {
"status": JSendStatus.SUCCESS,
"data": {
"issues":
[issue.serialize(self.request.app.router) for issue in issues]
}
}
@with_user
@docs(summary="Open Issue For User")
@requires(UserMatchesToken() | UserIsAdmin())
@expects(IssueSchema(only=('description', 'bike_identifier')))
@returns(
JSendSchema.of(issue=IssueSchema(only=('id', 'user_id', 'user_url',
'bike_identifier',
'description', 'opened_at'))))
async def post(self, user):
issue_data = {
"description": self.request["data"]["description"],
"user": user
}
if "bike_identifier" in self.request["data"]:
issue_data["bike"] = await get_bike(
identifier=self.request["data"]["bike_identifier"])
issue = await open_issue(**issue_data)
return {
"status": JSendStatus.SUCCESS,
"data": {
"issue": issue.serialize(self.request.app.router)
}
}
class LowBikesView(BaseView):
url = "/bikes/low"
@docs(summary="Get All Low Battery Bikes")
@returns(
JSendSchema.of(bikes=Many(
BikeSchema(only=("identifier", "battery", "current_location")))))
async def get(self):
"""
There may come a point where a bike hasn't been able to generate enough power
to sustain its battery level. The that point (30% battery or lower), the bike
will be listed here. If you claim and recharge one of these bikes, you will
receive discounts on your next trip proportional to the amount charged. These
stack up.
If, for example, you charged 5 bikes for 92, 45, 37, 78, and 83 percent each
then your next 5 rides will be 92% off, then 45% off, etc.
"""
low_battery_bikes = await self.bike_connection_manager.low_battery(30)
serialized_bikes = [
bike.serialize(self.bike_connection_manager, self.rental_manager,
self.reservation_manager)
for bike in low_battery_bikes
]
serialized_bikes = [
bike for bike in serialized_bikes if bike["available"]
]
return {
"status": JSendStatus.SUCCESS,
"data": {
"bikes": serialized_bikes
}
}
class BrokenBikesView(BaseView):
"""
Gets the list of bikes with active issues, along with the open issues for those bikes.
"""
url = "/bikes/broken"
with_bikes = match_getter(get_broken_bikes, "broken_bikes")
with_admin = match_getter(get_user,
"user",
firebase_id=GetFrom.AUTH_HEADER)
@with_admin
@with_bikes
@docs(summary="Get All Broken Bikes")
@requires(UserIsAdmin())
@returns(JSendSchema.of(bikes=Many(BikeSchema())))
async def get(self, user, broken_bikes):
"""
A broken bike is one that has at least one issue open. Broken bikes must be
serviced, and so their status is shown here for use by the operators. These
bikes can be loaded into a path-finding algorithm and serviced as needed.
"""
return {
"status": JSendStatus.SUCCESS,
"data": {
"bikes": [
bike.serialize(self.bike_connection_manager,
self.rental_manager,
self.reservation_manager,
issues=issues)
for bike, issues in broken_bikes
]
}
}
class ClosestBikeView(BaseView):
"""
Gets or updates a single bike.
"""
url = f"/bikes/closest"
name = "closest_bike"
@docs(summary="Get The Closest Bike")
@returns(
JSendSchema.of(bike=BikeSchema(exclude=("public_key", )),
distance=Float()))
async def get(self):
"""Gets a single bike by its id."""
lat = self.request.query["lat"]
long = self.request.query["lng"]
user_location = Point(float(long), float(lat))
bike, distance = await self.bike_connection_manager.closest_available_bike(
user_location, self.rental_manager, self.reservation_manager)
if bike is None:
raise web.HTTPNotFound
else:
return {
"status": JSendStatus.SUCCESS,
"data": {
"bike":
bike.serialize(self.bike_connection_manager,
self.rental_manager,
self.reservation_manager),
"distance":
distance
}
}
class RentalView(BaseView):
"""
Gets or updates a single rental.
"""
url = "/rentals/{id}"
name = "rental"
with_rental = match_getter(get_rental_with_distance,
'rental',
Optional('distance'),
rental='id')
with_user = match_getter(get_user, 'user', firebase_id=GetFrom.AUTH_HEADER)
@with_rental
@with_user
@docs(summary="Get A Rental")
@requires(UserIsAdmin())
@returns(
JSendSchema.of(rental=RentalSchema(only=("id", "user_id", "user_url",
"bike_identifier", "bike_url",
"start_time", "is_active",
"distance"))))
async def get(self, rental: Rental, user, distance: float):
return {
"status": JSendStatus.SUCCESS,
"data": {
"rental":
await rental.serialize(self.rental_manager,
self.bike_connection_manager,
self.reservation_manager,
self.request.app.router,
distance=distance)
}
}
class UserRentalsView(BaseView):
"""
Gets or adds to the users list of rentals.
"""
url = f"/users/{{id:{USER_IDENTIFIER_REGEX}}}/rentals"
name = "user_rentals"
with_user = match_getter(get_user, 'user', user_id='id')
with_rentals = match_getter(get_rentals, 'rentals', user='******')
@with_user
@with_rentals
@docs(summary="Get All Rentals For User")
@requires(UserMatchesToken() | UserIsAdmin())
@returns(JSendSchema.of(rentals=Many(RentalSchema())))
async def get(self, user, rentals: List[Rental]):
return {
"status": JSendStatus.SUCCESS,
"data": {
"rentals": [
await rental.serialize(self.rental_manager,
self.request.app.router)
for rental in rentals
]
}
}
async def test_get_pickups(self, client, random_pickup_point):
resp = await client.get('/api/v1/pickups')
schema = JSendSchema.of(pickups=Many(PickupPointSchema()))
data = schema.load(await resp.json())
assert data["status"] == JSendStatus.SUCCESS
class RentalsView(BaseView):
"""
Gets a list of all rentals.
"""
url = "/rentals"
name = "rentals"
with_user = match_getter(get_user, 'user', firebase_id=GetFrom.AUTH_HEADER)
@with_user
@docs(summary="Get All Rentals")
@requires(UserIsAdmin())
@returns(
JSendSchema.of(rentals=Many(
RentalSchema(only=("id", "user_id", "user_url", "bike_identifier",
"bike_url", "start_time", "is_active")))))
async def get(self, user):
return {
"status": JSendStatus.SUCCESS,
"data": {
"rentals": [
await rental.serialize(self.rental_manager,
self.bike_connection_manager,
self.reservation_manager,
self.request.app.router)
for rental in await get_rentals()
]
}
}
class UserCurrentReservationView(BaseView):
"""
Gets the users' current reservation.
"""
url = f"/users/{{id:{USER_IDENTIFIER_REGEX}}}/reservations/current"
with_reservation = match_getter(current_reservations,
"reservations",
user="******")
with_user = match_getter(get_user, "user", user_id="id")
@with_user
@with_reservation
@docs(summary="Get Current Reservations For User")
@requires(UserMatchesToken() | UserIsAdmin())
@returns(JSendSchema.of(reservations=Many(CurrentReservationSchema())))
async def get(self, user, reservations: List[Reservation]):
return {
"status": JSendStatus.SUCCESS,
"data": {
"reservations": [
reservation.serialize(self.request.app.router,
self.reservation_manager)
for reservation in reservations
]
}
}
class UserPaymentView(BaseView):
"""
Allows a user to get or replace their payment details.
"""
url = f"/users/{{id:{USER_IDENTIFIER_REGEX}}}/payment"
with_user = match_getter(get_user, 'user', user_id='id')
@with_user
@docs(summary="Check For Existence Of Payment Details")
@returns(None)
async def get(self, user: User):
if user.can_pay:
raise web.HTTPOk
else:
raise web.HTTPNoContent
@with_user
@docs(summary="Add Or Replace Payment Details")
@expects(PaymentSourceSchema())
async def put(self, user: User):
if user.can_pay:
await self.payment_manager.update_customer(
user, self.request["data"]["token"])
else:
await self.payment_manager.create_customer(
user, self.request["data"]["token"])
raise web.HTTPOk
@with_user
@docs(summary="Delete Payment Details")
@returns(
active_rental=JSendSchema.of(rental=RentalSchema(),
message=String(),
url=Url(relative=True)),
no_details=(None, web.HTTPNotFound),
deleted=(None, web.HTTPNoContent),
)
async def delete(self, user: User):
rental = await self.rental_manager.active_rental(user)
if rental is not None:
return "active_rental", {
"status": JSendStatus.FAIL,
"data": {
"message":
"You cannot delete your payment details with an active rental.",
"url":
self.request.app.router["rental"].url_for(
id=str(rental.id)).path
}
}
elif not user.can_pay:
return "no_details", None
else:
await self.payment_manager.delete_customer(user)
return "deleted", None
async def test_get_issue(self, client, random_admin):
issue = await open_issue(random_admin, "An issue!")
response = await client.get(
f"/api/v1/issues/{issue.id}",
headers={"Authorization": f"Bearer {random_admin.firebase_id}"})
response_data = JSendSchema.of(issue=IssueSchema()).load(
await response.json())
assert response_data["status"] == JSendStatus.SUCCESS
assert response_data["data"]["issue"]["id"] == issue.id
async def test_get_issues(self, client, random_admin):
schema = JSendSchema.of(issues=Many(IssueSchema()))
await open_issue(random_admin, "test issue!")
resp = await client.get(
'/api/v1/issues',
headers={"Authorization": f"Bearer {random_admin.firebase_id}"})
data = schema.load(await resp.json())
assert len(data["data"]["issues"]) == 1
class ReservationView(BaseView):
"""
Gets or updates a single reservation.
"""
url = "/reservations/{id}"
name = "reservation"
with_reservation = match_getter(get_reservation, 'reservation', rid="id")
with_user = match_getter(get_user, 'user', firebase_id=GetFrom.AUTH_HEADER)
@with_user
@with_reservation
@docs(summary="Get A Reservation")
@requires(UserIsAdmin() | UserOwnsReservation())
@returns(JSendSchema.of(reservation=ReservationSchema()))
async def get(self, reservation: Reservation, user):
return {
"status": JSendStatus.SUCCESS,
"data": {"reservation": reservation.serialize(self.request.app.router, self.reservation_manager)}
}
@with_user
@with_reservation
@docs(summary="Delete A Reservation")
@requires(UserIsAdmin() | UserOwnsReservation())
@returns(
already_ended=(JSendSchema(), web.HTTPBadRequest),
cancelled=JSendSchema.of(reservation=ReservationSchema()),
)
async def delete(self, reservation: Reservation, user):
if reservation.outcome is not None:
return "already_ended", {
"status": JSendStatus.FAIL,
"data": {"message": "The requested rental cannot be cancelled because it is not currently active."}
}
await self.reservation_manager.cancel(reservation)
return "cancelled", {
"status": JSendStatus.SUCCESS,
"data": {"reservation": reservation.serialize(self.request.app.router, self.reservation_manager)}
}
class BikeIssuesView(BaseView):
url = f"/bikes/{{identifier:{BIKE_IDENTIFIER_REGEX}}}/issues"
with_issues = match_getter(partial(get_issues, is_active=True),
'issues',
bike=('identifier', str))
with_bike = match_getter(get_bike, 'bike', identifier=('identifier', str))
with_user = match_getter(get_user, "user", firebase_id=GetFrom.AUTH_HEADER)
@with_issues
@with_user
@docs(summary="Get All Open Issues On Bike")
@requires(UserIsAdmin())
@returns(JSendSchema.of(issues=Many(IssueSchema())))
async def get(self, issues: List[Issue], user):
return {
"status": JSendStatus.SUCCESS,
"data": {
"issues":
[issue.serialize(self.request.app.router) for issue in issues]
}
}
@with_user
@with_bike
@docs(summary="Open A New Issue About Bike")
@expects(IssueSchema(only=('description', )))
@returns(
JSendSchema.of(issue=IssueSchema(only=('id', 'user_id', 'user_url',
'bike_identifier',
'description', 'opened_at'))))
async def post(self, user, bike):
issue = await open_issue(
description=self.request["data"]["description"],
user=user,
bike=bike)
return {
"status": JSendStatus.SUCCESS,
"data": {
"issue": issue.serialize(self.request.app.router)
}
}
async def test_get_pickup_reservations(self, client, random_pickup_point,
reservation_manager, random_admin):
await reservation_manager.reserve(
random_admin, random_pickup_point,
datetime.now(timezone.utc) + timedelta(hours=4))
response = await client.get(
f'/api/v1/pickups/{random_pickup_point.id}/reservations',
headers={"Authorization": f"Bearer {random_admin.firebase_id}"})
response_data = JSendSchema.of(
reservations=Many(ReservationSchema())).load(await response.json())
assert len(response_data["data"]["reservations"]) == 1
class UserView(BaseView):
"""
Gets, replaces or deletes a single user.
"""
url = f"/users/{{id:{USER_IDENTIFIER_REGEX}}}"
name = "user"
with_user = match_getter(get_user, 'user', user_id='id')
@with_user
@docs(summary="Get A User")
@requires(UserMatchesToken() | UserIsAdmin())
@expects(None)
@returns(JSendSchema.of(user=UserSchema()))
async def get(self, user: User):
return {
"status": JSendStatus.SUCCESS,
"data": {
"user": user.serialize()
}
}
@with_user
@docs(summary="Replace A User")
@requires(UserMatchesToken() | UserIsAdmin())
@expects(UserSchema(only=('first', 'email')))
@returns(JSendSchema.of(user=UserSchema()))
async def put(self, user: User):
user = await update_user(user, **self.request["data"])
return {"status": JSendStatus.SUCCESS, "data": {"user": user}}
@with_user
@docs(summary="Delete A User")
@requires(UserMatchesToken() | UserIsAdmin())
async def delete(self, user: User):
if user.can_pay:
await self.payment_manager.delete_customer(user)
await delete_user(user)
raise web.HTTPNoContent
class UsersView(BaseView):
"""
Gets or adds to the list of users.
"""
url = "/users"
name = "users"
with_user = match_getter(get_user, 'user', firebase_id=GetFrom.AUTH_HEADER)
@with_user
@docs(summary="Get All Users")
@requires(UserIsAdmin())
@expects(None)
@returns(JSendSchema.of(users=Many(UserSchema())))
async def get(self, user):
return {
"status": JSendStatus.SUCCESS,
"data": {
"users": await get_users()
}
}
@docs(summary="Create A User")
@requires(ValidToken())
@expects(UserSchema(only=('first', 'email')))
@returns(JSendSchema.of(user=UserSchema()))
async def post(self):
"""
Anyone who has already authenticated with firebase can then create a user in the system.
This must be done before you use the rest of the system, but only has to be done once.
"""
try:
user = await create_user(**self.request["data"],
firebase_id=self.request["token"])
except UserExistsError:
user = await get_user(firebase_id=self.request["token"])
user = await update_user(user, **self.request["data"])
return {"status": JSendStatus.SUCCESS, "data": {"user": user}}
async def test_create_pickup_reservation(self, client, random_pickup_point,
reservation_manager, random_user):
request_data = CreateReservationSchema().dump(
{"reserved_for": datetime.now(timezone.utc) + timedelta(hours=4)})
response = await client.post(
f"/api/v1/pickups/{random_pickup_point.id}/reservations",
headers={"Authorization": f"Bearer {random_user.firebase_id}"},
json=request_data)
response_data = JSendSchema.of(reservation=ReservationSchema()).load(
await response.json())
assert response_data["data"]["reservation"][
"user_id"] == random_user.id
async def test_get_rentals(self, client: TestClient, random_admin,
random_bike):
"""Assert that you can get a list of all rentals."""
await client.app["rental_manager"].create(random_admin, random_bike)
response = await client.get(
'/api/v1/rentals',
headers={"Authorization": f"Bearer {random_admin.firebase_id}"})
response_schema = JSendSchema.of(rentals=Many(RentalSchema()))
response_data = response_schema.load(await response.json())
assert response_data["status"] == JSendStatus.SUCCESS
assert len(response_data["data"]["rentals"]) == 1
rental = response_data["data"]["rentals"][0]
assert rental["bike_identifier"] == random_bike.identifier
assert (await client.get(rental["bike_url"])).status != 404
class CurrentReportView(BaseView):
url = f"/report/current"
@docs(summary="Get Current Report")
@returns(JSendSchema.of(
current_rentals=fields.Integer(),
current_reservations=fields.Integer(),
current_shortages=fields.Integer(),
connected_bikes=fields.Integer(),
active_bikes=fields.Integer(),
active_issues=fields.Integer(),
average_issue_resolution_time=fields.TimeDelta()
))
async def get(self):
"""
Retrieves some statistics about the system as it is now.
"""
current_rentals = len(self.rental_manager._active_rentals)
current_reservations = len(self.reservation_manager.reservations)
connected_bikes = len(self.bike_connection_manager._bike_connections)
active_bikes = Counter(self.bike_connection_manager._bike_locked.values())[False]
current_shortages = 0
for count, date in self.reservation_sourcer.shortages().values():
current_shortages += count
active_issues = 0
closed_issues = 0
issue_time = timedelta()
async for issue in Issue.all():
if issue.status != IssueStatus.CLOSED:
active_issues += 1
else:
closed_issues += 1
issue_time += issue.closed_at - issue.opened_at
return {
"status": JSendStatus.SUCCESS,
"data": {
"current_rentals": current_rentals,
"current_reservations": current_reservations,
"current_shortages": current_shortages,
"connected_bikes": connected_bikes,
"active_bikes": active_bikes,
"active_issues": active_issues,
"average_issue_resolution_time": issue_time / closed_issues if closed_issues > 0 else None,
}
}
async def test_get_rental(self, client: TestClient, random_admin,
random_bike):
"""Assert that you get gets a single rental from the system."""
rental, location = await client.app["rental_manager"].create(
random_admin, random_bike)
response = await client.get(
f'/api/v1/rentals/{rental.id}',
headers={"Authorization": f"Bearer {random_admin.firebase_id}"})
response_schema = JSendSchema.of(rental=RentalSchema())
response_data = response_schema.load(await response.json())
assert response_data["status"] == JSendStatus.SUCCESS
assert response_data["data"]["rental"]["id"] == rental.id
assert response_data["data"]["rental"][
"bike_identifier"] == random_bike.identifier
assert (await client.get(response_data["data"]["rental"]["bike_url"]
)).status != 404
class IssuesView(BaseView):
"""
Gets the list of issues or adds a new issue.
"""
url = "/issues"
with_issues = match_getter(partial(get_issues, is_active=True), "issues")
with_admin = match_getter(get_user, "user", firebase_id=GetFrom.AUTH_HEADER)
@with_admin
@with_issues
@docs(summary="Get All Issues")
@requires(UserIsAdmin())
@returns(JSendSchema.of(issues=Many(IssueSchema(exclude=('user', 'bike')))))
async def get(self, user, issues: List[Issue]):
return {
"status": JSendStatus.SUCCESS,
"data": {"issues": [issue.serialize(self.request.app.router) for issue in issues]}
}
class ReservationsView(BaseView):
"""
Gets the list of reservations.
"""
url = "/reservations"
with_user = match_getter(get_user, 'user', firebase_id=GetFrom.AUTH_HEADER)
@with_user
@docs(summary="Get All Reservations")
@requires(UserIsAdmin())
@returns(JSendSchema.of(reservations=Many(ReservationSchema())))
async def get(self, user):
return {
"status": JSendStatus.SUCCESS,
"data": {"reservations": [
reservation.serialize(self.request.app.router, self.reservation_manager) for reservation in
await get_reservations()
]}
}
class UserCurrentRentalView(BaseView):
"""
Gets or ends the user's current rental.
"""
url = f"/users/{{id:{USER_IDENTIFIER_REGEX}}}/rentals/current"
name = "user_current_rental"
with_user = match_getter(get_user, 'user', user_id='id')
@with_user
@docs(summary="Get Current Rental For User")
@requires(UserMatchesToken() | UserIsAdmin())
@returns(no_rental=(JSendSchema(), web.HTTPNotFound),
rental_exists=JSendSchema.of(rental=CurrentRentalSchema(
only=('id', 'bike_identifier', 'bike_url', 'user_id',
'user_url', 'start_time', 'is_active',
'estimated_price', 'start_location',
'current_location'))))
async def get(self, user: User):
if not self.rental_manager.has_active_rental(user):
return "no_rental", {
"status": JSendStatus.FAIL,
"data": {
"message": f"You have no current rental."
}
}
current_rental, start_location, current_location = await self.rental_manager.active_rental(
user, with_locations=True)
return "rental_exists", {
"status": JSendStatus.SUCCESS,
"data": {
"rental":
await
current_rental.serialize(self.rental_manager,
self.bike_connection_manager,
self.reservation_manager,
self.request.app.router,
start_location=start_location,
current_location=current_location)
}
}
async def test_get_bikes_in_pickup(self, client,
random_pickup_point: PickupPoint,
bike_connection_manager):
bike1 = await Bike.create(public_key_hex="abcdef")
bike2 = await Bike.create(public_key_hex="badcfe")
await bike_connection_manager.update_location(bike1,
location=Point(100, 100))
await bike_connection_manager.update_location(
bike1, location=random_pickup_point.area.centroid)
await bike_connection_manager.update_location(bike2,
location=Point(100, 100))
response = await client.get(
f'/api/v1/pickups/{random_pickup_point.id}/bikes')
schema = JSendSchema.of(bikes=Many(BikeSchema()))
data = schema.load(await response.json())
assert data["status"] == JSendStatus.SUCCESS
assert len(data["data"]["bikes"]) == 1
assert data["data"]["bikes"][0]["public_key"] == b'\xab\xcd\xef'
class PickupShortagesView(BaseView):
"""
Gets all pickup points with shortages.
"""
url = "/pickups/shortages"
with_user = match_getter(get_user, "user", firebase_id=GetFrom.AUTH_HEADER)
@with_user
@requires(UserIsAdmin())
@returns(JSendSchema.of(pickups=Many(PickupPointSchema())))
async def get(self, user: User):
shortages = self.reservation_sourcer.shortages()
return {
"status": JSendStatus.SUCCESS,
"data": {
"pickups": [
pickup.serialize(self.reservation_manager, count, date)
for pickup, (count, date) in shortages.items()
]
}
}
class PickupBikesView(BaseView):
"""
Gets list of bikes currently at a pickup point.
"""
url = f"/pickups/{{id:{PICKUP_IDENTIFIER_REGEX}}}/bikes"
with_pickup = match_getter(get_pickup_point, 'pickup', pickup_id='id')
@with_pickup
@docs(summary="Get All Bikes In Pickup Point")
@returns(JSendSchema.of(bikes=Many(BikeSchema())))
async def get(self, pickup: PickupPoint):
return {
"status": JSendStatus.SUCCESS,
"data": {
"bikes": [
bike.serialize(self.bike_connection_manager,
self.rental_manager,
self.reservation_manager) for bike in await
self.reservation_manager.available_bikes(pickup)
]
}
}