def get_place_trip_geoquery(geojson):
if geojson is not None:
place_gq = estg.GeoQuery(loc_field_list=['data.location'],
poly_region=geojson)
trip_gq = estg.GeoQuery(
loc_field_list=['data.start_loc', 'data.end_loc'],
poly_region=geojson)
else:
place_gq = None
trip_gq = None
return (place_gq, trip_gq)
def count_query():
edb.pm_address = request.json['pm_address']
# Dummy id used as a placeholder. It must be consistent for each user but
# otherwise doesn't matter. An optimization would remove all instance of user_uuid.
user_uuid = request.json['uuid']
query = request.json['query']
query_obj = saq.AE(1)
cost = query_obj.generate_diff_priv_cost(query['alpha'], query['offset'])
# Try and deduce from the privacy budget
available_budget = safmt.deduct_budget(edb.pm_address, cost)
if not available_budget:
# Query could not complete, no budget remaining
return {"success": False}
start_time = query['start_ts']
end_time = query['end_ts']
time_query = estt.TimeQuery("data.ts", start_time, end_time)
region = query['sel_region']
if region is None:
geo_query = None
else:
geo_query = estg.GeoQuery(["data.loc"], region)
loc_entry_list = esda.get_entries(esda.CLEANED_LOCATION_KEY, user_uuid,
time_query=time_query, geo_query=geo_query)
convert_objectid_to_string(loc_entry_list)
if len(loc_entry_list) > 0:
ret_val = 1
else:
ret_val = 0
return {"success" : True, "results": ret_val}
def range_mode_heatmap(user_uuid, modes, time_query, region):
if region is None:
geo_query = None
else:
geo_query = estg.GeoQuery(["data.loc"], region)
extra_query_list = []
if modes is not None:
mode_enum_list = [ecwm.MotionTypes[mode] for mode in modes]
extra_query_list.append(esdlq.get_mode_query(mode_enum_list))
loc_entry_list = esda.get_entries(esda.CLEANED_LOCATION_KEY,
user_id=user_uuid,
time_query=time_query,
geo_query=geo_query,
extra_query_list=extra_query_list)
return {"lnglat": [e.data.loc.coordinates for e in loc_entry_list]}
def range_mode_heatmap(modes, from_ld, to_ld, region):
time_query = esttc.TimeComponentQuery("data.local_dt", from_ld, to_ld)
if region is None:
geo_query = None
else:
geo_query = estg.GeoQuery(["data.loc"], region)
if modes is None:
extra_query_list = None
else:
mode_enum_list = [ecwm.MotionTypes[mode] for mode in modes]
extra_query_list = [esdlq.get_mode_query(mode_enum_list)]
loc_entry_list = esda.get_entries(esda.CLEANED_LOCATION_KEY,
user_id=None,
time_query=time_query,
geo_query=geo_query,
extra_query_list=extra_query_list)
return {"lnglat": [e.data.loc.coordinates for e in loc_entry_list]}
def Berkeley_pop_route(start_ts, end_ts):
berkeley_json = {
"geometry": {
"type":
"Polygon",
"coordinates":
[[[-122.267443, 37.864693], [-122.267443, 37.880687],
[-122.250985, 37.880687], [-122.250985, 37.864693],
[-122.267443, 37.864693]]]
}
}
# box = [ [-122.267443, 37.864693], [-122.250985, 37.880687] ]
start_dt = esdl.get_local_date(start_ts, "UTC")
end_dt = esdl.get_local_date(end_ts, "UTC")
time_query = esttc.TimeComponentQuery("data.ts", start_dt, end_dt)
geo_query = estg.GeoQuery(["data.loc"], berkeley_json)
loc_entry_list = esda.get_entries(esda.CLEANED_LOCATION_KEY,
user_id=None,
time_query=time_query,
geo_query=geo_query)
return {"lnglat": [e.data.loc.coordinates for e in loc_entry_list]}
def incident_heatmap(user_uuid, modes, time_query, region):
"""
Return a list of geojson points with properties for the time and the stress level
related to incidents. This should not return full entries because that can
expose the user_id in the aggregate case. Maybe it can return the data part only?
Or should we put the other entries into the properties?
:param modes: The modes that we want to query for
:param time_query: The time query, in either local date or timestamp
:param region: The region of interest
:return: list of `incident` objects, with all metadata stripped out
"""
if region is None:
geo_query = None
else:
geo_query = estg.GeoQuery(["data.loc"], region)
extra_query_list = []
if modes is not None:
mode_enum_list = [ecwm.MotionTypes[mode] for mode in modes]
extra_query_list.append(esdlq.get_mode_query(mode_enum_list))
if user_uuid is None:
incident_entry_list = esda.get_entries(
MANUAL_INCIDENT_KEY,
user_id=None,
time_query=time_query,
geo_query=geo_query,
extra_query_list=extra_query_list)
else:
# We don't support aggregate queries on the usercache. And that is
# actually fine, because we don't expect immediate results for the
# aggregate case. We just want to query the usercache to ensure that
# the incidents don't magically disappear just because they got pushed
# to the server but are not yet processed
incident_entry_list = estc.find_entries([MANUAL_INCIDENT_KEY],
time_query)
return {"incidents": [e.data for e in incident_entry_list]}
def uuid_list_query(modes, time_query, region):
if region is None:
geo_query = None
else:
geo_query = estg.GeoQuery(["data.loc"], region)
extra_query_list = []
if modes is not None:
mode_enum_list = [ecwm.MotionTypes[mode] for mode in modes]
extra_query_list.append(esdlq.get_mode_query(mode_enum_list))
loc_entry_df = esda.get_data_df(esda.CLEANED_LOCATION_KEY,
user_id=None,
time_query=time_query,
geo_query=geo_query,
extra_query_list=extra_query_list)
if len(loc_entry_df) == 0:
logging.info("No points found matching query, returning empty list")
return []
unique_uuid_list = loc_entry_df.user_id.unique().tolist()
logging.info("Found %d points with %d unique uuids" %
(len(loc_entry_df), len(unique_uuid_list)))
return unique_uuid_list