def add_day_data():
log.info("/add_day_data")
pretty_print_POST(request)
response = json.loads(request.data)
ok_add, ok_once, ok_inc = False, False, False
if len(db_fetch(query.add_day_data_check_rows.format(response["date"],response["userid"]))) == 0:
log.info("adding row for date {} for user {}".format(response["date"],response["userid"]))
statement = query.add_day_data_add_row.format(response["date"],response["userid"])
log.info("query: {}".format(statement))
ok_add = db_insup(statement)
if response["add_type"] == "once":
statement = query.add_day_data_set_value_once.format(response["type"],response["value"],response["date"],response["userid"])
log.info("query: {}".format(statement))
ok_once = db_insup(statement)
if response["add_type"] == "increment":
statement = query.add_day_data_fetch_value.format(response["type"],response["date"],response["userid"])
log.info("query: {}".format(statement))
result = db_fetch(statement)
new_val = float(response["value"])
if result[0][0]:
new_val += float(result[0][0])
log.info("updating value")
statement = query.add_day_data_set_value_once.format(response["type"],new_val,response["date"],response["userid"])
log.info("query: {}".format(statement))
ok_inc = db_insup(statement)
return Response(json.dumps({"inserted": ok_add or ok_once or ok_inc}), headers=HEADER, status=200, mimetype='application/json')
def get_session_info():
log.info('/get_session_info')
args = request.args.to_dict()
statement = query.get_session_info1.format(args["start_date"],args["end_date"],args["userid"])
log.info("query: {}".format(statement))
result_s1 = db_fetch(statement)
session_ids = []
for r in result_s1:
session_ids.append(r[0])
session_ids = tuple(session_ids)
statement = query.get_session_info2.format(session_ids)
log.info("query: {}".format(statement))
result_s2 = db_fetch(statement)[::-1]
send_data = {"userid":args["userid"], "session_info":[]}
for r in result_s1:
cp = templates.get_session_info.copy()
cp["session_id"],cp["date"],cp["start_timestamp"],cp["end_timestamp"],cp["duration"],\
cp["rpe"],cp["ctl"],cp["atl"],cp["tsb"],cp["acwr"],cp["ewma"] = r[0],str(r[1]),str(r[3]),\
str(r[4]),r[5],r[7],r[8],r[9],r[10],r[11],r[12]
answers = [{"q_id":0,"val":r[6]}]
while result_s2 and result_s2[-1][0] == r[0]:
ans = result_s2.pop()
answers.append({"q_id":ans[1],"val":ans[2]})
cp["answers"] = answers
send_data["session_info"].append(cp)
return Response(json.dumps(send_data), headers=HEADER, status=200, mimetype='application/json')
def get_event():
log.info('/get_event')
args = request.args.to_dict()["userid"]
statement = query.get_event.format(args)
log.info("query: {}".format(statement))
result = db_fetch(statement)
send_data = []
for res in result:
event_data = templates.get_event.copy()
start_day_split,start_time_split,end_day_split,end_time_split = \
str(res[0]).split(' ')[0].split("-"), str(res[0]).split(' ')[1].split(":"),\
str(res[1]).split(' ')[0].split("-"), str(res[1]).split(' ')[1].split(":")
start,end = templates.get_event_sched.copy(), templates.get_event_sched.copy()
start["year"],start["month"],start["day"],start["hours"],start["minutes"],start["seconds"] = \
start_day_split[0],start_day_split[1],start_day_split[2],start_time_split[0],start_time_split[1],\
start_time_split[2]
end["year"],end["month"],end["day"],end["hours"],end["minutes"],end["seconds"] = \
end_day_split[0],end_day_split[1],end_day_split[2],end_time_split[0],end_time_split[1],\
end_time_split[2]
event_data["start"],event_data["end"],event_data["description"], event_data["title"] = \
start,end,res[2],res[3]
send_data.append(event_data)
return Response(json.dumps({"userid":args, "events":send_data}), headers=HEADER, status=200, mimetype='application/json')
def get_athelete_ids():
log.info('/get_athelete_ids')
args = request.args.to_dict()["coachid"]
statement1 = query.get_athelete_ids1.format(args)
log.info("query: {}".format(statement1))
result = db_fetch(statement1)
send_data = []
if len(result)>0:
statement2 = query.get_athelete_ids2.format(result[0][0])
log.info("query: {}".format(statement2))
result = db_fetch(statement2)
for r in result:
if r[0] != args:
send_data.append({"id":r[0],"name":r[1]})
return Response(json.dumps({"athelete_ids":send_data}), headers=HEADER, status=200, mimetype='application/json')
def donate_item():
try:
content = request.json
log.info("item to donate: {}".format(content))
result = db_fetch("select id, address from users_hack where name='{}'"\
.format(content['d_name']))
if result:
id = result[0][0]
address = result[0][0]
else:
raise ValueError('No ID found for {}'.format(content['d_name']))
geocode_result = gmaps.geocode(
content['addr'])[0]['geometry']['location']
insert_procurement(id, geocode_result, content['items'])
resp = {
u"message":
u"Thank you for the good gesture.\nYour request \
has been submitted. you will be notified once a pickup is schduled"
}
return Response(json.dumps(resp), headers=HEADER, status=200, \
mimetype='application/json')
except Exception as e:
resp = {u"message": u"could not make request...{}".format(e)}
raise
finally:
pass
def get_max_metric(*args, **kwargs):
'''
userid, start_timestamp, end_timestamp, metric_label
'''
log.info("/get_max_metric")
args = request.args.to_dict()
statement = query.get_max_metric.format(str(args['userid']),args\
['metric_label'],args['start_timestamp'],args['end_timestamp'])
send_data = {
u"label": args['metric_label'],
u"values": []
}
log.info('query: {}'.format(statement))
result = db_fetch(statement)
log.info(result)
for res in result:
temp = templates.get_max_metric.copy()
if res[0]:
temp["event_timestamp"] = str(res[0])
if res[1]:
temp["max_metric_value"] = str(res[1])
send_data["values"].append(temp)
log.info("sent response \n{}".format(pprint.pformat(send_data)))
return Response(json.dumps(send_data), headers=HEADER, status=200, mimetype='application/json')
def get_device_key():
log.info('/get_device_key')
args = request.args.to_dict()["userid"]
statement = query.get_device_key.format(args)
log.info("query: {}".format(statement))
result = db_fetch(statement)
return Response(json.dumps({"device_key":result[0][0]}), headers=HEADER, status=200, mimetype='application/json')
def is_uid_available():
log.info('/is_uid_available')
args = (request.args.to_dict()["userid"],)
statement = query.is_uid_available
result = set(db_fetch(statement))
send_data = {"avl": args not in result}
return Response(json.dumps(send_data), headers=HEADER, status=200, mimetype='application/json')
def get_session_id():
log.info('/get_session_id')
args = request.args.to_dict()
statement = query.get_session_id.format(args["date"],args["userid"])
log.info("query: {}".format(statement))
result = db_fetch(statement)
return Response(json.dumps({"session_id":result[0][0],"userid":args["userid"]}), headers=HEADER, status=200, mimetype='application/json')
def get_question_response():
log.info('/get_question_response')
args = request.args.to_dict()["userid"]
statement = "SELECT qid,question from questionnaire"
log.info("query: {}".format(statement))
result = db_fetch(statement)
lookup = dict(result)
statement = query.get_question_response.format(args)
log.info("query: {}".format(statement))
result = db_fetch(statement)
send_ans = []
for res in result:
send_ans.append({"qid": res[0], "qstn":lookup[res[0]], "response":res[1]})
return Response(json.dumps({"user_id":args, "answers":send_ans}), headers=HEADER, status=200, mimetype='application/json')
def get_sports():
log.info('/get_sports')
statement = query.get_sports
result = db_fetch(statement)
send_data = []
for r in result:
send_data.append(collections.OrderedDict({u"s_id": r[0], u"s_nsme": r[1], u"s_type":r[2]}))
return Response(json.dumps(send_data), headers=HEADER, status=200, mimetype='application/json')
def get_questions():
log.info("/get_questions")
statement = query.get_questions
result = db_fetch(statement)
send_data = []
for r in result:
send_data.append(collections.OrderedDict({u"q_id": r[0], u"qst": r[1]}))
return Response(json.dumps(send_data), headers=HEADER, status=200, mimetype='application/json')
def get_coach_types():
log.info('/get_coach_types')
statement = query.get_coach_types
log.info("query: {}".format(statement))
result = db_fetch(statement)
send_data = []
for r in result:
send_data.append(collections.OrderedDict({u"type_id": r[0], u"type": r[1]}))
return Response(json.dumps(send_data), headers=HEADER, status=200, mimetype='application/json')
def get_session_questions():
log.info('/get_session_questions')
statement = query.get_session_questions
log.info("query: {}".format(statement))
result = db_fetch(statement)
send_data = []
for r in result:
send_data.append({"q_id":r[0],"qstn":r[1]})
return Response(json.dumps({"questions":send_data}), headers=HEADER, status=200, mimetype='application/json')
def get_id_from_device_key():
log.info('/get_id_from_device_key')
args = request.args.to_dict()["device_key"]
statement = query.get_id_from_device_key.format(args)
log.info("query: {}".format(statement))
result = db_fetch(statement)
send_data = "device_key does not exist"
if len(result)>0:
send_data = result[0][0]
return Response(json.dumps({"user_id":send_data}), headers=HEADER, status=200, mimetype='application/json')
def get_athletes_for_coach():
log.info('/get_athletes_for_coach')
args = request.args.to_dict()["coachid"]
statement = query.get_athletes_for_coach.format(args)
log.info("query: {}".format(statement))
result = db_fetch(statement)
send_data = []
for r in result:
send_data.append({"id":r[0],"name":r[1]})
return Response(json.dumps({"atheletes":send_data}), headers=HEADER, status=200, mimetype='application/json')
def driver_see_pickups():
driver_addr = request.json['addr']
geocode_result = gmaps.geocode(driver_addr)[0]['geometry']['location']
log.info("driver address {}".format(geocode_result))
lat_bound_low, lat_bound_high = geocode_result[
'lat'] - 0.05, geocode_result['lat'] + 0.05
lng_bound_low, lng_bound_high = geocode_result[
'lng'] - 0.05, geocode_result['lng'] + 0.05
log.info("radius for driver: {},{},{},{}"\
.format(lat_bound_low, lat_bound_high,lng_bound_low, lng_bound_high))
result = db_fetch("select * from procurement where status='N'")
#doner_addr = set()
doner_addr = set([(res[6], res[2]) for res in result])
'''
for res in result:
doner_addr.add((res[6],res[2]))
'''
resp = {"possible_pickups": []}
for add in doner_addr:
lat = add[0].split(',')[0]
lng = add[0].split(',')[1]
if lat_bound_low <= float(lat) <= lat_bound_high \
and lng_bound_low <= float(lng) <= lng_bound_high:
pickup_info = dict()
log.info("nearby doner lat: {}, long: {}".format(lat, lng))
statement = "select name, address, phone from users_hack where id='{}'".format(
res[2])
log.info("fetch statement: {}".format(statement))
doner_info = db_fetch(statement)
pickup_info['d_id'] = res[2]
pickup_info['lat'] = lat
pickup_info['lng'] = lng
pickup_info['name'] = doner_info[0][0]
pickup_info['addr'] = doner_info[0][1]
pickup_info['phone'] = doner_info[0][2]
resp['possible_pickups'].append(pickup_info)
return Response(json.dumps(resp),
headers=HEADER,
status=200,
mimetype='application/json')
def get_user_details(userid):
user_data = templates.get_user_info.copy()
statement_users = query.get_user_info_1.format(userid)
log.info("query: {}".format(statement_users))
result = db_fetch(statement_users)
user_data["userid"] = userid
if len(result)>0:
user_data["name"] = result[0][0]
user_data["email"] = result[0][1]
user_data["device_key"] = result[0][2]
user_data["user_present"] = True
statement_user_info = query.get_user_info_2.format(userid)
log.info("query: {}".format(statement_user_info))
result = db_fetch(statement_user_info)
if len(result)>0:
user_data["age"], user_data["gender"], user_data["height"], user_data["weight"],\
user_data["sport_id"],user_data["organization"], user_data["role"] = result[0][0], \
result[0][1],result[0][2],result[0][3],result[0][4],result[0][5],result[0][6]
return user_data
def update_procurement(upd_qty):
log.info("upd_qty = {}".format(upd_qty))
for resource_id, qty in upd_qty.items():
statement = "select current_inventory, deficit from resource where id='{}'".format(
resource_id)
res = db_fetch(statement)
current_inventory = str(int(res[0][0]) + qty)
deficit = str(int(res[0][1]) - qty)
statement = "update resource set current_inventory='{}', deficit='{}' where id='{}'"\
.format(current_inventory,deficit,resource_id)
log.info("update statement: {}".format(statement))
db_insup(statement)
def get_user_info_post():
log.info('/get_user_info')
pretty_print_POST(request)
response = json.loads(request.data)
statement_validate = query.get_user_info_validate_user.format(response["userid"])
log.info("query: {}".format(statement_validate))
result = db_fetch(statement_validate)
if len(result) == 0:
return Response(json.dumps({"error": "user not registered"}), headers=HEADER, status=200, mimetype='application/json')
if result[0][0] != response["password"]:
return Response(json.dumps({"error": "password invalid"}), headers=HEADER, status=200, mimetype='application/json')
user_data = get_user_details(response["userid"])
return Response(json.dumps(user_data), headers=HEADER, status=200, mimetype='application/json')
def get_items():
statement = "select * from resource"
log.info('query: {}'.format(statement))
result = db_fetch(statement)
log.info(result)
send_data = {u"items": []}
for res in result:
line_item = dict()
if int(res[4]) > 0: # deficit
line_item['item'] = res[2]
line_item['qty'] = int(res[4])
send_data['items'].append(line_item)
return Response(json.dumps(send_data), headers=HEADER, status=200, \
mimetype='application/json')
def get_injury_history():
log.info('/get_injury_history')
args = request.args.to_dict()["userid"]
statement = query.get_injury_history.format(args)
log.info("query: {}".format(statement))
result = db_fetch(statement)
send_data = []
for res in result:
injury_data = templates.get_injury_data.copy()
injury_data["desc"],injury_data["date"],injury_data["type"],\
injury_data["location"],injury_data["region"],injury_data["intensity"]\
= res[1],str(res[2]),res[3],res[4],res[5],res[6]
send_data.append(injury_data)
return Response(json.dumps(send_data), headers=HEADER, status=200, mimetype='application/json')
def insert_procurement(doner_id, addr, items):
log.info("in update function {}, {}, {}".format(doner_id, addr, items))
for key, val in items.items():
statement = "select id from resource where name='{}'".format(key)
result = db_fetch(statement)
if result:
resource_id = result[0][0]
#log.info("addr = {}".format(addr))
coordinate = str(addr['lat']) + "," + str(addr['lng'])
statement = "INSERT INTO public.procurement (resource_id, quantity, donor_id, coordinate, status) \
VALUES('{}','{}','{}','{}','{}')".format(resource_id, str(val),
doner_id, coordinate, 'N')
log.info("statement to execute: {}".format(statement))
db_insup(statement)
else:
raise ValueError('No result found for {}'.format(key))
def get_forecast():
log.info('/get_forecast')
args = request.args.to_dict()
statement = query.get_forecast.format(args["userid"],args["start_date"])
log.info("query: {}".format(statement))
result = db_fetch(statement)
data, index = [], []
for r in result[::-1]:
data.append(r[1])
index.append(str(r[0]))
df = pd.DataFrame(data=data,index=index,columns=['acwr'])
try:
forecasted = forecast(df['acwr'])
except Exception as e:
forecasted = e.message
log.error(e)
return Response(json.dumps({"forecast":forecasted}), headers=HEADER, status=200, mimetype='application/json')
def get_daily_health_data():
log.info('/get_daily_health_data')
args = request.args.to_dict()
statement = query.get_daily_health_data.format(args["start_date"],args["end_date"],args["userid"])
log.info("query: {}".format(statement))
result = db_fetch(statement)
send_data = {}
for r in result:
u_data = templates.get_daily_health_data.copy()
u_data["calories"], u_data["steps"], u_data["floors"], u_data["distance"], u_data["minutes_sitting"],\
u_data["minutes_of_slow_activity"], u_data["minutes_of_moderate_activity"],\
u_data["minutes_of_intense_activity"], u_data["calories_activty"] = r[2], r[3], r[4], r[5], r[6], r[7],\
r[8], r[9], r[10]
send_data[str(r[0])] = u_data
if not send_data:
send_data = None
return Response(json.dumps(send_data), headers=HEADER, status=200, mimetype='application/json')
def pickup_item():
resp = {"msg": "OK"}
contents = request.json
upd_qty = {}
for pickup in contents["scheduled_pickups"]:
statement = "select resource_id, quantity from procurement \
where donor_id='{}' and status='N'".format(pickup["doner_id"])
result = db_fetch(statement)
statement = "update procurement set status='P' where donor_id='{}'"\
.format(pickup["doner_id"])
## TODO update pickup schedule in db
db_insup(statement)
for res in result:
if res[0] not in upd_qty:
upd_qty[res[0]] = int(res[1])
else:
upd_qty[res[0]] += int(res[1])
update_procurement(upd_qty)
return Response(json.dumps(resp),
headers=HEADER,
status=200,
mimetype='application/json')
def compute_resource_helper(disaster):
''' Computes required resources based on calamity and required resources'''
disaster_type = disaster['disaster_type']
category = disaster['category']
population = int(disaster['population'])
items = templates.resource_requirements[disaster_type][category]["items"]
recovery_time = templates.resource_requirements[disaster_type][category][
"recovery_time"]
required_items = {}
for item, qty in items.iteritems():
required_items[item] = int(population * qty * recovery_time)
log.info("required_items: {}".format(required_items[item]))
query = "select name, deficit, current_inventory, storage_id from resource where name in (" + str(
items.keys())[1:-1:] + ") and storage_id = '1'"
log.info("compite_resource_query_fetch: {}".format(query))
result = db_fetch(query)
for row in result:
if (required_items[row[0]] < row[2]):
query = "update resource set deficit=" + \
str(int(row[2]) + required_items[row[0]]) + \
" where name='" + row[0] + "';"
log.info("compute_resource_query_insup: {}".format(query))
db_insup(query)
