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)