def post(self):
arguments = self.request.arguments()
if 'client_mac' not in arguments or 'base_mac' not in arguments or 'ss' not in arguments:
utils.send_400(self.response, "Only pass client_mac, base_mac and ss arguments (as integers)")
return
try:
client_mac = int(self.request.get('client_mac'))
base_mac = int(self.request.get('base_mac'))
ss = int(self.request.get('ss'))
except ValueError:
utils.send_400(self.response, "Pass all arguments as integers")
return
#Calculate the location from the scan
#TODO for now we generate a random one
now = utils.now_datetime()
map_id = maps.random_map_id()
location = model.Location(map_id=map_id, x=utils.random_int(0, 300), y=utils.random_int(0, 600), timestamp=now)
location.put()
#Find out which base_station
base_station = base_stations.get_base_station_with_mac(base_mac)
#Create or update the client entry
client = clients.create_or_update_client(client_mac, base_station, now)
#Create the scan and insert it
scan = model.Scan(map_key=map_id, client=client.key(), base_ap=base_station.key(), ss=ss, timestamp=now,
location=location.key())
scan.put()
utils.send_200(self.response, "Scan and Location successfully inserted")
def post(self):
arguments = self.request.arguments()
if 'client_mac' not in arguments or 'base_mac' not in arguments or 'ss' not in arguments:
utils.send_400(
self.response,
"Only pass client_mac, base_mac and ss arguments (as integers)"
)
return
try:
client_mac = int(self.request.get('client_mac'))
base_mac = int(self.request.get('base_mac'))
ss = int(self.request.get('ss'))
except ValueError:
utils.send_400(self.response, "Pass all arguments as integers")
return
#Calculate the location from the scan
#TODO for now we generate a random one
now = utils.now_datetime()
map_id = maps.random_map_id()
location = model.Location(map_id=map_id,
x=utils.random_int(0, 300),
y=utils.random_int(0, 600),
timestamp=now)
location.put()
#Find out which base_station
base_station = base_stations.get_base_station_with_mac(base_mac)
#Create or update the client entry
client = clients.create_or_update_client(client_mac, base_station, now)
#Create the scan and insert it
scan = model.Scan(map_key=map_id,
client=client.key(),
base_ap=base_station.key(),
ss=ss,
timestamp=now,
location=location.key())
scan.put()
utils.send_200(self.response,
"Scan and Location successfully inserted")
def post(self, request, *args, **kwargs):
req_params = request.POST
mobile_number = req_params['mobile_number']
password = req_params['password']
person = Person.objects.get_person_by_num(mobile_number)
try:
if not person:
raise InvalidPerson(STR_INVALID_PERSON)
if person.user_password != gen_hash_pwd(password):
raise LoginFailed(STR_LOGIN_FAILED)
# TODO: Add it to redis and mantain session
return send_200(self.response)
except FamilyError, e:
self.response['res_str'] = str(e)
return send_400(self.response)
def post(self, request, *args, **kwargs):
req_params = request.POST
person_id = req_params['person_id']
relationship_name = req_params['relationship_name']
relation_person_id = req_params['relation_person_id']
try:
person, relationship_obj, relation_person = self._validate(
person_id, relationship_name, relation_person_id)
relative_obj = Relatives.objects.create_relatives(
relation_person, relationship_obj)
person.add_relatives(relative_obj)
return send_200(self.response)
except FamilyError, e:
self.response['res_str'] = str(e)
return send_400(self.response)
def get(self, request, *args, **kwargs):
req_params = request.POST
person_id = req_params['person_id']
relation_name = req_params['relation_name']
try:
person = Person.objects.get_person(person_id)
if not person:
raise InvalidPerson(STR_INVALID_PERSON)
relative_persons = person.search_relatives(relation_name)
person_list = []
for relative_person in relative_persons:
person_list.append(relative_person.serializer())
self.response['res_data'] = person_list
return send_200(self.response)
except FamilyError, e:
self.response['res_str'] = str(e)
return send_400(self.response)
def post(self, request, *args, **kwargs):
req_params = request.POST
first_name = req_params['first_name']
last_name = req_params['last_name']
gender = req_params['gender']
dob = req_params['dob']
email_id = req_params['email_id']
user_password = req_params['password']
mobile_number = req_params['mobile_number']
try:
self._validate(email_id, gender, mobile_number)
Person.objects.create_person(first_name, last_name, dob, gender,
mobile_number, email_id,
user_password)
return send_201(self.response)
except FamilyError, e:
self.response['res_str'] = str(e)
return send_400(self.response)
def get(self):
arguments = self.request.arguments()
try:
limit = int(self.request.get('limit', DEFAULT_LIMIT))
except ValueError:
utils.send_400(self.response, "Limit must be an integer")
return
if 't1' in arguments and 't2' in arguments:
try:
t1 = int(self.request.get('t1'))
t2 = int(self.request.get('t2'))
except ValueError:
utils.send_400(self.response, "t1 and t2 should be integers representing unix epoch in seconds")
return
[start_date, end_date] = utils.parse_timestamps(t1, t2)
query = model.Scan.all() \
.filter("timestamp >= ", start_date) \
.filter("timestamp <=", end_date) \
.order("-timestamp")
matched_scans = query.fetch(limit)
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(utils.json_encode(utils.query_to_array(matched_scans), True))
return
if 'client_mac' in arguments:
mac_string = self.request.get("client_mac")
client = clients.get_client_with_mac(utils.mac_string_to_int(mac_string))
matched_scans = []
if client is not None:
query = model.Scan.all() \
.filter("client = ", client.key()) \
.order("-timestamp")
matched_scans = query.fetch(limit)
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(utils.json_encode(utils.query_to_array(matched_scans), True))
return
if 'base_station_mac' in arguments:
base_station_mac = self.request.get("base_station_mac")
base_station = base_stations.get_base_station_with_mac(utils.mac_string_to_int(base_station_mac))
matched_scans = []
if base_station is not None:
query = model.Scan.all() \
.filter("base_station = ", base_station.key()) \
.order("-timestamp")
matched_scans = query.fetch(limit)
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(utils.json_encode(utils.query_to_array(matched_scans), True))
return
if 'map_id' in arguments:
map_id = self.request.get("map_id") #TODO check if map exists
if 'x' in arguments and 'y' in arguments and 'radius' in arguments:
try:
x = int(self.request.get('x'))
y = int(self.request.get('y'))
radius = float(self.request.get('radius'))
except ValueError:
utils.send_400(self.response, "x and y must be integers, radius must be float in meters")
return
scale = maps.get_scale(map_id)
delta = scale * radius
#TODO FOR NOW THE X/Y DISTANCE FILTERING IS VERY INEFFICIENT!!!
query = model.Scan.all() \
.filter("map_id = ", map_id) \
.filter("x <= ", x + delta) \
.filter('x >= ', x - delta)
matched_scans = query.fetch(limit)
matched_scans[:] = [scan for scan in matched_scans
if utils.point_in_circle(scan.location.x, scan.location.y, x, y, delta)]
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(utils.json_encode(utils.query_to_array(matched_scans), True))
return
def get(self):
arguments = self.request.arguments()
try:
limit = int(self.request.get('limit', DEFAULT_LIMIT))
except ValueError:
utils.send_400(self.response, "Limit must be an integer")
return
if 't1' in arguments and 't2' in arguments:
try:
t1 = int(self.request.get('t1'))
t2 = int(self.request.get('t2'))
except ValueError:
utils.send_400(
self.response,
"t1 and t2 should be integers representing unix epoch in seconds"
)
return
[start_date, end_date] = utils.parse_timestamps(t1, t2)
query = model.Scan.all() \
.filter("timestamp >= ", start_date) \
.filter("timestamp <=", end_date) \
.order("-timestamp")
matched_scans = query.fetch(limit)
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(
utils.json_encode(utils.query_to_array(matched_scans), True))
return
if 'client_mac' in arguments:
mac_string = self.request.get("client_mac")
client = clients.get_client_with_mac(
utils.mac_string_to_int(mac_string))
matched_scans = []
if client is not None:
query = model.Scan.all() \
.filter("client = ", client.key()) \
.order("-timestamp")
matched_scans = query.fetch(limit)
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(
utils.json_encode(utils.query_to_array(matched_scans), True))
return
if 'base_station_mac' in arguments:
base_station_mac = self.request.get("base_station_mac")
base_station = base_stations.get_base_station_with_mac(
utils.mac_string_to_int(base_station_mac))
matched_scans = []
if base_station is not None:
query = model.Scan.all() \
.filter("base_station = ", base_station.key()) \
.order("-timestamp")
matched_scans = query.fetch(limit)
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(
utils.json_encode(utils.query_to_array(matched_scans), True))
return
if 'map_id' in arguments:
map_id = self.request.get("map_id") #TODO check if map exists
if 'x' in arguments and 'y' in arguments and 'radius' in arguments:
try:
x = int(self.request.get('x'))
y = int(self.request.get('y'))
radius = float(self.request.get('radius'))
except ValueError:
utils.send_400(
self.response,
"x and y must be integers, radius must be float in meters"
)
return
scale = maps.get_scale(map_id)
delta = scale * radius
#TODO FOR NOW THE X/Y DISTANCE FILTERING IS VERY INEFFICIENT!!!
query = model.Scan.all() \
.filter("map_id = ", map_id) \
.filter("x <= ", x + delta) \
.filter('x >= ', x - delta)
matched_scans = query.fetch(limit)
matched_scans[:] = [
scan for scan in matched_scans if utils.point_in_circle(
scan.location.x, scan.location.y, x, y, delta)
]
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(
utils.json_encode(utils.query_to_array(matched_scans),
True))
return
def get(self):
try:
limit = int(self.request.get('limit', DEFAULT_LIMIT))
except ValueError:
send_400(self.response, "Limit must be an int")
return
arguments = self.request.arguments()
if 't1' in arguments and 't2' in arguments:
#GET /locations/:t1:t2
t1 = self.request.get('t1', None)
t2 = self.request.get('t2', None)
[start_date, end_date] = parse_timestamps(t1, t2)
if start_date is None and end_date is None:
send_400(self.response, "Timestamp format issue, t1 and t2 must be UNIX times in seconds")
return
query = model.Location.all() \
.filter("timestamp >= ", start_date) \
.filter("timestamp <= ", end_date) \
.order('-timestamp')
matched_locations = query.fetch(limit)
if 'mac' in arguments:
#GET /locations/:mac:t1:t2
mac_address = self.request.get('mac')
#get the clients with the mac_address
client = model.Client.all().filter("mac = ", mac_address).fetch(1)
#get the client's scans
matching_scans = client.scans.order(-model.Scan.timestamp).fetch(limit)
map_filter = 'map_id' in arguments
map_id = self.request.get('map_id')
matched_locations = []
for scan in matching_scans:
if map_filter and scan.location.map_id == map_id:
matched_locations.append(scan.location)
elif not map_filter:
matched_locations.append(scan.location)
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(utils.json_encode(utils.query_to_array(matched_locations), True))
return
elif 'map_id' in arguments:
#GET /locations/:map_id
map_id = self.request.get('map_id') #TODO check if map exists
query = model.Location.all().filter("map_id = ", map_id)
needs_y_filtering = False
if 'x' in arguments and 'y' in arguments:
#GET /locations/:map_id:x:y:radius
try:
x = int(self.request.get('x'))
y = int(self.request.get('y'))
radius = float(self.request.get('radius', 100))
except ValueError:
send_400(self.response, "x and y must be integers, radius must be float in meters")
return
scale = maps.get_scale(map_id)
delta = scale * radius
#TODO FOR NOW THE X/Y DISTANCE FILTERING IS VERY INEFFICIENT!!!
query.filter("x <= ", x + delta).filter('x >= ', x - delta)
needs_y_filtering = True
locations = query.fetch(limit)
if needs_y_filtering:
locations[:] = [location for location in locations
if utils.point_in_circle(location.x, location.y, x, y, delta)]
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(utils.json_encode(utils.query_to_array(locations), True))
return
elif 'mac' in arguments:
#GET /locations/:mac(:limit)
try:
mac_address = int(self.request.get('mac'))
except ValueError:
send_400(self.response, "mac_address must be formatted as an int")
return
#get the clients with the mac_address
client = model.Client.all().filter("mac = ", mac_address).fetch(1)
if len(client) == 0:
matching_scans = []
else:
#get the client's scans
matching_scans = client[0].scans.order("-timestamp").fetch(limit)
matched_locations = []
for scan in matching_scans:
matched_locations.append(scan.location)
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(utils.json_encode(utils.query_to_array(matched_locations), True))
return
#nothing matched
send_400(self.response, "Argument combination not supported or not enough arguments")