def generate_ride_request() -> Type[RideRequest]:
ride_request_dict = store.getMockRideRequest(returnDict=True)
ride_request = RideRequest.from_dict(ride_request_dict)
RideRequestGenericDao().create(ride_request)
RideRequestGenericDao().set(ride_request)
# ref = ride_request.get_firestore_ref()
return ride_request
def remove_match_tmp(ride_request_id):
ride_request_ref = RideRequestGenericDao(
).rideRequestCollectionRef.document(ride_request_id)
ride_request = RideRequestGenericDao().get(ride_request_ref)
orbit_ref = ride_request.orbit_ref
orbit = OrbitDao().get(orbit_ref)
group_actions.remove_from_orbit(ride_request, orbit)
def testSet(self):
rideRequestDict = self.rideRequestData1
rideRequest = RideRequest.from_dict(rideRequestDict)
RideRequestGenericDao().create(rideRequest)
RideRequestGenericDao().set(rideRequest)
ref = rideRequest.get_firestore_ref()
print(ref)
self.toDelete.append(ref)
d = RideRequestGenericDao().get(ref)
self.assertEqual(rideRequestDict, d.to_dict())
def add_luggage_nontransactional(rideRequestId, luggages):
"""
Add luggage to a rideRequest without a transaction (non-atomic). Using this method may result in modifications
done to rideRequest to be overridden.
:param rideRequestId:
:return:
"""
rideRequest = RideRequestGenericDao().get_by_id(rideRequestId)
rideRequest.baggages = luggages.to_dict()
RideRequestGenericDao().set(rideRequest)
def _put_luggages_transactional(transaction: Transaction, ride_request_id,
luggages: Luggages):
ride_request_ref = RideRequestGenericDao().ref_from_id(ride_request_id)
ride_request = RideRequestGenericDao().get_with_transaction(
transaction=transaction, rideRequestRef=ride_request_ref)
ride_request.baggages = luggages.to_dict()
RideRequestGenericDao().set_with_transaction(
transaction=transaction,
rideRequestRef=ride_request_ref,
newRideRequest=ride_request)
def _get_ride_requests(transaction: Transaction = None,
ids: set = None) -> dict:
if ids is None:
return dict()
else:
refs = [RideRequestGenericDao().ref_from_id(rid) for rid in ids]
ride_requests = {
ref.id:
RideRequestGenericDao.get_with_transaction(transaction, ref)
for ref in refs
}
return ride_requests
def post(self, rideRequestId):
ride_request_id = rideRequestId
ride_request_ref = RideRequestGenericDao(
).rideRequestCollectionRef.document(ride_request_id)
r = RideRequestGenericDao().get(ride_request_ref)
location_ref = r.airport_location
actions.drop_group({ride_request_id},
orbit_id=r.orbit_ref.id,
event_id=r.event_ref.id,
location_id=location_ref.id)
response_dict = {"success": True}
return response_dict, 200
def get(self):
"""
Triggers an automatic grouping for all incomplete requests. \
(temporary: will migrate to other ways to trigger grouping) \
Can only be called by google cloud cron tasks.
---
tags:
- groupAll
# operationId: find ride request by id
responses:
'200':
description: successful operation
properties:
success:
type: boolean
example: true
operationMode:
type: string
example: all
'403':
description: Unauthorized. This resource must be run with Appengine-Cron.
default:
description: unexpected error
"""
all_ride_request_ids = RideRequestGenericDao().get_ids(incomplete=True)
actions.group_many(all_ride_request_ids)
response_dict = {"success": True, "operationMode": "all"}
return response_dict, 200
def separate_by_event_id_and_direction(
ride_request_ids: List[str]) -> Dict[Tuple, List[Type[RideRequest]]]:
""" Returns a dict with event id as key and ride request object as value
:param ride_request_ids: a list of ride requests from any number of events
"""
d = dict()
event_ids = list()
for ride_request_id in ride_request_ids:
ride_request = RideRequestGenericDao().get_by_id(ride_request_id)
# Do not add to rideRequests queue if the request is complete
if ride_request.request_completion:
continue
event_id = ride_request.event_ref.id
if event_id not in event_ids:
event_ids.append(event_id)
d[(event_id,
True)] = list() # event_id = event_id and to_event=True
d[(event_id,
False)] = list() # event_id = event_id and to_event=False
d[(event_id, ride_request.target.to_event)].append(ride_request)
return d
def post(self):
request_json = request.get_json()
request_form = json.loads(request_json) if (
type(request_json) != dict) else request_json
operation_mode = request_form.get("operationMode", None)
ride_request_ids = request_form.get("rideRequestIds", None)
response_dict = None
if operation_mode == "two" and ride_request_ids is not None:
response_dict = actions.group_two(ride_request_ids)
elif operation_mode == "many" and ride_request_ids is not None:
actions.group_many(ride_request_ids)
response_dict = {"success": True, "operationMode": "many"}
elif operation_mode == "all":
all_ride_request_ids = RideRequestGenericDao().get_ids(
incomplete=True)
actions.group_many(all_ride_request_ids)
response_dict = {"success": True, "operationMode": "all"}
else:
response_dict = {"error": "Not specified operation mode."}
return response_dict, 400
# return rideRequest.get_firestore_ref().id, 200
return response_dict, 200
def refreshGroupAll():
""" Description
This function corresponds to use case "grouping ride requests".
:return:
"""
allRideRequestIds = RideRequestGenericDao().get_ids(incomplete=True)
actions.group_many(allRideRequestIds)
def post(self):
request_json = request.get_json()
request_form = json.loads(request_json) if (
type(request_json) != dict) else request_json
ride_request_id = request_form.get("rideRequestId", None)
ride_request_ref = RideRequestGenericDao(
).rideRequestCollectionRef.document(ride_request_id)
r = RideRequestGenericDao().get(ride_request_ref)
location_ref = r.airport_location
actions.drop_group({ride_request_id},
orbit_id=r.orbit_ref.id,
event_id=r.event_ref.id,
location_id=location_ref.id)
response_dict = {"success": True}
return response_dict, 200
def delete(self, rideRequestId, uid):
"""
Replaces POST "/deleteRideRequest"
:param rideRequestId:
:param uid:
:return:
"""
user_id = uid
user_ref = UserDao().get_ref(user_id)
ride_request_ref = RideRequestGenericDao(
).rideRequestCollectionRef.document(rideRequestId)
response_dict = {}
ride_request = RideRequestGenericDao().get(ride_request_ref)
event_id = ride_request.event_ref.id
print("userId: {}, rideRequestId: {}, eventId: {}".format(
user_id, rideRequestId, event_id))
# Validate that the ride request is not matched to an orbit
request_completion = ride_request.request_completion
if request_completion:
raise service_errors.RequestAlreadyMatchedError
try:
# Delete in User's Event Schedule
EventScheduleGenericDao(
userRef=user_ref).delete_event_by_id(event_id)
# Delete in RideRequest Collection
RideRequestGenericDao().delete(ride_request_ref)
response_dict = {"success": True}
except Exception as e:
err_str = str(e)
response_dict = {
"error":
"Error occurred deleting rideRequest and eventSchedule: " +
err_str
}
print(response_dict)
return response_dict, 500
return response_dict, 200
def setUp(self):
self.c = scripts.SetUpTestDatabase()
self.c.clear_before()
self.c.generate_test_data(start_string="2018-12-17T08:00:00.000",
num_days=5)
self.maxDiff = None
self.arr = [
[
12000000, 12005000,
RideRequestGenericDao().rideRequestCollectionRef.document('A')
],
[
12000000, 12005000,
RideRequestGenericDao().rideRequestCollectionRef.document('B')
],
[
12000000, 12005000,
RideRequestGenericDao().rideRequestCollectionRef.document('C')
],
[
12005000, 12006000,
RideRequestGenericDao().rideRequestCollectionRef.document('D')
],
[
12007000, 12009000,
RideRequestGenericDao().rideRequestCollectionRef.document('E')
],
[
12009001, 12009900,
RideRequestGenericDao().rideRequestCollectionRef.document('F')
],
[
11000000, 11009000,
RideRequestGenericDao().rideRequestCollectionRef.document('G')
]
]
arr = self.arr
rideRequests = list()
for earliest, latest, firestoreRef in arr:
rideRequest = test.store.model.getMockRideRequest(
earliest=earliest,
latest=latest,
firestoreRef=firestoreRef,
userId='userIdA' if firestoreRef.id == 'A' else 'userIdBmore')
transaction = db.transaction()
RideRequestGenericDao().set_with_transaction(
transaction, rideRequest, firestoreRef)
rideRequest.set_firestore_ref(firestoreRef)
rideRequests.append(rideRequest)
self.rideRequests = rideRequests
def post(self, rideRequestId):
"""
Unmatches a ride request from an orbit.
---
tags:
- rideRequests
parameters:
- name: id
in: path
description: ID of the ride request to un-match
required: true
schema:
type: string
responses:
200:
description: Ride Request unmatched from the orbit
400:
description: Ride Request is not matched into an orbit yet
:param rideRequestId:
:return:
"""
ride_request_id = rideRequestId
ride_request_ref = RideRequestGenericDao(
).rideRequestCollectionRef.document(ride_request_id)
r = RideRequestGenericDao().get(ride_request_ref)
if not r.request_completion:
""" Returns 400 when ride request is not already matched into an orbit
"""
raise RequestNotMatchedError
location_ref = r.airport_location
actions.drop_group({ride_request_id},
orbit_id=r.orbit_ref.id,
event_id=r.event_ref.id,
location_id=location_ref.id)
response_dict = {"success": True}
return response_dict, 200
def testCreateRideRequestsTemp(self):
# Create new rideRequests
for userId in self.userIds:
form = self.d
form["testUserId"] = userId
r = self.app.post( # TODO: change everywhere to json=form (used to be json=json.dumps(form))
path='/rideRequests',
json=form,
headers=getMockAuthHeaders(userId))
print(r.json)
self.assertIn("firestoreRef", r.json.keys())
rid = r.json["id"]
ride_request = RideRequestGenericDao().get_by_id(rid)
print(ride_request.to_dict())
firestore_ref = ride_request.get_firestore_ref(
) # Not that it is actually rideRequestId
self.ride_request_ids_to_delete.append((userId, firestore_ref.id))
def get(self, rideRequestId, uid):
"""
Get the luggage JSON associated with the ride request.
---
tags:
- luggage
parameters:
- name: id
in: path
description: ID of the ride request associated with the luggages
required: true
schema:
type: string
responses:
'200':
description: luggages response
properties:
luggages:
type: array
items:
$ref: "#/definitions/LuggageItem"
default:
description: unexpected error
:param rideRequestId:
:param uid:
:return:
"""
user_id = uid
# TODO: validate that the user has permission to view the ride request
ride_request_ref = RideRequestGenericDao(
).rideRequestCollectionRef.document(rideRequestId)
ride_request = RideRequestGenericDao().get(ride_request_ref)
print("userId: {}, rideRequestId: {}".format(user_id, rideRequestId))
response_dict = ride_request.to_dict_view()["baggages"]
return response_dict, 200
def _refresh_ride_requests_all(transaction: Transaction, in_orbit: dict,
not_in_orbit: dict, orbit: Orbit, event,
location):
""" This function refreshes each rideRequests
:param transaction:
:param in_orbit:
:param not_in_orbit:
:param orbit:
:param event:
:param location:
:return:
"""
for rid, ride_request in in_orbit.items():
RideRequestGenericDao.set_with_transaction(
transaction, ride_request, ride_request.get_firestore_ref())
for rid, ride_request in not_in_orbit.items():
RideRequestGenericDao.set_with_transaction(
transaction, ride_request, ride_request.get_firestore_ref())
def _refresh_ride_requests_all(transaction: Transaction, in_orbit: dict,
not_in_orbit: dict, orbit: Orbit, event,
location):
""" Refreshes each rideRequest.
:param transaction: firestore transaction
:param in_orbit: all ride requests that are currently in the orbit
:param not_in_orbit: all ride requests that are no longer in the orbit
:param orbit: orbit object
:param event: event object
:param location: location object representing event location
:return: None
"""
for rid, ride_request in in_orbit.items():
RideRequestGenericDao.set_with_transaction(
transaction, ride_request, ride_request.get_firestore_ref())
for rid, ride_request in not_in_orbit.items():
RideRequestGenericDao.set_with_transaction(
transaction, ride_request, ride_request.get_firestore_ref())
def _get_existing_ride_requests(transaction: Transaction = None,
orbit: Orbit = None) -> dict:
refs = [
ticket["rideRequestRef"]
for user_id, ticket in orbit.user_ticket_pairs.items()
]
ride_requests = {
ref.id:
RideRequestGenericDao.get_with_transaction(transaction, ref)
for ref in refs
}
return ride_requests
def get(self, rideRequestId, uid):
"""
Get the JSON for the luggage associatedd with ride request
:param rideRequestId:
:param uid:
:return:
"""
user_id = uid
# TODO: validate that the user has permission to view the ride request
ride_request_ref = RideRequestGenericDao(
).rideRequestCollectionRef.document(rideRequestId)
ride_request = RideRequestGenericDao().get(ride_request_ref)
print("userId: {}, rideRequestId: {}".format(user_id, rideRequestId))
response_dict = ride_request.to_dict_view()["baggages"]
return response_dict, 200
def get(self, rideRequestId, uid):
"""
Get the JSON for ride request
:param rideRequestId:
:param uid:
:return:
"""
user_id = uid
# TODO: validate that the user has permission to view the ride request
ride_request_ref = RideRequestGenericDao(
).rideRequestCollectionRef.document(rideRequestId)
ride_request = RideRequestGenericDao().get(ride_request_ref)
print("userId: {}, rideRequestId: {}".format(user_id, rideRequestId))
response_dict = ride_request.to_dict_view()
response_dict["pickupAddress"] = ride_request.pickup_address
return response_dict, 200
def get(self, rideRequestId, uid):
"""
Returns a ride request based on a single ID.
---
tags:
- rideRequests
# operationId: find ride request by id
parameters:
- name: id
in: path
description: ID of the ride request to fetch
required: true
schema:
type: string
responses:
'200':
description: ride request response
default:
description: unexpected error
"""
user_id = uid
# TODO: validate that the user has permission to view the ride request
ride_request_ref = RideRequestGenericDao(
).rideRequestCollectionRef.document(rideRequestId)
ride_request = RideRequestGenericDao().get(ride_request_ref)
print("userId: {}, rideRequestId: {}".format(user_id, rideRequestId))
response_dict = ride_request.to_dict_view()
response_dict["pickupAddress"] = ride_request.pickup_address
return response_dict, 200
def group_two(ride_request_ids: list):
""" Force matches two rideRequests into an orbit.
:param ride_request_ids: Two rideRequest Ids
:return:
"""
ride_requests = [RideRequestGenericDao().get_by_id(rid) for rid in ride_request_ids]
num_ride_requests = len(ride_requests)
assert num_ride_requests >= 2
ride_requests_dict: dict = {
r.get_firestore_ref().id: r for r in ride_requests
}
not_joined_ids = run_orbit_group(ride_requests_dict)
response_dict = {"notJoined": not_joined_ids}
return response_dict
def separate_by_event_id(ride_request_ids: List[str]) -> Dict[str, List[Type[RideRequest]]]:
""" DEPRECATED
Returns a dict with event id as key and ride request object as value
:param ride_request_ids: a list of ride requests from any number of events
"""
d = dict()
for ride_request_id in ride_request_ids:
ride_request = RideRequestGenericDao().get_by_id(ride_request_id)
# Do not add to rideRequests queue if the request is complete
if ride_request.request_completion:
continue
event_id = ride_request.event_ref.id
if event_id not in d.keys():
d[event_id] = list()
d[event_id].append(ride_request)
return d
def group_all_pairs_of_event(pair_list: list) -> list:
""" Description (Experimental)
Groups all pairs of ride requests under an event
This function
1. reads all ride requests associated with an event
2. puts ride requests into groups
3. call join method on each grouping
:param pair_list: a list of all pairs of ride requests under an event
:return: a list of ride request ids not joined
"""
not_joined_all = list()
for pair in pair_list:
d = {ref.id: RideRequestGenericDao().get(ref) for ref in pair}
not_joined = run_orbit_group(d)
not_joined_all.extend(not_joined)
return not_joined_all
def testGrouping(self):
expectedPaired = [
[
RideRequestGenericDao().rideRequestCollectionRef.document('A'),
RideRequestGenericDao().rideRequestCollectionRef.document('B')
],
[
RideRequestGenericDao().rideRequestCollectionRef.document('C'),
RideRequestGenericDao().rideRequestCollectionRef.document('D')
]
]
expectedUnpaired = [
[RideRequestGenericDao().rideRequestCollectionRef.document('G')],
[RideRequestGenericDao().rideRequestCollectionRef.document('E')],
[RideRequestGenericDao().rideRequestCollectionRef.document('F')]
]
rideRequests: list = self.rideRequests
paired, unpaired = gravitate.domain.group.pairing.pair_ride_requests(
rideRequests)
self.assertListEqual(expectedPaired, paired, 'paired does not match')
self.assertListEqual(expectedUnpaired, unpaired,
'unpaired does not match')
def post(self):
"""
Matches rideRequests in ways specified in the given json
---
tags:
- groupTasks
parameters:
- in: body
name: body
schema:
id: GroupTask
required:
- operationMode
properties:
operationMode:
type: string
enum:
- two
- many
- all
rideRequestIds:
type: array
items:
name: rideRequestId
type: string
example: "riderequestid1"
responses:
'200':
description: successful operation
properties:
success:
type: boolean
example: true
operationMode:
type: string
example: all
'400':
description: unexpected error
properties:
error:
description: error message
example: "Not specified operation mode."
"""
request_json = request.get_json()
request_form = json.loads(request_json) if (
type(request_json) != dict) else request_json
operation_mode = request_form.get("operationMode", None)
ride_request_ids = request_form.get("rideRequestIds", None)
response_dict = None
if operation_mode == "two" and ride_request_ids is not None:
response_dict = actions.group_two(ride_request_ids)
elif operation_mode == "many" and ride_request_ids is not None:
actions.group_many(ride_request_ids)
response_dict = {"success": True, "operationMode": "many"}
elif operation_mode == "all":
all_ride_request_ids = RideRequestGenericDao().get_ids(
incomplete=True)
actions.group_many(all_ride_request_ids)
response_dict = {"success": True, "operationMode": "all"}
else:
response_dict = {"error": "Not specified operation mode."}
return response_dict, 400
# return rideRequest.get_firestore_ref().id, 200
return response_dict, 200
def delete(self, rideRequestId, uid):
"""
Deletes a ride request.
---
tags:
- rideRequests
parameters:
- name: id
in: path
description: ID of the ride request to delete
required: true
schema:
type: string
responses:
'200':
description: ride request deleted
default:
description: unexpected error
# content:
# application/json:
# schema:
# $ref: '#/components/schemas/Error'
"""
user_id = uid
user_ref = UserDao().get_ref(user_id)
ride_request_ref = RideRequestGenericDao(
).rideRequestCollectionRef.document(rideRequestId)
response_dict = {}
ride_request = RideRequestGenericDao().get(ride_request_ref)
event_id = ride_request.event_ref.id
print("userId: {}, rideRequestId: {}, eventId: {}".format(
user_id, rideRequestId, event_id))
# Validate that the ride request is not matched to an orbit
request_completion = ride_request.request_completion
if request_completion:
raise service_errors.RequestAlreadyMatchedError
try:
# Delete in User's Event Schedule
EventScheduleGenericDao(
userRef=user_ref).delete_event_by_id(event_id)
# Delete in RideRequest Collection
RideRequestGenericDao().delete(ride_request_ref)
response_dict = {"success": True}
except Exception as e:
err_str = str(e)
response_dict = {
"error":
"Error occurred deleting rideRequest and eventSchedule: " +
err_str
}
print(response_dict)
return response_dict, 500
return response_dict, 200 # TODO: change to 204
def testCreate(self):
rideRequestDict = self.rideRequestData1
rideRequest = RideRequest.from_dict(rideRequestDict)
RideRequestGenericDao().create(rideRequest)
resultDict = rideRequest.to_dict()
self.assertEqual(rideRequestDict, resultDict)
