def __add_parking_event_to_ods(self, parking_area_id, parking_event_json):
register_number = parking_event_json['registerNumber']
self.db\
.child(ParkingEventRepository._parking_event_ODS_node_name)\
.child(parking_area_id)\
.child(register_number)\
.set(parking_event_json)
# lookup_json is the json stored in the Firebase lookup node
lookup_json = {
'registerNumber': register_number,
'parkingAreaId': parking_area_id,
'parkingAreaParkingEventId': register_number,
'timestamp': parking_event_json['timestamp']
}
if parking_event_json['parkingType'] == 'PAID':
lookup_json[
'durationEndTimestamp'] = TimeUtils.get_local_timestamp(
parking_event_json['parkingDurationInMinutes'])
self.db\
.child(ParkingEventRepository._parking_event_ODS_lookup_node_name)\
.child(register_number) \
.set(lookup_json)
add_results = {
'odsId': register_number,
'odsLookupId': register_number
}
return add_results
def store_parking_event(self, request_json, live_time):
register_number = request_json['registerNumber']
parking_context_type = request_json['parkingContextType']
timestamp = TimeUtils.get_local_timestamp()
# parking_event_json is the json stored under parkingAreaParkingEvent node
parking_event_json = {
'timestamp': timestamp,
'parkingType': parking_context_type,
'registerNumber': register_number,
}
if parking_context_type == 'PAID':
parking_area_id = request_json['parkingAreaId']
parking_event_json['parkingDurationInMinutes'] = request_json[
'parkingDurationInMinutes']
elif parking_context_type == 'PARKING_DISC':
parking_area_id = 'PARKING_DISC_AREA'
# Remove previous events from the ODS if any exist
self.__remove_parking_event_from_ods_by(register_number)
# Store the incoming event to ODS
add_results = self.__add_parking_event_to_ods(parking_area_id,
parking_event_json)
# Store notification about the event for event consumption and clean up
# > Notifications are stored in a flattened format
# > Better use of indexing for server side event consumers
notification_json = {
'parkingAreaId': parking_area_id,
'registerNumber': register_number,
'parkingEventId': add_results['odsId'],
'liveUntilTime':
TimeUtils.get_epoch_timestamp_plus_seconds(live_time),
'parkingAreaParkingEvent': parking_event_json
}
# Only PAID context events are stored long term, because they are the only
# types of events that one gets location information of.
if parking_context_type == 'PAID':
notification_json['willBeStoredToLongTermDataStore'] = True
notification_add_results = self.__add_parking_event_to_notification_store(
notification_json)
add_results['notificationId'] = notification_add_results['name']
add_results['timestamp'] = timestamp
return json.dumps(add_results)
def get_occuring_paid_event_counts(self):
now = TimeUtils.get_local_timestamp()
counts = {}
occuring_events = self.db \
.child('parkingEventLookup') \
.order_by_child('durationEndTimestamp') \
.start_at(now).end_at('9') \
.get()
occuring_events = self.db.sort(occuring_events, 'parkingAreaId')
# count currently occuring parking event amounts for each area
for k, g in groupby(occuring_events.each(),
lambda i: i.val()['parkingAreaId']):
counts[str(k)] = sum(1 for i in g)
return counts
def test_duration_timestamp(self):
"""
Test if the duration timestamps get set properly in paid parking context.
:return:
"""
# Assign
mock_now = datetime(2016, 1, 1, 1, 1, 1, 1)
with mock.patch('datetime.datetime') as dt_mock:
dt_mock.now.return_value = mock_now
self.parking_event_repo.db = MockDb().with_paid_init()
expected_parking_context_type = 'PAID'
expected_parking_duration_in_minutes = 60
request_json = TestUtils.build_request(
parking_context_type=expected_parking_context_type,
parking_duration_in_minutes=
expected_parking_duration_in_minutes,
parking_area_id=paid_parking_area_id,
payment_method_type=paid_parking_payment_method_type,
payment_receipt=paid_parking_payment_receipt)
# Act
result = self.parking_event_repo.store_parking_event(
request_json, 100)
# Assert
_, actual_event = self.parking_event_repo.db. \
get_single_event_key_and_value(paid_parking_area_id)
_, lookup = self.parking_event_repo.db \
.get_single_lookup_key_and_value(parking_disc_parking_area_id)
actual_end_timestamp = lookup['durationEndTimestamp']
expected_end_timestamp = TimeUtils.get_local_timestamp(
actual_event['parkingDurationInMinutes'])
self.assertEqual(expected_end_timestamp, actual_end_timestamp)
