def run_orbit_group(ride_requests: dict):
""" Create an orbit and group ride requests into the orbit.
:param ride_requests: ride requests to place in the same orbit.
:return: ride requests that could not be joined
"""
assert len(ride_requests) != 0
event_ids: set = {r.event_ref.id for rid, r in ride_requests.items()}
assert len(event_ids) == 1
event_ref = EventDao().get_ref(event_ids.pop())
orbit = Orbit.from_dict({
"orbitCategory": "airportRide",
"eventRef": event_ref,
"userTicketPairs": {
},
"chatroomRef": None,
"costEstimate": 987654321,
"status": 1
})
orbit_ref = OrbitDao().create(orbit)
orbit.set_firestore_ref(orbit_ref)
event = EventDao().get(event_ref)
location_ref: DocumentReference = event.location_ref
location = LocationGenericDao().get(location_ref)
ride_request_refs = [r.get_firestore_ref() for rid, r in ride_requests.items()]
transaction = db.transaction()
# TODO: implement and call validate_entities_not_changed
not_joined = _add_to_group(transaction, orbit_ref, ride_request_refs, event_ref, location_ref)
return not_joined
def test_create_fb_event(self):
ref = EventDao().create_fb_event(self.fb_event)
print(ref)
self.assertIsNotNone(ref)
ref2 = EventDao().create_fb_event(self.fb_event)
self.assertEqual(
ref.id, ref2.id, "The document id should be the same"
"when storing the same facebook event twice")
def setUp(self):
self.refs_to_delete = list()
event_dict = getEventDict(use_firestore_ref=True,
to_earliest=1545033600,
to_latest=1545119999,
from_earliest=1545033600,
from_latest=1545119999)
self.event = Event.from_dict(event_dict)
main.app.testing = True
self.app = main.app.test_client()
self.userId = "testuid1"
self.c = scripts.SetUpTestDatabase()
self.c.clear_before()
self.c.generate_test_data(start_string="2018-12-17T08:00:00.000", num_days=5)
# Populate location
location_ref = event_dict["locationRef"]
location_d = getLocationDict(location_category="social")
location = Location.from_dict(location_d)
LocationGenericDao().set(location, location_ref)
self.refs_to_delete.append(location_ref)
event_ref: firestore.DocumentReference = EventDao().create(self.event)
self.event.set_firestore_ref(event_ref)
self.refs_to_delete.append(event_ref)
self.event_id = event_ref.id
def get_event_ref_by_id(event_id: str) -> DocumentReference:
"""
This method returns the event_ref by event_id.
:param event_id:
:return: DocumentReference of the event.
"""
return EventDao().get_ref(event_id)
def find_event(flight_local_time) -> DocumentReference:
""" Description
1. Find event reference by querying events with flightLocalTime
2. Return the reference of such event
:param flight_local_time:
:return:
"""
# Parse the flightLocalTime of the ride request form, then query database
# event_time = local_time_as_timestamp(flight_local_time)
event_date_str = local_time_as_date_str(flight_local_time)
# eventReference = EventDao().locateAirportEvent(eventTime)
event = EventDao().find_by_date_str(event_date_str, "airport")
return event.get_firestore_ref()
def _create_social_event_ride_request(args, user_id):
""" Creates an social event ride request with arguments received by REST API endpoint
:param args: argument dict returned by .parse_args() from a reqparse object
:param user_id: user id
:return: RideRequest object
"""
builder = SocialEventRideRequestBuilder()
ride_request: SocialEventRideRequest = builder \
.set_with_form_and_user_id(args, user_id) \
.build_social_event_ride_request() \
.export_as_class(SocialEventRideRequest)
print(ride_request.location_ref)
location = LocationGenericDao().get(ride_request.location_ref)
event = EventDao().get(ride_request.event_ref)
# Do Validation Tasks before saving rideRequest
# 1. Check that rideRequest is not submitted by the same user
# for the flight on the same day already
# TODO: move to transactional logic for better atomicity
if utils.check_duplicate(ride_request.user_id, ride_request.event_ref):
raise service_errors.RequestAlreadyExistsError
# Starts database operations to (save rideRequest and update user's eventSchedule)
transaction = db.transaction()
# Transactional business logic for adding rideRequest
utils.add_ride_request(transaction, ride_request, location, user_id, event)
# Save write result
transaction.commit()
return ride_request
def testFindByTimestamp(self):
"""
Deprecated (event model has changed)
:return:
"""
def setUp(self):
eventRef: firestore.DocumentReference = EventDao().create(
self.event)
self.event.set_firestore_ref(eventRef)
self.refs_to_delete.append(eventRef)
self.event_id = eventRef.id
setUp(self)
# Monday, December 17, 2018 3:00:00 PM GMT-08:00 = 1545087600
event: Event = EventDao().find_by_timestamp(1545087600,
category="airport")
self.assertNotEqual(None, event)
# self.assertEquals(event.startTimestamp, 1546502400)
assert isinstance(event, AirportEvent)
self.assertEqual(event.local_date_string, "2018-12-17")
self.assertEqual(event.event_category, "airport")
self.assertEqual(event.airport_code, "LAX")
self.assertEquals(self.event_id, event.get_firestore_ref().id)
def testHasDuplicateEvent(self):
userId: str = "44lOjfDJoifnq1IMRdk4VKtPutF3"
eventId: str = "8GKfUA2AbGCrgRo7n6Rt"
eventRef: firestore.DocumentReference = EventDao().get_ref(eventId)
result = check_duplicate(userId, eventRef)
# Assert that check_duplicate is False since we have an entry
# with equal eventRef and userId field in the database
self.assertNotEqual(result, False)
def _build_event_with_id(self):
"""
TODO: change to event id
:return:
"""
event = EventDao().get_by_id(self.event_id)
self.event = event
def populate_events(start_string="2018-12-07T08:00:00.000", num_days=35, event_category="airport"):
start_datetime = generateStartDatetime(start_string)
timestamp_tuple_list = generateTimestamps(start_datetime, num_days)
assert event_category == "airport" or event_category == "campus"
event_list = generate_airport_events(timestamp_tuple_list) if event_category == "airport" else generate_uc_events(
timestamp_tuple_list)
for event in event_list:
event_ref = EventDao().create(event)
print(event_ref)
def testGet(self):
def setUp(self):
eventRef: firestore.DocumentReference = EventDao().create(
self.event)
self.event.set_firestore_ref(eventRef)
self.refs_to_delete.append(eventRef)
setUp(self)
event: Event = EventDao().get(self.event.get_firestore_ref())
self.assertIsNotNone(event)
def setUp(self):
event_dict = store.getEventDict(event_category="social")
event = Event.from_dict(event_dict)
event_ref = EventDao().create(event)
self.refs_to_delete.append(event_ref)
self.event_id = event_ref.id
d = store.EventRideRequestFormDictFactory().create(
event_id=self.event_id, add_earliest_latest=True)
self.user_id = 'testuserid1'
self.builder: SocialEventRideRequestBuilder = \
SocialEventRideRequestBuilder().set_with_form_and_user_id(d, user_id=self.user_id)
def testGetStrRef(self):
def setUp(self):
eventRef: firestore.DocumentReference = EventDao().create(
self.event)
self.event.set_firestore_ref(eventRef)
self.refs_to_delete.append(eventRef)
setUp(self)
path_str = "/events/" + self.event.get_firestore_ref().id
event: Event = EventDao().get(path_str)
self.assertIsNotNone(event)
def testFindByDateStr(self):
def setUp(self):
eventRef: firestore.DocumentReference = EventDao().create(
self.event)
self.event.set_firestore_ref(eventRef)
self.refs_to_delete.append(eventRef)
setUp(self)
# Monday, December 17, 2018 3:00:00 PM GMT-08:00 = 1545087600
event: Event = EventDao().find_by_date_str("2018-12-17",
category="airport")
self.assertNotEqual(None, event)
def get(self, eventId):
"""
Returns a JSON representation of an event based on a single ID.
---
tags:
- events
# operationId: find event by id
parameters:
- name: id
in: path
description: ID of the event to fetch
required: true
schema:
type: string
responses:
'200':
description: event response
default:
description: unexpected error
"""
event = EventDao().get_by_id(event_id=eventId)
event_dict = event.to_dict_view()
return event_dict
def post(self, uid):
json_data = request.get_json()
b = event_builders.FbEventBuilder()
b.build_with_fb_dict(json_data)
e: event_models.SocialEvent = b.export_as_class(event_models.SocialEvent)
# Note that e.firestore_ref will not be set by create()
ref: DocumentReference = EventDao().create_fb_event(e)
e.set_firestore_ref(ref)
dict_view = e.to_dict_view()
dict_view["eventId"] = ref.id
# TODO: add error handling
UserDao().add_user_event_dict(uid, dict_view["fbEventId"], dict_view)
return {
"id": e.get_firestore_ref().id
}
def create_fb_event(event_dict, uid) -> str:
""" Creates event from a facebook event.
:param event_dict: event json returned by Facebook graph api
:param uid: user id
:return: id of the event just created
"""
b = event_builders.FbEventBuilder()
# print(event_dict)
b.build_with_fb_dict(event_dict)
e: SocialEvent = b.export_as_class(SocialEvent)
# Note that e.firestore_ref will not be set by create()
ref = EventDao().create_fb_event(e)
e.set_firestore_ref(ref)
dict_view = e.to_dict_view()
dict_view["eventId"] = ref.id
# TODO: add error handling
UserDao().add_user_event_dict(uid, dict_view["fbEventId"], dict_view)
event_id = ref.id
return event_id
def execute(self) -> list:
"""
:return: a list of DocumentReference for documents just created
"""
refs = list()
start_datetime = generateStartDatetime(self.start_string)
timestamp_tuple_list = generateTimestamps(start_datetime, self.num_days)
event_list = generate_airport_events(timestamp_tuple_list) \
if self.event_category == "airport" \
else generate_uc_events(timestamp_tuple_list)
for event in event_list:
event_ref = EventDao().create(event)
refs.append(event_ref)
print(event_ref)
return refs
def setUp(self):
main.app.testing = True
self.app = main.app.test_client()
self.userIds = ["testuid1", "testuid2"]
self.refs_to_delete = list()
location_dict = store.getLocationDict(location_category="social")
location = Location.from_dict(location_dict)
location_ref = LocationGenericDao().insert_new(location)
self.refs_to_delete.append(location_ref)
event_dict = store.getEventDict(event_category="social")
event_dict["locationRef"] = location_ref
event = Event.from_dict(event_dict)
event_ref = EventDao().create(event)
self.refs_to_delete.append(event_ref)
event_id = event_ref.id
self.d = store.EventRideRequestFormDictFactory().create(
event_id=event_id)
self.ride_request_ids_to_delete = list()
def put(self, uid):
json_data = request.get_json()
event_dicts = json_data["data"]
ids = list()
for event_dict in event_dicts:
b = event_builders.FbEventBuilder()
# print(event_dict)
b.build_with_fb_dict(event_dict)
e: event_models.SocialEvent = b.export_as_class(event_models.SocialEvent)
# Note that e.firestore_ref will not be set by create()
ref = EventDao().create_fb_event(e)
e.set_firestore_ref(ref)
dict_view = e.to_dict_view()
dict_view["eventId"] = ref.id
# TODO: add error handling
UserDao().add_user_event_dict(uid, dict_view["fbEventId"], dict_view)
ids.append(ref.id)
return {
"ids": ids
}
def _get_event(transaction: Transaction = None,
event_id: str = None) -> Type[Event]:
event_ref = EventDao().get_ref(event_id)
return EventDao().get_with_transaction(transaction, event_ref)
def setUp(self):
eventRef: firestore.DocumentReference = EventDao().create(
self.event)
self.event.set_firestore_ref(eventRef)
self.refs_to_delete.append(eventRef)
def get(self, eventId):
event = EventDao().get_by_id(event_id=eventId)
event_dict = event.to_dict_view()
return event_dict
def testCreate(self):
eventRef: firestore.DocumentReference = EventDao().create(self.event)
self.event.set_firestore_ref(eventRef)
print("eventRef = {}".format(eventRef))
def post(self, uid):
"""
Creates a new event with Facebook event JSON (that is obtained from Facebook Graph API).
---
tags:
- events
parameters:
- in: body
name: body
schema:
id: UserEventJSON
type: object
required:
- description
- end_time
- start_time
- place
- id
properties:
description:
type: string
example: "Advance Sale begins Friday, 6/1 at 11AM PDT\nwww.coachella.com"
end_time:
type: string
example: "2019-04-14T23:59:00-0700"
start_time:
type: string
example: "2019-04-12T12:00:00-0700"
place:
type: object
properties:
name:
type: string
example: "Coachella"
location:
type: object
properties:
latitude:
type: number
example: 33.679974
longitude:
type: number
example: -116.237221
id:
example: "20281766647"
id:
type: string
example: "137943263736990"
responses:
200:
description: user created
400:
description: form fields error
:param uid:
:return:
"""
json_data = request.get_json()
b = event_builders.FbEventBuilder()
b.build_with_fb_dict(json_data)
e: event_models.SocialEvent = b.export_as_class(event_models.SocialEvent)
# Note that e.firestore_ref will not be set by create()
ref: DocumentReference = EventDao().create_fb_event(e)
e.set_firestore_ref(ref)
dict_view = e.to_dict_view()
dict_view["eventId"] = ref.id
# TODO: add error handling
UserDao().add_user_event_dict(uid, dict_view["fbEventId"], dict_view)
return {
"id": e.get_firestore_ref().id
}
